wp-typia 0.20.5 → 0.22.0

package/dist-bunli/{command-list-pztcgga5.js → command-list-jt1a1w7r.js}

@@ -2,9 +2,12 @@
 import {
   ADD_OPTION_METADATA,
   CREATE_OPTION_METADATA,
+  DOCTOR_OPTION_METADATA,
+  INIT_OPTION_METADATA,
   MIGRATE_OPTION_METADATA,
   SYNC_OPTION_METADATA,
   TEMPLATES_OPTION_METADATA,
+  WP_TYPIA_TOP_LEVEL_COMMAND_NAMES,
   buildCommandOptions,
   emitCliDiagnosticFailure,
   getAddBlockDefaults,
@@ -13,7 +16,7 @@ import {
   package_default,
   prefersStructuredCliOutput,
   resolveCommandOptionValues
-} from "./cli-xnh2s5kz.js";
+} from "./cli-ktp869eh.js";
 import {
   Result,
   TaggedError,
@@ -30,12 +33,13 @@ import"./cli-ac2ebaf8.js";
 import {
   formatPackageExecCommand
 } from "./cli-sj5mtyzj.js";
-import {
-  CLI_DIAGNOSTIC_CODES
-} from "./cli-xxzpb58s.js";
 import {
   createManagedTempRoot
 } from "./cli-t73q5aqz.js";
+import {
+  CLI_DIAGNOSTIC_CODES,
+  createCliDiagnosticCodeError
+} from "./cli-p95wr1q8.js";
 import {
   __require,
   __toESM
@@ -66,17 +70,6 @@ function resolveBundledModuleHref(baseUrl, candidates, options = {}) {
 }
 
 // src/add-kind-registry.ts
-var ADD_KIND_IDS = [
-  "block",
-  "variation",
-  "pattern",
-  "binding-source",
-  "rest-resource",
-  "ability",
-  "ai-feature",
-  "editor-plugin",
-  "hooked-block"
-];
 var BLOCK_VISIBLE_FIELD_ORDER = [
   "kind",
   "name",
@@ -86,30 +79,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(option2) {
+  const details = [
+    option2.description,
+    option2.extends.length > 0 ? `extends ${option2.extends.join(", ")}` : undefined
+  ].filter((value) => typeof value === "string" && value.length > 0);
+  return details.length > 0 ? details.join(" \xB7 ") : undefined;
+}
+function toExternalLayerPromptOptions(options) {
+  return options.map((option2) => ({
+    hint: formatExternalLayerSelectHint(option2),
+    label: option2.id,
+    value: option2.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.",
@@ -125,6 +211,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);
@@ -137,8 +267,8 @@ var ADD_KIND_REGISTRY = {
       }
       return true;
     })
-  },
-  ability: {
+  }),
+  ability: defineAddKindRegistryEntry({
     completion: {
       nextSteps: (values) => [
         `Review src/abilities/${values.abilitySlug}/ and inc/abilities/${values.abilitySlug}.php.`,
@@ -152,9 +282,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}/.`,
@@ -167,11 +312,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.`,
@@ -187,9 +350,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.`,
@@ -203,9 +393,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.`,
@@ -221,9 +510,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.`,
@@ -238,9 +548,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.`,
@@ -255,9 +585,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 {
@@ -272,6 +630,9 @@ function formatAddKindList() {
 function formatAddKindUsagePlaceholder() {
   return `<${ADD_KIND_IDS.join("|")}>`;
 }
+function supportsAddKindDryRun(kind) {
+  return ADD_KIND_REGISTRY[kind].supportsDryRun;
+}
 
 // src/runtime-bridge-add-dry-run.ts
 import fs2 from "fs";
@@ -435,6 +796,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;
@@ -444,6 +808,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;
@@ -509,6 +876,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);
 }
@@ -554,28 +992,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
   };
 }
@@ -664,16 +1105,16 @@ function printBlock(lines, printLine) {
     printLine(line);
   }
 }
-function formatExternalLayerSelectHint(option2) {
+function formatExternalLayerSelectHint2(option2) {
   const details = [
     option2.description,
     option2.extends.length > 0 ? `extends ${option2.extends.join(", ")}` : undefined
   ].filter((value) => typeof value === "string" && value.length > 0);
   return details.length > 0 ? details.join(" \xB7 ") : undefined;
 }
-function toExternalLayerPromptOptions(options) {
+function toExternalLayerPromptOptions2(options) {
   return options.map((option2) => ({
-    hint: formatExternalLayerSelectHint(option2),
+    hint: formatExternalLayerSelectHint2(option2),
     label: option2.id,
     value: option2.id
   }));
@@ -709,7 +1150,7 @@ function resolveSyncExecutionTarget(subcommand) {
   if (subcommand === "ai") {
     return "ai";
   }
-  throw new Error(`Unknown sync subcommand "${subcommand}". Expected one of: "ai".`);
+  throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_COMMAND, `Unknown sync subcommand "${subcommand}". Expected one of: "ai".`);
 }
 function formatRunScript(packageManagerId, scriptName, extraArgs = "") {
   const args = extraArgs.trim();
@@ -737,7 +1178,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 createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.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 ?? "");
@@ -827,7 +1268,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 createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.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) {
@@ -865,7 +1306,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 createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.CONFIGURATION_MISSING, `Expected ${project.packageJsonPath} to define a \`sync-ai\` script for \`wp-typia sync ai\`.`);
     }
     return [syncAiCommand2];
   }
@@ -874,7 +1315,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 createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.CONFIGURATION_MISSING, `Expected ${project.packageJsonPath} to define either a \`sync\` or \`sync-types\` script.`);
   }
   const plannedCommands = [syncTypesCommand];
   const syncRestCommand = createSyncPlannedCommand(project, "sync-rest", extraArgs);
