wp-typia 0.22.8 → 0.22.9

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.22.8",
+  version: "0.22.9",
   description: "Canonical CLI package for wp-typia scaffolding and project workflows",
   packageManager: "bun@1.3.11",
   type: "module",
@@ -73,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.22.8",
+    "@wp-typia/project-tools": "0.22.9",
     "better-result": "^2.7.0",
     react: "^19.2.5",
     "react-dom": "^19.2.5",
@@ -97,7 +97,7 @@ var package_default = {
 
 // src/node-cli.ts
 import {
-  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES11,
+  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES12,
   createCliCommandError as createCliCommandError5,
   formatCliDiagnosticError,
   serializeCliDiagnosticError as serializeCliDiagnosticError2
@@ -929,80 +929,18 @@ function extractWpTypiaConfigOverride(argv) {
 
 // src/runtime-bridge.ts
 import {
-  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES7,
-  createCliDiagnosticCodeError as createCliDiagnosticCodeError6
-} from "@wp-typia/project-tools/cli-diagnostics";
-
-// src/add-kind-registry.ts
-import {
-  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES5,
-  createCliDiagnosticCodeError as createCliDiagnosticCodeError4
+  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES8,
+  createCliDiagnosticCodeError as createCliDiagnosticCodeError7
 } from "@wp-typia/project-tools/cli-diagnostics";
 
 // src/add-kind-ids.ts
 import { ADD_KIND_IDS } from "@wp-typia/project-tools/cli-add-kind-ids";
 
-// src/cli-string-flags.ts
+// src/add-kind-registry-shared.ts
 import {
   CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES4,
   createCliDiagnosticCodeError as createCliDiagnosticCodeError3
 } from "@wp-typia/project-tools/cli-diagnostics";
-function readOptionalCliStringFlagValue(flags, name, mode) {
-  const value = flags[name];
-  if (value === undefined || value === null) {
-    return;
-  }
-  if (typeof value !== "string") {
-    throw createCliDiagnosticCodeError3(CLI_DIAGNOSTIC_CODES4.MISSING_ARGUMENT, `\`--${name}\` requires a value.`);
-  }
-  const trimmed = value.trim();
-  if (trimmed.length === 0) {
-    if (mode === "strict") {
-      throw createCliDiagnosticCodeError3(CLI_DIAGNOSTIC_CODES4.MISSING_ARGUMENT, `\`--${name}\` requires a value.`);
-    }
-    return;
-  }
-  return mode === "strict" ? value : trimmed;
-}
-function readOptionalLooseStringFlag(flags, name) {
-  return readOptionalCliStringFlagValue(flags, name, "loose");
-}
-function readOptionalStrictStringFlag(flags, name) {
-  return readOptionalCliStringFlagValue(flags, name, "strict");
-}
-function requireStrictStringFlag(flags, name, message) {
-  const value = readOptionalStrictStringFlag(flags, name);
-  if (!value) {
-    throw createCliDiagnosticCodeError3(CLI_DIAGNOSTIC_CODES4.MISSING_ARGUMENT, message);
-  }
-  return value;
-}
-function readOptionalPairedStrictStringFlags(flags, leftName, rightName, message) {
-  const leftValue = readOptionalStrictStringFlag(flags, leftName);
-  const rightValue = readOptionalStrictStringFlag(flags, rightName);
-  if (Boolean(leftValue) !== Boolean(rightValue)) {
-    throw createCliDiagnosticCodeError3(CLI_DIAGNOSTIC_CODES4.MISSING_ARGUMENT, message);
-  }
-  return [leftValue, rightValue];
-}
-
-// src/external-layer-prompt-options.ts
-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
-  }));
-}
-
-// src/add-kind-registry.ts
 var BLOCK_VISIBLE_FIELD_ORDER = [
   "kind",
   "name",
@@ -1062,7 +1000,7 @@ var NAME_NAMESPACE_VISIBLE_FIELDS = [
 ];
 function requireAddKindName(context, message) {
   if (!context.name) {
-    throw createCliDiagnosticCodeError4(CLI_DIAGNOSTIC_CODES5.MISSING_ARGUMENT, message);
+    throw createCliDiagnosticCodeError3(CLI_DIAGNOSTIC_CODES4.MISSING_ARGUMENT, message);
   }
   return context.name;
 }
@@ -1084,509 +1022,618 @@ function isAddPersistenceTemplate(template) {
 function formatAddBlockTemplateIds(addRuntime) {
   return addRuntime.ADD_BLOCK_TEMPLATE_IDS.join(", ");
 }
+function getMistypedAddBlockTemplateMessage(addRuntime, templateId) {
+  const suggestion = addRuntime.suggestAddBlockTemplateId(templateId);
+  if (!suggestion) {
+    return null;
+  }
+  return `Unknown add-block template "${templateId}". Did you mean "${suggestion}"? Use \`--template ${suggestion}\`, or run \`wp-typia templates list\` to inspect available templates.`;
+}
 function assertAddBlockTemplateId(context, templateId) {
+  if (templateId === "query-loop") {
+    throw createCliDiagnosticCodeError3(CLI_DIAGNOSTIC_CODES4.INVALID_ARGUMENT, "`wp-typia add block --template query-loop` is not supported. Query Loop is a create-time `core/query` variation scaffold, so use `wp-typia create <project-dir> --template query-loop` instead.");
+  }
   if (context.addRuntime.isAddBlockTemplateId(templateId)) {
     return templateId;
   }
-  if (templateId === "query-loop") {
-    throw createCliDiagnosticCodeError4(CLI_DIAGNOSTIC_CODES5.INVALID_ARGUMENT, "`wp-typia add block --template query-loop` is not supported. Query Loop is a create-time `core/query` variation scaffold, so use `wp-typia create <project-dir> --template query-loop` instead.");
+  const mistypedAddBlockTemplateMessage = getMistypedAddBlockTemplateMessage(context.addRuntime, templateId);
+  if (mistypedAddBlockTemplateMessage) {
+    throw createCliDiagnosticCodeError3(CLI_DIAGNOSTIC_CODES4.UNKNOWN_TEMPLATE, mistypedAddBlockTemplateMessage);
   }
-  throw createCliDiagnosticCodeError4(CLI_DIAGNOSTIC_CODES5.UNKNOWN_TEMPLATE, `Unknown add-block template "${templateId}". Expected one of: ${formatAddBlockTemplateIds(context.addRuntime)}. Run \`wp-typia templates list\` to inspect available templates.`);
+  throw createCliDiagnosticCodeError3(CLI_DIAGNOSTIC_CODES4.UNKNOWN_TEMPLATE, `Unknown add-block template "${templateId}". Expected one of: ${formatAddBlockTemplateIds(context.addRuntime)}. Run \`wp-typia templates list\` to inspect available templates.`);
 }
-var ADD_KIND_REGISTRY = {
-  "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 = readOptionalStrictStringFlag(context.flags, "source");
-      return createNamedExecutionPlan(context, {
-        execute: ({ cwd, name: name2 }) => context.addRuntime.runAddAdminViewCommand({
-          adminViewName: name2,
-          cwd,
-          source
-        }),
-        getValues: (result) => ({
-          adminViewSlug: result.adminViewSlug,
-          ...result.source ? { source: result.source } : {}
-        }),
-        missingNameMessage: "`wp-typia add admin-view` requires <name>. Usage: wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>].",
-        name
-      });
-    },
-    sortOrder: 10,
-    supportsDryRun: true,
-    usage: "wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>] [--dry-run]",
-    visibleFieldNames: () => NAME_SOURCE_VISIBLE_FIELDS
-  }),
-  "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",
-    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, attributeName] = readOptionalPairedStrictStringFlags(context.flags, "block", "attribute", "`wp-typia add binding-source` requires --block and --attribute to be provided together.");
-      return createNamedExecutionPlan(context, {
-        execute: ({ cwd, name: name2 }) => context.addRuntime.runAddBindingSourceCommand({
-          attributeName,
-          bindingSourceName: name2,
-          blockName,
-          cwd
-        }),
-        getValues: (result) => ({
-          ...result.attributeName ? { attributeName: result.attributeName } : {},
-          ...result.blockSlug ? { blockSlug: result.blockSlug } : {},
-          bindingSourceSlug: result.bindingSourceSlug
-        }),
-        missingNameMessage: "`wp-typia add binding-source` requires <name>. Usage: wp-typia add binding-source <name> [--block <block-slug|namespace/block-slug> --attribute <attribute>].",
-        name
-      });
-    },
-    sortOrder: 70,
-    supportsDryRun: true,
-    usage: "wp-typia add binding-source <name> [--block <block-slug|namespace/block-slug> --attribute <attribute>] [--dry-run]",
-    visibleFieldNames: () => NAME_BLOCK_ATTRIBUTE_VISIBLE_FIELDS
-  }),
-  block: defineAddKindRegistryEntry({
-    completion: {
-      nextSteps: () => [
-        "Review the generated sources under src/blocks/ and the updated scripts/block-config.ts entry.",
-        "Run your workspace build or dev command to verify the new scaffolded block family."
-      ],
-      summaryLines: (values, projectDir) => [
-        `Blocks: ${values.blockSlugs}`,
-        `Template family: ${values.templateId}`,
-        `Project directory: ${projectDir}`
-      ],
-      title: "Added workspace block"
-    },
-    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 = readOptionalStrictStringFlag(context.flags, "external-layer-id");
-      const externalLayerSource = readOptionalStrictStringFlag(context.flags, "external-layer-source");
-      const shouldPromptForLayerSelection = Boolean(externalLayerSource) && !Boolean(externalLayerId) && context.isInteractiveSession;
-      const selectPrompt = shouldPromptForLayerSelection ? await context.getOrCreatePrompt() : undefined;
-      const alternateRenderTargets = readOptionalStrictStringFlag(context.flags, "alternate-render-targets");
-      const dataStorageMode = readOptionalStrictStringFlag(context.flags, "data-storage");
-      const innerBlocksPreset = readOptionalStrictStringFlag(context.flags, "inner-blocks-preset");
-      const persistencePolicy = readOptionalStrictStringFlag(context.flags, "persistence-policy");
-      const requestedTemplateId = readOptionalStrictStringFlag(context.flags, "template");
-      let resolvedTemplateId = requestedTemplateId ? assertAddBlockTemplateId(context, requestedTemplateId) : undefined;
-      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 createNamedExecutionPlan(context, {
-        execute: ({ cwd, name: name2 }) => context.addRuntime.runAddBlockCommand({
-          alternateRenderTargets,
-          blockName: name2,
-          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,
-        missingNameMessage: "`wp-typia add block` requires <name>. Usage: wp-typia add block <name> [--template <basic|interactivity|persistence|compound>]",
-        name,
-        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);
-      }
-      if (fieldName === "inner-blocks-preset") {
-        return template === "compound";
-      }
-      if (fieldName === "data-storage" || fieldName === "persistence-policy") {
-        return isAddPersistenceTemplate(template);
-      }
-      return true;
-    })
-  }),
-  ability: defineAddKindRegistryEntry({
-    completion: {
-      nextSteps: (values) => [
-        `Review src/abilities/${values.abilitySlug}/ and inc/abilities/${values.abilitySlug}.php.`,
-        "Run `wp-typia sync` or `npm run sync-abilities -- --check` and then your workspace build/dev command to verify the generated workflow ability."
-      ],
-      summaryLines: (values, projectDir) => [
-        `Ability: ${values.abilitySlug}`,
-        `Project directory: ${projectDir}`
-      ],
-      title: "Added workflow ability"
-    },
-    description: "Add a typed server/client workflow ability scaffold",
-    nameLabel: "Ability name",
-    async prepareExecution(context) {
-      return createNamedExecutionPlan(context, {
-        execute: ({ cwd, name }) => context.addRuntime.runAddAbilityCommand({
-          abilityName: name,
-          cwd
-        }),
-        getValues: (result) => ({
-          abilitySlug: result.abilitySlug
-        }),
-        getWarnings: (result) => result.warnings,
-        missingNameMessage: "`wp-typia add ability` requires <name>. Usage: wp-typia add ability <name>.",
-        warnLine: context.warnLine
-      });
-    },
-    sortOrder: 90,
-    supportsDryRun: true,
-    usage: "wp-typia add ability <name> [--dry-run]",
-    visibleFieldNames: () => NAME_ONLY_VISIBLE_FIELDS
-  }),
-  "editor-plugin": defineAddKindRegistryEntry({
-    completion: {
-      nextSteps: (values) => [
-        `Review src/editor-plugins/${values.editorPluginSlug}/.`,
-        "Run your workspace build or dev command to verify the new editor plugin registration."
-      ],
-      summaryLines: (values, projectDir) => [
-        `Editor plugin: ${values.editorPluginSlug}`,
-        `Slot: ${values.slot}`,
-        `Project directory: ${projectDir}`
-      ],
-      title: "Added editor plugin"
-    },
-    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 = readOptionalStrictStringFlag(context.flags, "slot");
-      return createNamedExecutionPlan(context, {
-        execute: ({ cwd, name: name2 }) => context.addRuntime.runAddEditorPluginCommand({
-          cwd,
-          editorPluginName: name2,
-          slot
-        }),
-        getValues: (result) => ({
-          editorPluginSlug: result.editorPluginSlug,
-          slot: result.slot
-        }),
-        missingNameMessage: "`wp-typia add editor-plugin` requires <name>. Usage: wp-typia add editor-plugin <name> [--slot <sidebar|document-setting-panel>].",
-        name
-      });
-    },
-    sortOrder: 120,
-    supportsDryRun: true,
-    usage: "wp-typia add editor-plugin <name> [--slot <sidebar|document-setting-panel>] [--dry-run]",
-    visibleFieldNames: () => NAME_SLOT_VISIBLE_FIELDS
-  }),
-  "hooked-block": defineAddKindRegistryEntry({
-    completion: {
-      nextSteps: (values) => [
-        `Review src/blocks/${values.blockSlug}/block.json for the new blockHooks entry.`,
-        "Run your workspace build or dev command to verify the updated hooked-block metadata."
-      ],
-      summaryLines: (values, projectDir) => [
-        `Block: ${values.blockSlug}`,
-        `Anchor: ${values.anchorBlockName}`,
-        `Position: ${values.position}`,
-        `Project directory: ${projectDir}`
-      ],
-      title: "Added blockHooks metadata"
-    },
-    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 = requireStrictStringFlag(context.flags, "anchor", "`wp-typia add hooked-block` requires --anchor <anchor-block-name>.");
-      const position = requireStrictStringFlag(context.flags, "position", "`wp-typia add hooked-block` requires --position <before|after|firstChild|lastChild>.");
-      return createNamedExecutionPlan(context, {
-        execute: ({ cwd, name: name2 }) => context.addRuntime.runAddHookedBlockCommand({
-          anchorBlockName,
-          blockName: name2,
-          cwd,
-          position
-        }),
-        getValues: (result) => ({
-          anchorBlockName: result.anchorBlockName,
-          blockSlug: result.blockSlug,
-          position: result.position
-        }),
-        missingNameMessage: "`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>.",
-        name
-      });
-    },
-    sortOrder: 110,
-    supportsDryRun: true,
-    usage: "wp-typia add hooked-block <block-slug> --anchor <anchor-block-name> --position <before|after|firstChild|lastChild> [--dry-run]",
-    visibleFieldNames: () => NAME_ANCHOR_POSITION_VISIBLE_FIELDS
-  }),
-  pattern: defineAddKindRegistryEntry({
-    completion: {
-      nextSteps: (values) => [
-        `Review src/patterns/${values.patternSlug}.php.`,
-        "Run your workspace build or dev command to verify the new pattern registration."
-      ],
-      summaryLines: (values, projectDir) => [
-        `Pattern: ${values.patternSlug}`,
-        `Project directory: ${projectDir}`
-      ],
-      title: "Added workspace pattern"
-    },
-    description: "Add a PHP block pattern shell",
-    nameLabel: "Pattern name",
-    async prepareExecution(context) {
-      return createNamedExecutionPlan(context, {
-        execute: ({ cwd, name }) => context.addRuntime.runAddPatternCommand({
-          cwd,
-          patternName: name
-        }),
-        getValues: (result) => ({
-          patternSlug: result.patternSlug
-        }),
-        missingNameMessage: "`wp-typia add pattern` requires <name>. Usage: wp-typia add pattern <name>."
-      });
-    },
-    sortOrder: 60,
-    supportsDryRun: true,
-    usage: "wp-typia add pattern <name> [--dry-run]",
-    visibleFieldNames: () => NAME_ONLY_VISIBLE_FIELDS
-  }),
-  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 = requireStrictStringFlag(context.flags, "block", "`wp-typia add style` requires --block <block-slug>.");
-      return createNamedExecutionPlan(context, {
-        execute: ({ cwd, name: name2 }) => context.addRuntime.runAddBlockStyleCommand({
-          blockName: blockSlug,
-          cwd,
-          styleName: name2
-        }),
-        getValues: (result) => ({
-          blockSlug: result.blockSlug,
-          styleSlug: result.styleSlug
-        }),
-        missingNameMessage: "`wp-typia add style` requires <name>. Usage: wp-typia add style <name> --block <block-slug>.",
-        name
-      });
-    },
-    sortOrder: 40,
-    supportsDryRun: true,
-    usage: "wp-typia add style <name> --block <block-slug> [--dry-run]",
-    visibleFieldNames: () => NAME_BLOCK_VISIBLE_FIELDS
-  }),
-  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 = requireStrictStringFlag(context.flags, "from", "`wp-typia add transform` requires --from <namespace/block>.");
-      const toBlockName = requireStrictStringFlag(context.flags, "to", "`wp-typia add transform` requires --to <block-slug|namespace/block-slug>.");
-      return createNamedExecutionPlan(context, {
-        execute: ({ cwd, name: name2 }) => context.addRuntime.runAddBlockTransformCommand({
-          cwd,
-          fromBlockName,
-          toBlockName,
-          transformName: name2
-        }),
-        getValues: (result) => ({
-          blockSlug: result.blockSlug,
-          fromBlockName: result.fromBlockName,
-          toBlockName: result.toBlockName,
-          transformSlug: result.transformSlug
-        }),
-        missingNameMessage: "`wp-typia add transform` requires <name>. Usage: wp-typia add transform <name> --from <namespace/block> --to <block-slug|namespace/block-slug>.",
-        name
-      });
-    },
-    sortOrder: 50,
-    supportsDryRun: true,
-    usage: "wp-typia add transform <name> --from <namespace/block> --to <block-slug|namespace/block-slug> [--dry-run]",
-    visibleFieldNames: () => NAME_FROM_TO_VISIBLE_FIELDS
-  }),
-  "rest-resource": defineAddKindRegistryEntry({
-    completion: {
-      nextSteps: (values) => [
-        `Review src/rest/${values.restResourceSlug}/ and inc/rest/${values.restResourceSlug}.php.`,
-        "Run your workspace build or dev command to verify the generated REST resource contract."
-      ],
-      summaryLines: (values, projectDir) => [
-        `REST resource: ${values.restResourceSlug}`,
-        `Namespace: ${values.namespace}`,
-        `Methods: ${values.methods}`,
-        `Project directory: ${projectDir}`
-      ],
-      title: "Added plugin-level REST resource"
-    },
-    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 = readOptionalStrictStringFlag(context.flags, "methods");
-      const namespace = readOptionalStrictStringFlag(context.flags, "namespace");
-      return createNamedExecutionPlan(context, {
-        execute: ({ cwd, name: name2 }) => context.addRuntime.runAddRestResourceCommand({
-          cwd,
-          methods,
-          namespace,
-          restResourceName: name2
-        }),
-        getValues: (result) => ({
-          methods: result.methods.join(", "),
-          namespace: result.namespace,
-          restResourceSlug: result.restResourceSlug
-        }),
-        missingNameMessage: "`wp-typia add rest-resource` requires <name>. Usage: wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <list,read,create>].",
-        name
-      });
-    },
-    sortOrder: 80,
-    supportsDryRun: true,
-    usage: "wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <list,read,create,update,delete>] [--dry-run]",
-    visibleFieldNames: () => NAME_NAMESPACE_METHODS_VISIBLE_FIELDS
-  }),
-  "ai-feature": defineAddKindRegistryEntry({
-    completion: {
-      nextSteps: (values) => [
-        `Review src/ai-features/${values.aiFeatureSlug}/ and inc/ai-features/${values.aiFeatureSlug}.php.`,
-        "Run `wp-typia sync-rest` and `wp-typia sync ai` or your workspace build/dev command to verify the generated REST artifacts and AI schema."
-      ],
-      summaryLines: (values, projectDir) => [
-        `AI feature: ${values.aiFeatureSlug}`,
-        `Namespace: ${values.namespace}`,
-        `Project directory: ${projectDir}`
-      ],
-      title: "Added server-only AI feature"
-    },
-    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 = readOptionalStrictStringFlag(context.flags, "namespace");
-      return createNamedExecutionPlan(context, {
-        execute: ({ cwd, name: name2 }) => context.addRuntime.runAddAiFeatureCommand({
-          aiFeatureName: name2,
-          cwd,
-          namespace
-        }),
-        getValues: (result) => ({
-          aiFeatureSlug: result.aiFeatureSlug,
-          namespace: result.namespace
-        }),
-        getWarnings: (result) => result.warnings,
-        missingNameMessage: "`wp-typia add ai-feature` requires <name>. Usage: wp-typia add ai-feature <name> [--namespace <vendor/v1>].",
-        name,
-        warnLine: context.warnLine
-      });
-    },
-    sortOrder: 100,
-    supportsDryRun: true,
-    usage: "wp-typia add ai-feature <name> [--namespace <vendor/v1>] [--dry-run]",
-    visibleFieldNames: () => NAME_NAMESPACE_VISIBLE_FIELDS
-  }),
-  variation: defineAddKindRegistryEntry({
-    completion: {
-      nextSteps: (values) => [
-        `Review src/blocks/${values.blockSlug}/variations/${values.variationSlug}.ts.`,
-        "Run your workspace build or dev command to pick up the new variation."
-      ],
-      summaryLines: (values, projectDir) => [
-        `Variation: ${values.variationSlug}`,
-        `Target block: ${values.blockSlug}`,
-        `Project directory: ${projectDir}`
-      ],
-      title: "Added workspace variation"
-    },
-    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 = requireStrictStringFlag(context.flags, "block", "`wp-typia add variation` requires --block <block-slug>.");
-      return createNamedExecutionPlan(context, {
-        execute: ({ cwd, name: name2 }) => context.addRuntime.runAddVariationCommand({
-          blockName: blockSlug,
-          cwd,
-          variationName: name2
-        }),
-        getValues: (result) => ({
-          blockSlug: result.blockSlug,
-          variationSlug: result.variationSlug
-        }),
-        missingNameMessage: "`wp-typia add variation` requires <name>. Usage: wp-typia add variation <name> --block <block-slug>",
-        name
-      });
-    },
-    sortOrder: 30,
-    supportsDryRun: true,
-    usage: "wp-typia add variation <name> --block <block-slug> [--dry-run]",
-    visibleFieldNames: () => NAME_BLOCK_VISIBLE_FIELDS
+
+// src/add-kinds/ability.ts
+var abilityAddKindEntry = defineAddKindRegistryEntry({
+  completion: {
+    nextSteps: (values) => [
+      `Review src/abilities/${values.abilitySlug}/ and inc/abilities/${values.abilitySlug}.php.`,
+      "Run `wp-typia sync` or `npm run sync-abilities -- --check` and then your workspace build/dev command to verify the generated workflow ability."
+    ],
+    summaryLines: (values, projectDir) => [
+      `Ability: ${values.abilitySlug}`,
+      `Project directory: ${projectDir}`
+    ],
+    title: "Added workflow ability"
+  },
+  description: "Add a typed server/client workflow ability scaffold",
+  nameLabel: "Ability name",
+  async prepareExecution(context) {
+    return createNamedExecutionPlan(context, {
+      execute: ({ cwd, name }) => context.addRuntime.runAddAbilityCommand({
+        abilityName: name,
+        cwd
+      }),
+      getValues: (result) => ({
+        abilitySlug: result.abilitySlug
+      }),
+      getWarnings: (result) => result.warnings,
+      missingNameMessage: "`wp-typia add ability` requires <name>. Usage: wp-typia add ability <name>.",
+      warnLine: context.warnLine
+    });
+  },
+  sortOrder: 90,
+  supportsDryRun: true,
+  usage: "wp-typia add ability <name> [--dry-run]",
+  visibleFieldNames: () => NAME_ONLY_VISIBLE_FIELDS
+});
+
+// src/cli-string-flags.ts
+import {
+  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES5,
+  createCliDiagnosticCodeError as createCliDiagnosticCodeError4
+} from "@wp-typia/project-tools/cli-diagnostics";
+function readOptionalCliStringFlagValue(flags, name, mode) {
+  const value = flags[name];
+  if (value === undefined || value === null) {
+    return;
+  }
+  if (typeof value !== "string") {
+    throw createCliDiagnosticCodeError4(CLI_DIAGNOSTIC_CODES5.MISSING_ARGUMENT, `\`--${name}\` requires a value.`);
+  }
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    if (mode === "strict") {
+      throw createCliDiagnosticCodeError4(CLI_DIAGNOSTIC_CODES5.MISSING_ARGUMENT, `\`--${name}\` requires a value.`);
+    }
+    return;
+  }
+  return mode === "strict" ? value : trimmed;
+}
+function readOptionalLooseStringFlag(flags, name) {
+  return readOptionalCliStringFlagValue(flags, name, "loose");
+}
+function readOptionalStrictStringFlag(flags, name) {
+  return readOptionalCliStringFlagValue(flags, name, "strict");
+}
+function requireStrictStringFlag(flags, name, message) {
+  const value = readOptionalStrictStringFlag(flags, name);
+  if (!value) {
+    throw createCliDiagnosticCodeError4(CLI_DIAGNOSTIC_CODES5.MISSING_ARGUMENT, message);
+  }
+  return value;
+}
+function readOptionalPairedStrictStringFlags(flags, leftName, rightName, message) {
+  const leftValue = readOptionalStrictStringFlag(flags, leftName);
+  const rightValue = readOptionalStrictStringFlag(flags, rightName);
+  if (Boolean(leftValue) !== Boolean(rightValue)) {
+    throw createCliDiagnosticCodeError4(CLI_DIAGNOSTIC_CODES5.MISSING_ARGUMENT, message);
+  }
+  return [leftValue, rightValue];
+}
+
+// src/add-kinds/admin-view.ts
+var adminViewAddKindEntry = 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 = readOptionalStrictStringFlag(context.flags, "source");
+    return createNamedExecutionPlan(context, {
+      execute: ({ cwd, name: name2 }) => context.addRuntime.runAddAdminViewCommand({
+        adminViewName: name2,
+        cwd,
+        source
+      }),
+      getValues: (result) => ({
+        adminViewSlug: result.adminViewSlug,
+        ...result.source ? { source: result.source } : {}
+      }),
+      missingNameMessage: "`wp-typia add admin-view` requires <name>. Usage: wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>].",
+      name
+    });
+  },
+  sortOrder: 10,
+  supportsDryRun: true,
+  usage: "wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>] [--dry-run]",
+  visibleFieldNames: () => NAME_SOURCE_VISIBLE_FIELDS
+});
+
+// src/add-kinds/ai-feature.ts
+var aiFeatureAddKindEntry = defineAddKindRegistryEntry({
+  completion: {
+    nextSteps: (values) => [
+      `Review src/ai-features/${values.aiFeatureSlug}/ and inc/ai-features/${values.aiFeatureSlug}.php.`,
+      "Run `wp-typia sync-rest` and `wp-typia sync ai` or your workspace build/dev command to verify the generated REST artifacts and AI schema."
+    ],
+    summaryLines: (values, projectDir) => [
+      `AI feature: ${values.aiFeatureSlug}`,
+      `Namespace: ${values.namespace}`,
+      `Project directory: ${projectDir}`
+    ],
+    title: "Added server-only AI feature"
+  },
+  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 = readOptionalStrictStringFlag(context.flags, "namespace");
+    return createNamedExecutionPlan(context, {
+      execute: ({ cwd, name: name2 }) => context.addRuntime.runAddAiFeatureCommand({
+        aiFeatureName: name2,
+        cwd,
+        namespace
+      }),
+      getValues: (result) => ({
+        aiFeatureSlug: result.aiFeatureSlug,
+        namespace: result.namespace
+      }),
+      getWarnings: (result) => result.warnings,
+      missingNameMessage: "`wp-typia add ai-feature` requires <name>. Usage: wp-typia add ai-feature <name> [--namespace <vendor/v1>].",
+      name,
+      warnLine: context.warnLine
+    });
+  },
+  sortOrder: 100,
+  supportsDryRun: true,
+  usage: "wp-typia add ai-feature <name> [--namespace <vendor/v1>] [--dry-run]",
+  visibleFieldNames: () => NAME_NAMESPACE_VISIBLE_FIELDS
+});
+
+// src/add-kinds/binding-source.ts
+var bindingSourceAddKindEntry = 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",
+  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, attributeName] = readOptionalPairedStrictStringFlags(context.flags, "block", "attribute", "`wp-typia add binding-source` requires --block and --attribute to be provided together.");
+    return createNamedExecutionPlan(context, {
+      execute: ({ cwd, name: name2 }) => context.addRuntime.runAddBindingSourceCommand({
+        attributeName,
+        bindingSourceName: name2,
+        blockName,
+        cwd
+      }),
+      getValues: (result) => ({
+        ...result.attributeName ? { attributeName: result.attributeName } : {},
+        ...result.blockSlug ? { blockSlug: result.blockSlug } : {},
+        bindingSourceSlug: result.bindingSourceSlug
+      }),
+      missingNameMessage: "`wp-typia add binding-source` requires <name>. Usage: wp-typia add binding-source <name> [--block <block-slug|namespace/block-slug> --attribute <attribute>].",
+      name
+    });
+  },
+  sortOrder: 70,
+  supportsDryRun: true,
+  usage: "wp-typia add binding-source <name> [--block <block-slug|namespace/block-slug> --attribute <attribute>] [--dry-run]",
+  visibleFieldNames: () => NAME_BLOCK_ATTRIBUTE_VISIBLE_FIELDS
+});
+
+// src/external-layer-prompt-options.ts
+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
+  }));
+}
+
+// src/add-kinds/block.ts
+var blockAddKindEntry = defineAddKindRegistryEntry({
+  completion: {
+    nextSteps: () => [
+      "Review the generated sources under src/blocks/ and the updated scripts/block-config.ts entry.",
+      "Run your workspace build or dev command to verify the new scaffolded block family."
+    ],
+    summaryLines: (values, projectDir) => [
+      `Blocks: ${values.blockSlugs}`,
+      `Template family: ${values.templateId}`,
+      `Project directory: ${projectDir}`
+    ],
+    title: "Added workspace block"
+  },
+  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 = readOptionalStrictStringFlag(context.flags, "external-layer-id");
+    const externalLayerSource = readOptionalStrictStringFlag(context.flags, "external-layer-source");
+    const shouldPromptForLayerSelection = Boolean(externalLayerSource) && !Boolean(externalLayerId) && context.isInteractiveSession;
+    const selectPrompt = shouldPromptForLayerSelection ? await context.getOrCreatePrompt() : undefined;
+    const alternateRenderTargets = readOptionalStrictStringFlag(context.flags, "alternate-render-targets");
+    const dataStorageMode = readOptionalStrictStringFlag(context.flags, "data-storage");
+    const innerBlocksPreset = readOptionalStrictStringFlag(context.flags, "inner-blocks-preset");
+    const persistencePolicy = readOptionalStrictStringFlag(context.flags, "persistence-policy");
+    const requestedTemplateId = readOptionalStrictStringFlag(context.flags, "template");
+    let resolvedTemplateId = requestedTemplateId ? assertAddBlockTemplateId(context, requestedTemplateId) : undefined;
+    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 createNamedExecutionPlan(context, {
+      execute: ({ cwd, name: name2 }) => context.addRuntime.runAddBlockCommand({
+        alternateRenderTargets,
+        blockName: name2,
+        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,
+      missingNameMessage: "`wp-typia add block` requires <name>. Usage: wp-typia add block <name> [--template <basic|interactivity|persistence|compound>]",
+      name,
+      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);
+    }
+    if (fieldName === "inner-blocks-preset") {
+      return template === "compound";
+    }
+    if (fieldName === "data-storage" || fieldName === "persistence-policy") {
+      return isAddPersistenceTemplate(template);
+    }
+    return true;
   })
+});
+
+// src/add-kinds/editor-plugin.ts
+var editorPluginAddKindEntry = defineAddKindRegistryEntry({
+  completion: {
+    nextSteps: (values) => [
+      `Review src/editor-plugins/${values.editorPluginSlug}/.`,
+      "Run your workspace build or dev command to verify the new editor plugin registration."
+    ],
+    summaryLines: (values, projectDir) => [
+      `Editor plugin: ${values.editorPluginSlug}`,
+      `Slot: ${values.slot}`,
+      `Project directory: ${projectDir}`
+    ],
+    title: "Added editor plugin"
+  },
+  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 = readOptionalStrictStringFlag(context.flags, "slot");
+    return createNamedExecutionPlan(context, {
+      execute: ({ cwd, name: name2 }) => context.addRuntime.runAddEditorPluginCommand({
+        cwd,
+        editorPluginName: name2,
+        slot
+      }),
+      getValues: (result) => ({
+        editorPluginSlug: result.editorPluginSlug,
+        slot: result.slot
+      }),
+      missingNameMessage: "`wp-typia add editor-plugin` requires <name>. Usage: wp-typia add editor-plugin <name> [--slot <sidebar|document-setting-panel>].",
+      name
+    });
+  },
+  sortOrder: 120,
+  supportsDryRun: true,
+  usage: "wp-typia add editor-plugin <name> [--slot <sidebar|document-setting-panel>] [--dry-run]",
+  visibleFieldNames: () => NAME_SLOT_VISIBLE_FIELDS
+});
+
+// src/add-kinds/hooked-block.ts
+var hookedBlockAddKindEntry = defineAddKindRegistryEntry({
+  completion: {
+    nextSteps: (values) => [
+      `Review src/blocks/${values.blockSlug}/block.json for the new blockHooks entry.`,
+      "Run your workspace build or dev command to verify the updated hooked-block metadata."
+    ],
+    summaryLines: (values, projectDir) => [
+      `Block: ${values.blockSlug}`,
+      `Anchor: ${values.anchorBlockName}`,
+      `Position: ${values.position}`,
+      `Project directory: ${projectDir}`
+    ],
+    title: "Added blockHooks metadata"
+  },
+  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 = requireStrictStringFlag(context.flags, "anchor", "`wp-typia add hooked-block` requires --anchor <anchor-block-name>.");
+    const position = requireStrictStringFlag(context.flags, "position", "`wp-typia add hooked-block` requires --position <before|after|firstChild|lastChild>.");
+    return createNamedExecutionPlan(context, {
+      execute: ({ cwd, name: name2 }) => context.addRuntime.runAddHookedBlockCommand({
+        anchorBlockName,
+        blockName: name2,
+        cwd,
+        position
+      }),
+      getValues: (result) => ({
+        anchorBlockName: result.anchorBlockName,
+        blockSlug: result.blockSlug,
+        position: result.position
+      }),
+      missingNameMessage: "`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>.",
+      name
+    });
+  },
+  sortOrder: 110,
+  supportsDryRun: true,
+  usage: "wp-typia add hooked-block <block-slug> --anchor <anchor-block-name> --position <before|after|firstChild|lastChild> [--dry-run]",
+  visibleFieldNames: () => NAME_ANCHOR_POSITION_VISIBLE_FIELDS
+});
+
+// src/add-kinds/pattern.ts
+var patternAddKindEntry = defineAddKindRegistryEntry({
+  completion: {
+    nextSteps: (values) => [
+      `Review src/patterns/${values.patternSlug}.php.`,
+      "Run your workspace build or dev command to verify the new pattern registration."
+    ],
+    summaryLines: (values, projectDir) => [
+      `Pattern: ${values.patternSlug}`,
+      `Project directory: ${projectDir}`
+    ],
+    title: "Added workspace pattern"
+  },
+  description: "Add a PHP block pattern shell",
+  nameLabel: "Pattern name",
+  async prepareExecution(context) {
+    return createNamedExecutionPlan(context, {
+      execute: ({ cwd, name }) => context.addRuntime.runAddPatternCommand({
+        cwd,
+        patternName: name
+      }),
+      getValues: (result) => ({
+        patternSlug: result.patternSlug
+      }),
+      missingNameMessage: "`wp-typia add pattern` requires <name>. Usage: wp-typia add pattern <name>."
+    });
+  },
+  sortOrder: 60,
+  supportsDryRun: true,
+  usage: "wp-typia add pattern <name> [--dry-run]",
+  visibleFieldNames: () => NAME_ONLY_VISIBLE_FIELDS
+});
+
+// src/add-kinds/rest-resource.ts
+var restResourceAddKindEntry = defineAddKindRegistryEntry({
+  completion: {
+    nextSteps: (values) => [
+      `Review src/rest/${values.restResourceSlug}/ and inc/rest/${values.restResourceSlug}.php.`,
+      "Run your workspace build or dev command to verify the generated REST resource contract."
+    ],
+    summaryLines: (values, projectDir) => [
+      `REST resource: ${values.restResourceSlug}`,
+      `Namespace: ${values.namespace}`,
+      `Methods: ${values.methods}`,
+      `Project directory: ${projectDir}`
+    ],
+    title: "Added plugin-level REST resource"
+  },
+  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,update,delete>].");
+    const methods = readOptionalStrictStringFlag(context.flags, "methods");
+    const namespace = readOptionalStrictStringFlag(context.flags, "namespace");
+    return createNamedExecutionPlan(context, {
+      execute: ({ cwd, name: name2 }) => context.addRuntime.runAddRestResourceCommand({
+        cwd,
+        methods,
+        namespace,
+        restResourceName: name2
+      }),
+      getValues: (result) => ({
+        methods: result.methods.join(", "),
+        namespace: result.namespace,
+        restResourceSlug: result.restResourceSlug
+      }),
+      missingNameMessage: "`wp-typia add rest-resource` requires <name>. Usage: wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <list,read,create,update,delete>].",
+      name
+    });
+  },
+  sortOrder: 80,
+  supportsDryRun: true,
+  usage: "wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <list,read,create,update,delete>] [--dry-run]",
+  visibleFieldNames: () => NAME_NAMESPACE_METHODS_VISIBLE_FIELDS
+});
+
+// src/add-kinds/style.ts
+var styleAddKindEntry = 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 = requireStrictStringFlag(context.flags, "block", "`wp-typia add style` requires --block <block-slug>.");
+    return createNamedExecutionPlan(context, {
+      execute: ({ cwd, name: name2 }) => context.addRuntime.runAddBlockStyleCommand({
+        blockName: blockSlug,
+        cwd,
+        styleName: name2
+      }),
+      getValues: (result) => ({
+        blockSlug: result.blockSlug,
+        styleSlug: result.styleSlug
+      }),
+      missingNameMessage: "`wp-typia add style` requires <name>. Usage: wp-typia add style <name> --block <block-slug>.",
+      name
+    });
+  },
+  sortOrder: 40,
+  supportsDryRun: true,
+  usage: "wp-typia add style <name> --block <block-slug> [--dry-run]",
+  visibleFieldNames: () => NAME_BLOCK_VISIBLE_FIELDS
+});
+
+// src/add-kinds/transform.ts
+var transformAddKindEntry = 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 = requireStrictStringFlag(context.flags, "from", "`wp-typia add transform` requires --from <namespace/block>.");
+    const toBlockName = requireStrictStringFlag(context.flags, "to", "`wp-typia add transform` requires --to <block-slug|namespace/block-slug>.");
+    return createNamedExecutionPlan(context, {
+      execute: ({ cwd, name: name2 }) => context.addRuntime.runAddBlockTransformCommand({
+        cwd,
+        fromBlockName,
+        toBlockName,
+        transformName: name2
+      }),
+      getValues: (result) => ({
+        blockSlug: result.blockSlug,
+        fromBlockName: result.fromBlockName,
+        toBlockName: result.toBlockName,
+        transformSlug: result.transformSlug
+      }),
+      missingNameMessage: "`wp-typia add transform` requires <name>. Usage: wp-typia add transform <name> --from <namespace/block> --to <block-slug|namespace/block-slug>.",
+      name
+    });
+  },
+  sortOrder: 50,
+  supportsDryRun: true,
+  usage: "wp-typia add transform <name> --from <namespace/block> --to <block-slug|namespace/block-slug> [--dry-run]",
+  visibleFieldNames: () => NAME_FROM_TO_VISIBLE_FIELDS
+});
+
+// src/add-kinds/variation.ts
+var variationAddKindEntry = defineAddKindRegistryEntry({
+  completion: {
+    nextSteps: (values) => [
+      `Review src/blocks/${values.blockSlug}/variations/${values.variationSlug}.ts.`,
+      "Run your workspace build or dev command to pick up the new variation."
+    ],
+    summaryLines: (values, projectDir) => [
+      `Variation: ${values.variationSlug}`,
+      `Target block: ${values.blockSlug}`,
+      `Project directory: ${projectDir}`
+    ],
+    title: "Added workspace variation"
+  },
+  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 = requireStrictStringFlag(context.flags, "block", "`wp-typia add variation` requires --block <block-slug>.");
+    return createNamedExecutionPlan(context, {
+      execute: ({ cwd, name: name2 }) => context.addRuntime.runAddVariationCommand({
+        blockName: blockSlug,
+        cwd,
+        variationName: name2
+      }),
+      getValues: (result) => ({
+        blockSlug: result.blockSlug,
+        variationSlug: result.variationSlug
+      }),
+      missingNameMessage: "`wp-typia add variation` requires <name>. Usage: wp-typia add variation <name> --block <block-slug>",
+      name
+    });
+  },
+  sortOrder: 30,
+  supportsDryRun: true,
+  usage: "wp-typia add variation <name> --block <block-slug> [--dry-run]",
+  visibleFieldNames: () => NAME_BLOCK_VISIBLE_FIELDS
+});
+
+// src/add-kind-registry.ts
+var ADD_KIND_REGISTRY = {
+  "admin-view": adminViewAddKindEntry,
+  block: blockAddKindEntry,
+  variation: variationAddKindEntry,
+  style: styleAddKindEntry,
+  transform: transformAddKindEntry,
+  pattern: patternAddKindEntry,
+  "binding-source": bindingSourceAddKindEntry,
+  "rest-resource": restResourceAddKindEntry,
+  ability: abilityAddKindEntry,
+  "ai-feature": aiFeatureAddKindEntry,
+  "hooked-block": hookedBlockAddKindEntry,
+  "editor-plugin": editorPluginAddKindEntry
 };
 function isAddKindId(value) {
   return typeof value === "string" && ADD_KIND_IDS.includes(value);
@@ -1612,6 +1659,27 @@ function supportsAddKindDryRun(kind) {
   return ADD_KIND_REGISTRY[kind].supportsDryRun;
 }
 
+// src/cli-error-messages.ts
+var MISSING_CREATE_PROJECT_DIR_DETAIL_LINES = [
+  "`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."
+];
+function formatMissingAddKindDetailLine() {
+  return `\`wp-typia add\` requires <kind>. Usage: wp-typia add ${formatAddKindUsagePlaceholder()} ...`;
+}
+function buildMissingAddKindDetailLines() {
+  return [formatMissingAddKindDetailLine()];
+}
+function shouldPrintMissingAddKindHelp(options) {
+  if (typeof options.emitOutput === "boolean") {
+    return options.emitOutput;
+  }
+  return options.format !== "json";
+}
+function buildMissingCreateProjectDirDetailLines() {
+  return [...MISSING_CREATE_PROJECT_DIR_DETAIL_LINES];
+}
+
 // src/runtime-bridge-add-dry-run.ts
 import fs2 from "node:fs";
 import { promises as fsp } from "node:fs";
@@ -1741,9 +1809,15 @@ async function simulateWorkspaceAddDryRun({
 
 // src/runtime-bridge-output.ts
 import {
+  PACKAGE_MANAGER_IDS,
   formatPackageExecCommand,
-  inferPackageManagerId
+  inferPackageManagerId,
+  parsePackageManagerField
 } from "@wp-typia/project-tools/package-managers";
+import {
+  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES6,
+  createCliDiagnosticCodeError as createCliDiagnosticCodeError5
+} from "@wp-typia/project-tools/cli-diagnostics";
 
 // src/output-markers.ts
 var UNICODE_OUTPUT_MARKERS = {
@@ -1823,6 +1897,13 @@ function stripLeadingOutputMarker(text, kind) {
   return text.replace(new RegExp(`^(?:${markerPattern})\\s*`, "u"), "");
 }
 
+// src/print-block.ts
+function printBlock(printLine, lines) {
+  for (const line of lines) {
+    printLine(line);
+  }
+}
+
 // src/runtime-bridge-output.ts
 function printCompletionPayload(payload, options = {}) {
   const printLine = options.printLine ?? console.log;
@@ -1865,6 +1946,13 @@ function extractPlannedFiles(payload) {
   return toNonEmptyArray(files);
 }
 var PROJECT_DIRECTORY_SUMMARY_PREFIX = "Project directory: ";
+function resolveCreateCompletionPackageManager(packageManager) {
+  const parsedPackageManager = parsePackageManagerField(packageManager);
+  if (parsedPackageManager) {
+    return parsedPackageManager;
+  }
+  throw createCliDiagnosticCodeError5(CLI_DIAGNOSTIC_CODES6.INVALID_ARGUMENT, `Unsupported package manager "${packageManager}" in create completion payload. Expected one of: ${PACKAGE_MANAGER_IDS.join(", ")}.`);
+}
 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;
@@ -1921,8 +2009,9 @@ function formatCreateProgressLine(payload, markerOptions) {
   return formatOutputMarker("progress", `${payload.title}: ${payload.detail}`, markerOptions);
 }
 function buildCreateCompletionPayload(flow, markerOptions) {
+  const packageManager = resolveCreateCompletionPackageManager(flow.packageManager);
   const verificationSteps = [
-    formatPackageExecCommand(flow.packageManager, `wp-typia@${package_default.version}`, "doctor"),
+    formatPackageExecCommand(packageManager, `wp-typia@${package_default.version}`, "doctor"),
     ...flow.optionalOnboarding.steps
   ];
   return {
@@ -2044,11 +2133,6 @@ function buildSyncDryRunPayload(options, markerOptions) {
     title: formatOutputMarker("dryRun", `Dry run for wp-typia sync${targetSuffix}`, markerOptions)
   };
 }
-function printBlock(lines, printLine) {
-  for (const line of lines) {
-    printLine(line);
-  }
-}
 
 // src/runtime-capabilities.ts
 function isInteractiveTerminal({
@@ -2063,8 +2147,8 @@ import { spawnSync } from "node:child_process";
 import fs3 from "node:fs";
 import path3 from "node:path";
 import {
-  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES6,
-  createCliDiagnosticCodeError as createCliDiagnosticCodeError5
+  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES7,
+  createCliDiagnosticCodeError as createCliDiagnosticCodeError6
 } from "@wp-typia/project-tools/cli-diagnostics";
 import {
   formatInstallCommand,
@@ -2085,10 +2169,10 @@ function resolveSyncExecutionTarget(subcommand) {
   if (subcommand === "ai") {
     return "ai";
   }
-  throw createCliDiagnosticCodeError5(CLI_DIAGNOSTIC_CODES6.INVALID_COMMAND, `Unknown sync subcommand "${subcommand}". Expected one of: "ai".`);
+  throw createCliDiagnosticCodeError6(CLI_DIAGNOSTIC_CODES7.INVALID_COMMAND, `Unknown sync subcommand "${subcommand}". Expected one of: "ai".`);
 }
 function getSyncRootError(cwd) {
-  return createCliDiagnosticCodeError5(CLI_DIAGNOSTIC_CODES6.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.`);
+  return createCliDiagnosticCodeError6(CLI_DIAGNOSTIC_CODES7.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 resolveSyncProjectContext(cwd) {
   const packageJsonPath = path3.join(cwd, "package.json");
@@ -2154,7 +2238,7 @@ function assertSyncDependenciesInstalled(project, target) {
   if (markerDir) {
     return;
   }
-  throw createCliDiagnosticCodeError5(CLI_DIAGNOSTIC_CODES6.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\`.`);
+  throw createCliDiagnosticCodeError6(CLI_DIAGNOSTIC_CODES7.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) {
@@ -2192,7 +2276,7 @@ function buildSyncPlannedCommands(project, extraArgs, target) {
   if (target === "ai") {
     const syncAiCommand2 = createSyncPlannedCommand(project, "sync-ai", extraArgs);
     if (!syncAiCommand2) {
-      throw createCliDiagnosticCodeError5(CLI_DIAGNOSTIC_CODES6.CONFIGURATION_MISSING, `Expected ${project.packageJsonPath} to define a \`sync-ai\` script for \`wp-typia sync ai\`.`);
+      throw createCliDiagnosticCodeError6(CLI_DIAGNOSTIC_CODES7.CONFIGURATION_MISSING, `Expected ${project.packageJsonPath} to define a \`sync-ai\` script for \`wp-typia sync ai\`.`);
     }
     return [syncAiCommand2];
   }
@@ -2201,7 +2285,7 @@ function buildSyncPlannedCommands(project, extraArgs, target) {
   }
   const syncTypesCommand = createSyncPlannedCommand(project, "sync-types", extraArgs);
   if (!syncTypesCommand) {
-    throw createCliDiagnosticCodeError5(CLI_DIAGNOSTIC_CODES6.CONFIGURATION_MISSING, `Expected ${project.packageJsonPath} to define either a \`sync\` or \`sync-types\` script.`);
+    throw createCliDiagnosticCodeError6(CLI_DIAGNOSTIC_CODES7.CONFIGURATION_MISSING, `Expected ${project.packageJsonPath} to define either a \`sync\` or \`sync-types\` script.`);
   }
   const plannedCommands = [syncTypesCommand];
   const syncRestCommand = createSyncPlannedCommand(project, "sync-rest", extraArgs);
@@ -2225,7 +2309,7 @@ function runProjectScript(project, plannedCommand, options) {
   const stderr = options.captureOutput && typeof result.stderr === "string" ? result.stderr : undefined;
   const stdout = options.captureOutput && typeof result.stdout === "string" ? result.stdout : undefined;
   if (result.error || result.status !== 0) {
-    throw new Error(`\`${plannedCommand.displayCommand}\` failed.`, {
+    throw createCliDiagnosticCodeError6(CLI_DIAGNOSTIC_CODES7.COMMAND_EXECUTION, `\`${plannedCommand.displayCommand}\` failed.`, {
       cause: result.error ?? (stderr ? new Error(stderr.trim()) : undefined)
     });
   }
@@ -2483,16 +2567,16 @@ async function executeAddCommand({
     const addRuntime = await loadCliAddRuntime();
     const isInteractiveSession = interactive ?? isInteractiveTerminal();
     if (!kind) {
-      if (emitOutput) {
+      if (shouldPrintMissingAddKindHelp({ emitOutput })) {
         printLine(addRuntime.formatAddHelpText());
       }
-      throw createCliDiagnosticCodeError6(CLI_DIAGNOSTIC_CODES7.MISSING_ARGUMENT, `\`wp-typia add\` requires <kind>. Usage: wp-typia add ${formatAddKindUsagePlaceholder()} ...`);
+      throw createCliDiagnosticCodeError7(CLI_DIAGNOSTIC_CODES8.MISSING_ARGUMENT, formatMissingAddKindDetailLine());
     }
     if (!isAddKindId(kind)) {
-      throw createCliDiagnosticCodeError6(CLI_DIAGNOSTIC_CODES7.INVALID_COMMAND, `Unknown add kind "${kind}". Expected one of: ${formatAddKindList()}.`);
+      throw createCliDiagnosticCodeError7(CLI_DIAGNOSTIC_CODES8.INVALID_COMMAND, `Unknown add kind "${kind}". Expected one of: ${formatAddKindList()}.`);
     }
     if (dryRun && !supportsAddKindDryRun(kind)) {
-      throw createCliDiagnosticCodeError6(CLI_DIAGNOSTIC_CODES7.INVALID_ARGUMENT, `\`wp-typia add ${kind}\` does not support \`--dry-run\` yet.`);
+      throw createCliDiagnosticCodeError7(CLI_DIAGNOSTIC_CODES8.INVALID_ARGUMENT, `\`wp-typia add ${kind}\` does not support \`--dry-run\` yet.`);
     }
     const executionContext = {
       addRuntime,
@@ -2538,22 +2622,22 @@ async function executeTemplatesCommand({ flags }, printLine = console.log) {
   const subcommand = flags.subcommand ?? "list";
   if (subcommand === "list") {
     for (const template of listTemplates()) {
-      printBlock([formatTemplateSummary(template), formatTemplateFeatures(template)], printLine);
+      printBlock(printLine, [formatTemplateSummary(template), formatTemplateFeatures(template)]);
     }
     return;
   }
   if (subcommand === "inspect") {
     if (!flags.id) {
-      throw createCliDiagnosticCodeError6(CLI_DIAGNOSTIC_CODES7.MISSING_ARGUMENT, "`wp-typia templates inspect` requires <template-id>.");
+      throw createCliDiagnosticCodeError7(CLI_DIAGNOSTIC_CODES8.MISSING_ARGUMENT, "`wp-typia templates inspect` requires <template-id>.");
     }
     const template = getTemplateById(flags.id);
     if (!template) {
-      throw createCliDiagnosticCodeError6(CLI_DIAGNOSTIC_CODES7.INVALID_ARGUMENT, `Unknown template "${flags.id}".`);
+      throw createCliDiagnosticCodeError7(CLI_DIAGNOSTIC_CODES8.INVALID_ARGUMENT, `Unknown template "${flags.id}".`);
     }
-    printBlock([formatTemplateDetails(template)], printLine);
+    printBlock(printLine, [formatTemplateDetails(template)]);
     return;
   }
-  throw createCliDiagnosticCodeError6(CLI_DIAGNOSTIC_CODES7.INVALID_COMMAND, `Unknown templates subcommand "${subcommand}". Expected list or inspect.`);
+  throw createCliDiagnosticCodeError7(CLI_DIAGNOSTIC_CODES8.INVALID_COMMAND, `Unknown templates subcommand "${subcommand}". Expected list or inspect.`);
 }
 async function executeInitCommand({ apply, cwd, packageManager, projectDir }, options = {}) {
   try {
@@ -2643,8 +2727,8 @@ async function executeMigrateCommand({
 // src/command-contract.ts
 import path4 from "node:path";
 import {
-  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES8,
-  createCliDiagnosticCodeError as createCliDiagnosticCodeError7
+  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES9,
+  createCliDiagnosticCodeError as createCliDiagnosticCodeError8
 } from "@wp-typia/project-tools/cli-diagnostics";
 
 // src/command-registry.ts
@@ -2915,10 +2999,10 @@ function looksLikeStructuredProjectInput(value) {
 function assertPositionalAliasProjectDir(projectDir) {
   const normalizedProjectDir = path4.normalize(projectDir).replace(/[\\/]+$/u, "") || path4.normalize(projectDir);
   if (normalizedProjectDir === "." || normalizedProjectDir === "..") {
-    throw createCliDiagnosticCodeError7(CLI_DIAGNOSTIC_CODES8.INVALID_ARGUMENT, `The positional alias does not scaffold into \`${projectDir}\`. Use \`${WP_TYPIA_CANONICAL_CREATE_USAGE}\` with an explicit child directory instead.`);
+    throw createCliDiagnosticCodeError8(CLI_DIAGNOSTIC_CODES9.INVALID_ARGUMENT, `The positional alias does not scaffold into \`${projectDir}\`. Use \`${WP_TYPIA_CANONICAL_CREATE_USAGE}\` with an explicit child directory instead.`);
   }
   if (looksLikeStructuredProjectInput(projectDir)) {
-    throw createCliDiagnosticCodeError7(CLI_DIAGNOSTIC_CODES8.INVALID_ARGUMENT, `The positional alias only accepts unambiguous local project directories. Use \`${WP_TYPIA_CANONICAL_CREATE_USAGE}\` for \`${projectDir}\`.`);
+    throw createCliDiagnosticCodeError8(CLI_DIAGNOSTIC_CODES9.INVALID_ARGUMENT, `The positional alias only accepts unambiguous local project directories. Use \`${WP_TYPIA_CANONICAL_CREATE_USAGE}\` for \`${projectDir}\`.`);
   }
 }
 function normalizeWpTypiaArgv(argv) {
@@ -2932,7 +3016,7 @@ function normalizeWpTypiaArgv(argv) {
     return argv;
   }
   if (firstPositional === "migrations") {
-    throw createCliDiagnosticCodeError7(CLI_DIAGNOSTIC_CODES8.INVALID_ARGUMENT, "`wp-typia migrations` was removed in favor of `wp-typia migrate`. Use `wp-typia migrate <subcommand>` instead.");
+    throw createCliDiagnosticCodeError8(CLI_DIAGNOSTIC_CODES9.INVALID_ARGUMENT, "`wp-typia migrations` was removed in favor of `wp-typia migrate`. Use `wp-typia migrate <subcommand>` instead.");
   }
   if (isReservedTopLevelCommandName(firstPositional)) {
     assertStringOptionValues(argv);
@@ -2940,7 +3024,7 @@ function normalizeWpTypiaArgv(argv) {
   }
   if (positionalIndexes.length > 1) {
     const extraPositionals = positionalIndexes.slice(1).map((index) => argv[index]).filter((value) => typeof value === "string" && value.length > 0);
-    throw createCliDiagnosticCodeError7(CLI_DIAGNOSTIC_CODES8.INVALID_ARGUMENT, `The positional alias only accepts a single project directory. Use \`${WP_TYPIA_CANONICAL_CREATE_USAGE}\` for scaffold invocations with additional positional arguments, or check the command spelling if you meant another top-level command. Extra positional arguments: ${extraPositionals.map((value) => `\`${value}\``).join(", ")}.`);
+    throw createCliDiagnosticCodeError8(CLI_DIAGNOSTIC_CODES9.INVALID_ARGUMENT, `The positional alias only accepts a single project directory. Use \`${WP_TYPIA_CANONICAL_CREATE_USAGE}\` for scaffold invocations with additional positional arguments, or check the command spelling if you meant another top-level command. Extra positional arguments: ${extraPositionals.map((value) => `\`${value}\``).join(", ")}.`);
   }
   assertPositionalAliasProjectDir(firstPositional);
   const normalizedArgv = [
@@ -2954,7 +3038,7 @@ function normalizeWpTypiaArgv(argv) {
 
 // src/node-fallback/dispatchers/add.ts
 import {
-  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES9,
+  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES10,
   createCliCommandError as createCliCommandError3
 } from "@wp-typia/project-tools/cli-diagnostics";
 async function dispatchNodeFallbackAdd({
@@ -2964,16 +3048,14 @@ async function dispatchNodeFallbackAdd({
   printLine
 }) {
   if (!positionals[1]) {
-    if (mergedFlags.format !== "json") {
+    if (shouldPrintMissingAddKindHelp({ format: mergedFlags.format })) {
       const { formatAddHelpText } = await import("@wp-typia/project-tools/cli-add");
       printLine(formatAddHelpText());
     }
     throw createCliCommandError3({
-      code: CLI_DIAGNOSTIC_CODES9.MISSING_ARGUMENT,
+      code: CLI_DIAGNOSTIC_CODES10.MISSING_ARGUMENT,
       command: "add",
-      detailLines: [
-        `\`wp-typia add\` requires <kind>. Usage: wp-typia add ${formatAddKindUsagePlaceholder()} ...`
-      ]
+      detailLines: buildMissingAddKindDetailLines()
     });
   }
   if (mergedFlags.format === "json") {
@@ -3012,7 +3094,7 @@ async function dispatchNodeFallbackAdd({
 
 // src/node-fallback/dispatchers/create.ts
 import {
-  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES10,
+  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES11,
   createCliCommandError as createCliCommandError4
 } from "@wp-typia/project-tools/cli-diagnostics";
 async function dispatchNodeFallbackCreate({
@@ -3024,12 +3106,9 @@ async function dispatchNodeFallbackCreate({
   const projectDir = positionals[1];
   if (!projectDir) {
     throw createCliCommandError4({
-      code: CLI_DIAGNOSTIC_CODES10.MISSING_ARGUMENT,
+      code: CLI_DIAGNOSTIC_CODES11.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."
-      ]
+      detailLines: buildMissingCreateProjectDirDetailLines()
     });
   }
   let completion;
@@ -3064,13 +3143,8 @@ var NODE_FALLBACK_RUNTIME_SUMMARY_LINES = [
   `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 printBlock2(printLine, lines) {
-  for (const line of lines) {
-    printLine(line);
-  }
-}
 function renderGeneralHelp(printLine) {
-  printBlock2(printLine, [
+  printBlock(printLine, [
     `wp-typia ${package_default.version}`,
     "",
     "Canonical CLI package for wp-typia scaffolding and project workflows.",
@@ -3088,7 +3162,7 @@ function renderGeneralHelp(printLine) {
   ]);
 }
 function renderNodeFallbackCommandHelp(printLine, config) {
-  printBlock2(printLine, [
+  printBlock(printLine, [
     config.heading,
     "",
     ...NODE_FALLBACK_RUNTIME_SUMMARY_LINES,
@@ -3226,7 +3300,7 @@ function renderTemplatesJson(flags, subcommand) {
   const templateId = flags.id;
   if (!templateId) {
     throw createCliCommandError5({
-      code: CLI_DIAGNOSTIC_CODES11.MISSING_ARGUMENT,
+      code: CLI_DIAGNOSTIC_CODES12.MISSING_ARGUMENT,
       command: "templates",
       detailLines: ["`wp-typia templates inspect` requires <template-id>."]
     });
@@ -3234,7 +3308,7 @@ function renderTemplatesJson(flags, subcommand) {
   const template = getTemplateById(templateId);
   if (!template) {
     throw createCliCommandError5({
-      code: CLI_DIAGNOSTIC_CODES11.INVALID_ARGUMENT,
+      code: CLI_DIAGNOSTIC_CODES12.INVALID_ARGUMENT,
       command: "templates",
       detailLines: [`Unknown template "${templateId}".`]
     });
@@ -3245,7 +3319,7 @@ function renderTemplatesJson(flags, subcommand) {
 }
 function renderUnsupportedCommand(command) {
   throw createCliCommandError5({
-    code: CLI_DIAGNOSTIC_CODES11.UNSUPPORTED_COMMAND,
+    code: CLI_DIAGNOSTIC_CODES12.UNSUPPORTED_COMMAND,
     command,
     detailLines: [
       [
@@ -3271,7 +3345,7 @@ async function renderDoctorJson() {
   }, null, 2));
   if (checks.some((check) => check.status === "fail")) {
     throw createCliCommandError6({
-      code: CLI_DIAGNOSTIC_CODES11.DOCTOR_CHECK_FAILED,
+      code: CLI_DIAGNOSTIC_CODES12.DOCTOR_CHECK_FAILED,
       command: "doctor",
       detailLines: getDoctorFailureDetailLines(checks),
       summary: "One or more doctor checks failed."
@@ -3361,7 +3435,7 @@ var NODE_FALLBACK_COMMAND_DISPATCHERS = {
     const resolvedSubcommand = templateId ? "inspect" : subcommand ?? "list";
     if (resolvedSubcommand !== "list" && resolvedSubcommand !== "inspect") {
       throw createCliCommandError5({
-        code: CLI_DIAGNOSTIC_CODES11.INVALID_COMMAND,
+        code: CLI_DIAGNOSTIC_CODES12.INVALID_COMMAND,
         command: "templates",
         detailLines: [
           `Unknown templates subcommand "${resolvedSubcommand}". Expected list or inspect.`
@@ -3469,4 +3543,4 @@ export {
   hasFlagBeforeTerminator
 };
 
-//# debugId=8C4AF690141E04CA64756E2164756E21
+//# debugId=B5CA87A93189F22464756E2164756E21