@@ -939,14 +1380,14 @@ async function executeSyncCommand({
 }
 
 // src/runtime-bridge.ts
-var loadCliAddRuntime = () => import("./cli-add-6byyahb8.js");
-var loadCliDiagnosticsRuntime = () => import("./cli-diagnostics-zecc6w1f.js");
-var loadCliDoctorRuntime = () => import("./cli-doctor-2bc4sq7v.js");
-var loadCliInitRuntime = () => import("./cli-init-gdyp9enw.js");
+var loadCliAddRuntime = () => import("./cli-add-kjhghdqq.js");
+var loadCliDiagnosticsRuntime = () => import("./cli-diagnostics-5dvztm7q.js");
+var loadCliDoctorRuntime = () => import("./cli-doctor-p3jxvn0k.js");
+var loadCliInitRuntime = () => import("./cli-init-djhwr245.js");
 var loadCliPromptRuntime = () => import("./cli-prompt-614tq57c.js");
-var loadCliScaffoldRuntime = () => import("./cli-scaffold-19gyvxxt.js");
+var loadCliScaffoldRuntime = () => import("./cli-scaffold-376yw891.js");
 var loadCliTemplatesRuntime = () => import("./cli-templates-9t2a7zqd.js");
-var loadMigrationsRuntime = () => import("./migrations-1p6mbkyw.js");
+var loadMigrationsRuntime = () => import("./migrations-nwas5bwt.js");
 async function wrapCliCommandError(command, error) {
   const { createCliCommandError } = await loadCliDiagnosticsRuntime();
   return createCliCommandError({ command, error });
@@ -960,23 +1401,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 createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, `\`--${name}\` requires a value.`);
   }
   const trimmed = value.trim();
   return trimmed.length > 0 ? trimmed : undefined;
@@ -991,223 +1422,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,
@@ -1231,6 +1445,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" },
@@ -1319,7 +1553,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,
@@ -1372,16 +1606,17 @@ async function executeAddCommand({
       if (emitOutput) {
         printLine(addRuntime.formatAddHelpText());
       }
-      throw new Error(`\`wp-typia add\` requires <kind>. Usage: wp-typia add ${formatAddKindUsagePlaceholder()} ...`);
+      throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.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 createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_COMMAND, `Unknown add kind "${kind}". Expected one of: ${formatAddKindList()}.`);
     }
-    return await ADD_KIND_EXECUTION_REGISTRY[kind]({
+    if (dryRun && !supportsAddKindDryRun(kind)) {
+      throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, `\`wp-typia add ${kind}\` does not support \`--dry-run\` yet.`);
+    }
+    const executionContext = {
       addRuntime,
       cwd,
-      dryRun,
-      emitOutput,
       flags,
       getOrCreatePrompt: async () => {
         if (activePrompt) {
@@ -1393,8 +1628,13 @@ async function executeAddCommand({
       },
       isInteractiveSession,
       name,
-      printLine,
       warnLine
+    };
+    return await executePlannedAddKind(kind, executionContext, {
+      cwd,
+      dryRun,
+      emitOutput,
+      printLine
     });
   } catch (error) {
     if (!shouldWrapCliCommandError({ emitOutput })) {
@@ -1424,22 +1664,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 createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, "`wp-typia templates inspect` requires <template-id>.");
     }
     const template = getTemplateById(flags.id);
     if (!template) {
-      throw new Error(`Unknown template "${flags.id}".`);
+      throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, `Unknown template "${flags.id}".`);
     }
     printBlock([formatTemplateDetails(template)], printLine);
     return;
   }
-  throw new Error(`Unknown templates subcommand "${subcommand}". Expected list or inspect.`);
+  throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.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("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, {
@@ -1449,6 +1693,9 @@ async function executeInitCommand({ cwd, projectDir }, options = {}) {
     }
     return plan;
   } catch (error) {
+    if (!shouldWrapCliCommandError({ emitOutput: options.emitOutput })) {
+      throw error;
+    }
     throw await wrapCliCommandError("init", error);
   }
 }
@@ -1946,7 +2193,7 @@ function loadAddFlow() {
 var addOptions = buildCommandOptions(ADD_OPTION_METADATA);
 var addCommand = defineCommand({
   defaultFormat: "toon",
-  description: "Extend an official wp-typia workspace with blocks, variations, patterns, binding sources, plugin-level REST resources, workflow abilities, server-only AI features, editor plugins, or hooked blocks.",
+  description: "Extend an official wp-typia workspace with blocks, variations, block styles, transforms, patterns, binding sources, plugin-level REST resources, workflow abilities, server-only AI features, editor plugins, or hooked blocks.",
   handler: async (args) => {
     const prefersStructuredOutput = prefersStructuredCliOutput(args);
     try {
@@ -1959,7 +2206,12 @@ var addCommand = defineCommand({
           kind: args.positional[0],
           name: args.positional[1]
         });
-        args.output({ completion });
+        args.output(buildStructuredCompletionSuccessPayload("add", completion, {
+          dryRun: Boolean(args.flags["dry-run"]),
+          kind: args.positional[0],
+          name: args.positional[1],
+          projectDir: extractCompletionProjectDir(completion) ?? args.cwd
+        }));
         return;
       }
       await executeAddCommand({
@@ -1994,7 +2246,7 @@ var addCommand = defineCommand({
             kind: args.positional[0] ?? "block",
             name: args.positional[1] ?? "",
             position: initialValues.position ?? "after",
-            slot: initialValues.slot ?? "PluginSidebar"
+            slot: initialValues.slot ?? "sidebar"
           }
         }
       });
@@ -2023,9 +2275,11 @@ var createCommand = defineCommand({
   defaultFormat: "toon",
   description: "Scaffold a new wp-typia project.",
   handler: async (args) => {
+    const prefersStructuredOutput = prefersStructuredCliOutput(args);
     const projectDir = args.positional[0];
     if (!projectDir) {
       emitCliDiagnosticFailure(args, {
+        code: CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT,
         command: "create",
         detailLines: [
           "`wp-typia create` requires <project-dir>.",
@@ -2035,11 +2289,20 @@ var createCommand = defineCommand({
       return;
     }
     try {
-      await executeCreateCommand({
+      const completion = await executeCreateCommand({
         cwd: args.cwd,
+        emitOutput: !prefersStructuredOutput,
         flags: args.flags,
+        interactive: prefersStructuredOutput ? false : undefined,
         projectDir
       });
+      if (prefersStructuredOutput) {
+        args.output(buildStructuredCompletionSuccessPayload("create", completion, {
+          dryRun: Boolean(args.flags["dry-run"]),
+          projectDir: extractCompletionProjectDir(completion) ?? projectDir,
+          template: typeof args.flags.template === "string" ? args.flags.template : undefined
+        }));
+      }
     } catch (error) {
       emitCliDiagnosticFailure(args, {
         command: "create",
@@ -2083,8 +2346,8 @@ var doctorCommand = defineCommand({
     const prefersStructuredOutput = prefersStructuredCliOutput(args);
     if (prefersStructuredOutput) {
       const [{ getDoctorChecks }, { getDoctorFailureDetailLines }] = await Promise.all([
-        import("./cli-doctor-2bc4sq7v.js"),
-        import("./cli-diagnostics-zecc6w1f.js")
+        import("./cli-doctor-p3jxvn0k.js"),
+        import("./cli-diagnostics-5dvztm7q.js")
       ]);
       const checks = await getDoctorChecks(args.cwd);
       if (checks.some((check) => check.status === "fail")) {
@@ -2109,22 +2372,25 @@ var doctorCommand = defineCommand({
       });
     }
   },
-  name: "doctor"
+  name: "doctor",
+  options: buildCommandOptions(DOCTOR_OPTION_METADATA)
 });
 
 // src/commands/init.ts
 var initCommand = defineCommand({
   defaultFormat: "toon",
-  description: "Preview the minimum wp-typia retrofit plan for an existing project.",
+  description: "Preview or apply the minimum wp-typia retrofit plan for an existing project.",
   handler: async (args) => {
     const prefersStructuredOutput = prefersStructuredCliOutput(args);
     try {
       const plan = await executeInitCommand({
+        apply: Boolean(args.flags.apply),
         cwd: args.cwd,
+        packageManager: typeof args.flags["package-manager"] === "string" ? args.flags["package-manager"] : undefined,
         projectDir: args.positional[0]
       }, { emitOutput: !prefersStructuredOutput });
       if (prefersStructuredOutput) {
-        args.output({ init: plan });
+        args.output(buildStructuredInitSuccessPayload(plan));
       }
     } catch (error) {
       emitCliDiagnosticFailure(args, {
@@ -2134,7 +2400,7 @@ var initCommand = defineCommand({
     }
   },
   name: "init",
-  options: {}
+  options: buildCommandOptions(INIT_OPTION_METADATA)
 });
 
 // src/mcp.ts
@@ -2934,18 +3200,19 @@ var templatesCommand = defineCommand({
 });
 
 // src/command-list.ts
-var wpTypiaCommands = [
-  createCommand,
-  initCommand,
-  syncCommand,
-  addCommand,
-  migrateCommand,
-  templatesCommand,
-  doctorCommand,
-  mcpCommand
-];
+var WP_TYPIA_COMMANDS_BY_NAME = {
+  add: addCommand,
+  create: createCommand,
+  doctor: doctorCommand,
+  init: initCommand,
+  mcp: mcpCommand,
+  migrate: migrateCommand,
+  sync: syncCommand,
+  templates: templatesCommand
+};
+var wpTypiaCommands = WP_TYPIA_TOP_LEVEL_COMMAND_NAMES.map((commandName) => WP_TYPIA_COMMANDS_BY_NAME[commandName]);
 export {
   wpTypiaCommands
 };
 
-//# debugId=F507311661D3283E64756E2164756E21
+//# debugId=45C7A2D5B9B34F8064756E2164756E21