wp-typia 0.22.8 → 0.22.10

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.10",
   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.10",
     "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_CODES13,
   createCliCommandError as createCliCommandError5,
   formatCliDiagnosticError,
   serializeCliDiagnosticError as serializeCliDiagnosticError2
@@ -109,6 +109,84 @@ import {
   CLI_DIAGNOSTIC_CODES,
   createCliDiagnosticCodeError
 } from "@wp-typia/project-tools/cli-diagnostics";
+
+// src/command-options/add.ts
+var ADD_OPTION_METADATA = {
+  "alternate-render-targets": {
+    description: "Comma-separated alternate render targets for dynamic block scaffolds (email,mjml,plain-text).",
+    type: "string"
+  },
+  anchor: {
+    description: "Anchor block name for hooked-block workflows.",
+    type: "string"
+  },
+  attribute: {
+    description: "Target block attribute for end-to-end binding-source workflows.",
+    type: "string"
+  },
+  block: {
+    description: "Target block slug for variation, style, and end-to-end binding-source workflows.",
+    type: "string"
+  },
+  "data-storage": {
+    description: "Persistence storage mode for persistence-capable templates.",
+    type: "string"
+  },
+  "dry-run": {
+    argumentKind: "flag",
+    description: "Preview workspace file updates and completion guidance without writing them.",
+    type: "boolean"
+  },
+  "external-layer-id": {
+    description: "Explicit layer id when an external layer package exposes multiple selectable layers.",
+    type: "string"
+  },
+  "external-layer-source": {
+    description: "Local path, GitHub locator, or npm package that exposes wp-typia.layers.json for built-in block templates.",
+    type: "string"
+  },
+  from: {
+    description: "Source full block name (namespace/block) for transform workflows.",
+    type: "string"
+  },
+  "inner-blocks-preset": {
+    description: "Compound-only InnerBlocks preset (freeform, ordered, horizontal, locked-structure).",
+    type: "string"
+  },
+  methods: {
+    description: "Comma-separated REST resource methods for rest-resource workflows.",
+    type: "string"
+  },
+  namespace: {
+    description: "REST namespace for rest-resource and ai-feature workflows.",
+    type: "string"
+  },
+  "persistence-policy": {
+    description: "Persistence write policy for persistence-capable templates.",
+    type: "string"
+  },
+  position: {
+    description: "Hook position for hooked-block workflows.",
+    type: "string"
+  },
+  slot: {
+    description: "Document editor shell slot for editor-plugin workflows (sidebar or document-setting-panel).",
+    type: "string"
+  },
+  source: {
+    description: "Optional data source locator for admin-view workflows, such as rest-resource:products or core-data:postType/post.",
+    type: "string"
+  },
+  template: {
+    description: "Optional built-in block family for the new block; interactive flows let you choose it when omitted and non-interactive runs default to basic.",
+    type: "string"
+  },
+  to: {
+    description: "Target workspace block slug or full block name for transform workflows.",
+    type: "string"
+  }
+};
+// src/command-options/create.ts
 var CREATE_OPTION_METADATA = {
   "alternate-render-targets": {
     description: "Comma-separated alternate render targets for dynamic block scaffolds (email,mjml,plain-text).",
@@ -196,81 +274,30 @@ var CREATE_OPTION_METADATA = {
     type: "boolean"
   }
 };
-var ADD_OPTION_METADATA = {
-  "alternate-render-targets": {
-    description: "Comma-separated alternate render targets for dynamic block scaffolds (email,mjml,plain-text).",
-    type: "string"
-  },
-  anchor: {
-    description: "Anchor block name for hooked-block workflows.",
-    type: "string"
-  },
-  attribute: {
-    description: "Target block attribute for end-to-end binding-source workflows.",
-    type: "string"
-  },
-  block: {
-    description: "Target block slug for variation, style, and end-to-end binding-source workflows.",
-    type: "string"
-  },
-  "data-storage": {
-    description: "Persistence storage mode for persistence-capable templates.",
-    type: "string"
-  },
-  "dry-run": {
-    argumentKind: "flag",
-    description: "Preview workspace file updates and completion guidance without writing them.",
-    type: "boolean"
-  },
-  "external-layer-id": {
-    description: "Explicit layer id when an external layer package exposes multiple selectable layers.",
-    type: "string"
-  },
-  "external-layer-source": {
-    description: "Local path, GitHub locator, or npm package that exposes wp-typia.layers.json for built-in block templates.",
-    type: "string"
-  },
-  from: {
-    description: "Source full block name (namespace/block) for transform workflows.",
-    type: "string"
-  },
-  "inner-blocks-preset": {
-    description: "Compound-only InnerBlocks preset (freeform, ordered, horizontal, locked-structure).",
-    type: "string"
-  },
-  methods: {
-    description: "Comma-separated REST resource methods for rest-resource workflows.",
-    type: "string"
-  },
-  namespace: {
-    description: "REST namespace for rest-resource and ai-feature workflows.",
-    type: "string"
-  },
-  "persistence-policy": {
-    description: "Persistence write policy for persistence-capable templates.",
-    type: "string"
-  },
-  position: {
-    description: "Hook position for hooked-block workflows.",
-    type: "string"
-  },
-  slot: {
-    description: "Document editor shell slot for editor-plugin workflows (sidebar or document-setting-panel).",
+// src/command-options/doctor.ts
+var DOCTOR_OPTION_METADATA = {
+  format: {
+    description: "Use `json` for machine-readable doctor check output or `text` for human-readable output.",
     type: "string"
-  },
-  source: {
-    description: "Optional data source locator for admin-view workflows, such as rest-resource:products or core-data:postType/post.",
+  }
+};
+// src/command-options/global.ts
+var GLOBAL_OPTION_METADATA = {
+  config: {
+    description: "Config override file path.",
+    short: "c",
     type: "string"
   },
-  template: {
-    description: "Optional built-in block family for the new block; interactive flows let you choose it when omitted and non-interactive runs default to basic.",
+  format: {
+    description: "Output format for supported commands (`json` or `text`).",
     type: "string"
   },
-  to: {
-    description: "Target workspace block slug or full block name for transform workflows.",
+  id: {
+    description: "Template id for top-level `templates inspect` convenience.",
     type: "string"
   }
 };
+// src/command-options/init.ts
 var INIT_OPTION_METADATA = {
   apply: {
     argumentKind: "flag",
@@ -283,6 +310,14 @@ var INIT_OPTION_METADATA = {
     type: "string"
   }
 };
+// src/command-options/mcp.ts
+var MCP_OPTION_METADATA = {
+  "output-dir": {
+    description: "Output directory for generated MCP metadata.",
+    type: "string"
+  }
+};
+// src/command-options/migrate.ts
 var MIGRATE_OPTION_METADATA = {
   all: {
     argumentKind: "flag",
@@ -319,12 +354,7 @@ var MIGRATE_OPTION_METADATA = {
     type: "string"
   }
 };
-var MCP_OPTION_METADATA = {
-  "output-dir": {
-    description: "Output directory for generated MCP metadata.",
-    type: "string"
-  }
-};
+// src/command-options/sync.ts
 var SYNC_OPTION_METADATA = {
   check: {
     argumentKind: "flag",
@@ -337,33 +367,14 @@ var SYNC_OPTION_METADATA = {
     type: "boolean"
   }
 };
-var DOCTOR_OPTION_METADATA = {
-  format: {
-    description: "Use `json` for machine-readable doctor check output or `text` for human-readable output.",
-    type: "string"
-  }
-};
+// src/command-options/templates.ts
 var TEMPLATES_OPTION_METADATA = {
   id: {
     description: "Template id for `templates inspect`.",
     type: "string"
   }
 };
-var GLOBAL_OPTION_METADATA = {
-  config: {
-    description: "Config override file path.",
-    short: "c",
-    type: "string"
-  },
-  format: {
-    description: "Output format for supported commands (`json` or `text`).",
-    type: "string"
-  },
-  id: {
-    description: "Template id for top-level `templates inspect` convenience.",
-    type: "string"
-  }
-};
+// src/command-option-metadata.ts
 var COMMAND_OPTION_METADATA_BY_GROUP = {
   add: ADD_OPTION_METADATA,
   create: CREATE_OPTION_METADATA,
@@ -927,82 +938,27 @@ function extractWpTypiaConfigOverride(argv) {
   };
 }
 
-// src/runtime-bridge.ts
+// src/runtime-bridge-add.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
-} 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";
+import { ADD_KIND_IDS as ADD_KIND_IDS2 } from "@wp-typia/project-tools/cli-add-kind-ids";
+function formatAddKindList() {
+  return ADD_KIND_IDS.join(", ");
+}
+function formatAddKindUsagePlaceholder() {
+  return `<${ADD_KIND_IDS.join("|")}>`;
+}
 
-// 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 +1018,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,512 +1040,634 @@ 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 ABILITY_MISSING_NAME_MESSAGE = "`wp-typia add ability` requires <name>. Usage: wp-typia add ability <name>.";
+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: ABILITY_MISSING_NAME_MESSAGE,
+      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 ADMIN_VIEW_MISSING_NAME_MESSAGE = "`wp-typia add admin-view` requires <name>. Usage: wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>].";
+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, ADMIN_VIEW_MISSING_NAME_MESSAGE);
+    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: ADMIN_VIEW_MISSING_NAME_MESSAGE,
+      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 AI_FEATURE_MISSING_NAME_MESSAGE = "`wp-typia add ai-feature` requires <name>. Usage: wp-typia add ai-feature <name> [--namespace <vendor/v1>].";
+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, AI_FEATURE_MISSING_NAME_MESSAGE);
+    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: AI_FEATURE_MISSING_NAME_MESSAGE,
+      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 BINDING_SOURCE_MISSING_NAME_MESSAGE = "`wp-typia add binding-source` requires <name>. Usage: wp-typia add binding-source <name> [--block <block-slug|namespace/block-slug> --attribute <attribute>].";
+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, BINDING_SOURCE_MISSING_NAME_MESSAGE);
+    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: BINDING_SOURCE_MISSING_NAME_MESSAGE,
+      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 BLOCK_MISSING_NAME_MESSAGE = "`wp-typia add block` requires <name>. Usage: wp-typia add block <name> [--template <basic|interactivity|persistence|compound>]";
+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, BLOCK_MISSING_NAME_MESSAGE);
+    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: BLOCK_MISSING_NAME_MESSAGE,
+      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 EDITOR_PLUGIN_MISSING_NAME_MESSAGE = "`wp-typia add editor-plugin` requires <name>. Usage: wp-typia add editor-plugin <name> [--slot <sidebar|document-setting-panel>].";
+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, EDITOR_PLUGIN_MISSING_NAME_MESSAGE);
+    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: EDITOR_PLUGIN_MISSING_NAME_MESSAGE,
+      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 HOOKED_BLOCK_MISSING_NAME_MESSAGE = "`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>.";
+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, HOOKED_BLOCK_MISSING_NAME_MESSAGE);
+    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: HOOKED_BLOCK_MISSING_NAME_MESSAGE,
+      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 PATTERN_MISSING_NAME_MESSAGE = "`wp-typia add pattern` requires <name>. Usage: wp-typia add pattern <name>.";
+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: PATTERN_MISSING_NAME_MESSAGE,
+      warnLine: context.warnLine
+    });
+  },
+  sortOrder: 60,
+  supportsDryRun: true,
+  usage: "wp-typia add pattern <name> [--dry-run]",
+  visibleFieldNames: () => NAME_ONLY_VISIBLE_FIELDS
+});
+
+// src/add-kinds/rest-resource.ts
+var REST_RESOURCE_MISSING_NAME_MESSAGE = "`wp-typia add rest-resource` requires <name>. Usage: wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <list,read,create,update,delete>].";
+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, REST_RESOURCE_MISSING_NAME_MESSAGE);
+    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: REST_RESOURCE_MISSING_NAME_MESSAGE,
+      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 STYLE_MISSING_NAME_MESSAGE = "`wp-typia add style` requires <name>. Usage: wp-typia add style <name> --block <block-slug>.";
+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, STYLE_MISSING_NAME_MESSAGE);
+    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: STYLE_MISSING_NAME_MESSAGE,
+      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 TRANSFORM_MISSING_NAME_MESSAGE = "`wp-typia add transform` requires <name>. Usage: wp-typia add transform <name> --from <namespace/block> --to <block-slug|namespace/block-slug>.";
+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, TRANSFORM_MISSING_NAME_MESSAGE);
+    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: TRANSFORM_MISSING_NAME_MESSAGE,
+      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 VARIATION_MISSING_NAME_MESSAGE = "`wp-typia add variation` requires <name>. Usage: wp-typia add variation <name> --block <block-slug>";
+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, VARIATION_MISSING_NAME_MESSAGE);
+    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: VARIATION_MISSING_NAME_MESSAGE,
+      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);
+  return typeof value === "string" && ADD_KIND_IDS2.includes(value);
 }
 async function getAddKindExecutionPlan(kind, context) {
   return ADD_KIND_REGISTRY[kind].prepareExecution(context);
@@ -1602,16 +1680,31 @@ function buildAddKindCompletionDetails(kind, options) {
     title: descriptor.title
   };
 }
-function formatAddKindList() {
-  return ADD_KIND_IDS.join(", ");
-}
-function formatAddKindUsagePlaceholder() {
-  return `<${ADD_KIND_IDS.join("|")}>`;
-}
 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";
@@ -1637,6 +1730,55 @@ async function copyWorkspaceProject(sourceDir, targetDir) {
     recursive: true
   });
 }
+function formatInstallMarkerError(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+function formatInstallMarkerFailures(failures) {
+  return failures.map((failure) => `${failure.operation}: ${failure.reason}`).join("; ");
+}
+function ensureWorkspaceInstallMarker({
+  fsAdapter = fs2,
+  sourceMarker,
+  targetMarker
+}) {
+  const failures = [];
+  try {
+    fsAdapter.symlinkSync(sourceMarker, targetMarker);
+    return;
+  } catch (error) {
+    failures.push({
+      operation: "symlink",
+      reason: formatInstallMarkerError(error)
+    });
+  }
+  try {
+    fsAdapter.linkSync(sourceMarker, targetMarker);
+    return;
+  } catch (error) {
+    failures.push({
+      operation: "hard link",
+      reason: formatInstallMarkerError(error)
+    });
+  }
+  try {
+    fsAdapter.copyFileSync(sourceMarker, targetMarker);
+    return;
+  } catch (error) {
+    failures.push({
+      operation: "copy",
+      reason: formatInstallMarkerError(error)
+    });
+  }
+  throw new Error([
+    "Failed to prepare dry-run install marker.",
+    `Source: ${sourceMarker}`,
+    `Target: ${targetMarker}`,
+    `Fallback failures: ${formatInstallMarkerFailures(failures)}`
+  ].join(" "));
+}
 function ensureWorkspaceInstallMarkers(sourceDir, targetDir) {
   const sourceNodeModules = path2.join(sourceDir, "node_modules");
   if (fs2.existsSync(sourceNodeModules)) {
@@ -1648,15 +1790,7 @@ function ensureWorkspaceInstallMarkers(sourceDir, targetDir) {
       continue;
     }
     const targetMarker = path2.join(targetDir, marker);
-    try {
-      fs2.symlinkSync(sourceMarker, targetMarker);
-    } catch {
-      try {
-        fs2.linkSync(sourceMarker, targetMarker);
-      } catch {
-        fs2.copyFileSync(sourceMarker, targetMarker);
-      }
-    }
+    ensureWorkspaceInstallMarker({ sourceMarker, targetMarker });
   }
 }
 async function listWorkspaceFiles(rootDir) {
@@ -1739,12 +1873,6 @@ async function simulateWorkspaceAddDryRun({
   }
 }
 
-// src/runtime-bridge-output.ts
-import {
-  formatPackageExecCommand,
-  inferPackageManagerId
-} from "@wp-typia/project-tools/package-managers";
-
 // src/output-markers.ts
 var UNICODE_OUTPUT_MARKERS = {
   dryRun: "\uD83E\uDDEA",
@@ -1823,40 +1951,38 @@ function stripLeadingOutputMarker(text, kind) {
   return text.replace(new RegExp(`^(?:${markerPattern})\\s*`, "u"), "");
 }
 
-// src/runtime-bridge-output.ts
-function printCompletionPayload(payload, options = {}) {
-  const printLine = options.printLine ?? console.log;
-  const warnLine = options.warnLine ?? printLine;
-  for (const line of payload.preambleLines ?? []) {
-    printLine(line);
-  }
-  for (const warning of payload.warningLines ?? []) {
-    warnLine(formatOutputMarker("warning", warning, options.markerOptions));
-  }
-  const hasDetails = (payload.summaryLines?.length ?? 0) > 0 || (payload.nextSteps?.length ?? 0) > 0 || (payload.optionalLines?.length ?? 0) > 0 || Boolean(payload.optionalNote);
-  const hasLeadingContext = (payload.preambleLines?.length ?? 0) > 0 || (payload.warningLines?.length ?? 0) > 0;
-  printLine(hasLeadingContext && hasDetails ? `
-${payload.title}` : payload.title);
-  for (const line of payload.summaryLines ?? []) {
-    printLine(line);
-  }
-  if ((payload.nextSteps?.length ?? 0) > 0) {
-    printLine("Next steps:");
-    for (const step of payload.nextSteps ?? []) {
-      printLine(`  ${step}`);
-    }
-  }
-  if ((payload.optionalLines?.length ?? 0) > 0) {
-    printLine(`
-${payload.optionalTitle ?? "Optional:"}`);
-    for (const step of payload.optionalLines ?? []) {
-      printLine(`  ${step}`);
-    }
-  }
-  if (payload.optionalNote) {
-    printLine(`Note: ${payload.optionalNote}`);
-  }
+// src/runtime-output/init.ts
+function buildInitCompletionPayload(plan, markerOptions) {
+  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 ${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: changeLines,
+    optionalNote: plan.summary,
+    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}`,
+      modeLine
+    ],
+    title,
+    warningLines: plan.notes
+  };
 }
+
+// src/runtime-output/structured.ts
 function toNonEmptyArray(values) {
   return values && values.length > 0 ? values : undefined;
 }
@@ -1917,12 +2043,44 @@ function buildStructuredInitSuccessPayload(plan) {
     }
   };
 }
+// src/runtime-output/create.ts
+import {
+  PACKAGE_MANAGER_IDS,
+  formatPackageExecCommand,
+  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";
+function escapeRegExp2(source) {
+  return source.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+var LOOSE_CREATE_COMPLETION_PACKAGE_MANAGER_PATTERN = new RegExp(`^(?:corepack\\s+)?(${PACKAGE_MANAGER_IDS.map(escapeRegExp2).join("|")})(?=$|[@:/+\\s])`, "iu");
+function parseCreateCompletionPackageManager(packageManager) {
+  const normalizedPackageManager = packageManager.trim();
+  const parsedPackageManager = parsePackageManagerField(normalizedPackageManager);
+  if (parsedPackageManager) {
+    return parsedPackageManager;
+  }
+  const looseMatch = LOOSE_CREATE_COMPLETION_PACKAGE_MANAGER_PATTERN.exec(normalizedPackageManager);
+  const loosePackageManager = looseMatch?.[1]?.toLowerCase();
+  return PACKAGE_MANAGER_IDS.includes(loosePackageManager) ? loosePackageManager : null;
+}
+function resolveCreateCompletionPackageManager(packageManager) {
+  const parsedPackageManager = parseCreateCompletionPackageManager(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 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 {
@@ -1961,45 +2119,14 @@ function buildCreateDryRunPayload(flow, markerOptions) {
     warningLines: flow.result.warnings
   };
 }
-function buildInitCompletionPayload(plan, markerOptions) {
-  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 ${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: changeLines,
-    optionalNote: plan.summary,
-    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}`,
-      modeLine
-    ],
-    title,
-    warningLines: plan.notes
-  };
-}
-function buildMigrationCompletionPayload(options, markerOptions) {
-  const summaryLines = options.lines.filter((line) => line.trim().length > 0);
-  return {
-    summaryLines,
-    title: formatOutputMarker("success", `Completed wp-typia migrate ${options.command}`, markerOptions)
-  };
-}
+// src/runtime-output/add.ts
+import {
+  formatPackageExecCommand as formatPackageExecCommand2,
+  inferPackageManagerId
+} from "@wp-typia/project-tools/package-managers";
 function buildAddCompletionPayload(options, markerOptions) {
   const verificationLines = [
-    formatPackageExecCommand(options.packageManager ?? inferPackageManagerId(options.projectDir), `wp-typia@${package_default.version}`, "doctor")
+    formatPackageExecCommand2(options.packageManager ?? inferPackageManagerId(options.projectDir), `wp-typia@${package_default.version}`, "doctor")
   ];
   const verificationNote = "Run doctor via your package manager for a quick inventory and generated-artifact check after the add workflow.";
   const completion = buildAddKindCompletionDetails(options.kind, {
@@ -2028,6 +2155,15 @@ function buildAddDryRunPayload(options, markerOptions) {
     warningLines: options.completion.warningLines
   };
 }
+// src/runtime-output/migrate.ts
+function buildMigrationCompletionPayload(options, markerOptions) {
+  const summaryLines = options.lines.filter((line) => line.trim().length > 0);
+  return {
+    summaryLines,
+    title: formatOutputMarker("success", `Completed wp-typia migrate ${options.command}`, markerOptions)
+  };
+}
+// src/runtime-output/sync.ts
 function buildSyncDryRunPayload(options, markerOptions) {
   const targetSuffix = options.target === "ai" ? " ai" : "";
   const targetSummary = options.target === "ai" ? "Sync target: AI artifacts only." : options.target === "default" ? "Sync target: generated project defaults." : undefined;
@@ -2044,237 +2180,58 @@ function buildSyncDryRunPayload(options, markerOptions) {
     title: formatOutputMarker("dryRun", `Dry run for wp-typia sync${targetSuffix}`, markerOptions)
   };
 }
-function printBlock(lines, printLine) {
+// src/print-block.ts
+function printBlock(printLine, lines) {
   for (const line of lines) {
     printLine(line);
   }
 }
 
-// src/runtime-capabilities.ts
-function isInteractiveTerminal({
-  stdin = process.stdin,
-  stdout = process.stdout,
-  term = process.env.TERM
-} = {}) {
-  return Boolean(stdin?.isTTY) && Boolean(stdout?.isTTY) && term !== "dumb";
-}
-// src/runtime-bridge-sync.ts
-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
-} from "@wp-typia/project-tools/cli-diagnostics";
-import {
-  formatInstallCommand,
-  formatRunScript,
-  inferPackageManagerId as inferPackageManagerId2
-} from "@wp-typia/project-tools/package-managers";
-var SYNC_INSTALL_MARKERS = [
-  "node_modules",
-  ".pnp.cjs",
-  ".pnp.loader.mjs"
-];
-var LOCAL_SYNC_TOOL_PATTERN = /(^|[\s;&|()])(?:tsx|wp-scripts)(?=($|[\s;&|()]))/u;
-var CAPTURED_SYNC_OUTPUT_MAX_BUFFER = 16 * 1024 * 1024;
-function resolveSyncExecutionTarget(subcommand) {
-  if (!subcommand) {
-    return "default";
+// src/runtime-output/print.ts
+function printCompletionPayload(payload, options = {}) {
+  const printLine = options.printLine ?? console.log;
+  const warnLine = options.warnLine ?? printLine;
+  for (const line of payload.preambleLines ?? []) {
+    printLine(line);
   }
-  if (subcommand === "ai") {
-    return "ai";
+  for (const warning of payload.warningLines ?? []) {
+    warnLine(formatOutputMarker("warning", warning, options.markerOptions));
   }
-  throw createCliDiagnosticCodeError5(CLI_DIAGNOSTIC_CODES6.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.`);
-}
-function resolveSyncProjectContext(cwd) {
-  const packageJsonPath = path3.join(cwd, "package.json");
-  if (!fs3.existsSync(packageJsonPath)) {
-    throw getSyncRootError(cwd);
+  const hasDetails = (payload.summaryLines?.length ?? 0) > 0 || (payload.nextSteps?.length ?? 0) > 0 || (payload.optionalLines?.length ?? 0) > 0 || Boolean(payload.optionalNote);
+  const hasLeadingContext = (payload.preambleLines?.length ?? 0) > 0 || (payload.warningLines?.length ?? 0) > 0;
+  printLine(hasLeadingContext && hasDetails ? `
+${payload.title}` : payload.title);
+  for (const line of payload.summaryLines ?? []) {
+    printLine(line);
   }
-  const packageJson = JSON.parse(fs3.readFileSync(packageJsonPath, "utf8"));
-  const scripts = packageJson.scripts ?? {};
-  const syncScripts = {
-    sync: typeof scripts.sync === "string" ? {
-      command: scripts.sync,
-      scriptName: "sync"
-    } : undefined,
-    "sync-ai": typeof scripts["sync-ai"] === "string" ? {
-      command: scripts["sync-ai"],
-      scriptName: "sync-ai"
-    } : typeof scripts["sync-wordpress-ai"] === "string" ? {
-      command: scripts["sync-wordpress-ai"],
-      scriptName: "sync-wordpress-ai"
-    } : undefined,
-    "sync-rest": typeof scripts["sync-rest"] === "string" ? {
-      command: scripts["sync-rest"],
-      scriptName: "sync-rest"
-    } : undefined,
-    "sync-types": typeof scripts["sync-types"] === "string" ? {
-      command: scripts["sync-types"],
-      scriptName: "sync-types"
-    } : undefined
-  };
-  return {
-    cwd,
-    packageJsonPath,
-    packageManager: inferPackageManagerId2(cwd, packageJson.packageManager),
-    scripts: syncScripts
-  };
-}
-function findInstalledDependencyMarkerDir(projectDir) {
-  let currentDir = path3.resolve(projectDir);
-  while (true) {
-    if (SYNC_INSTALL_MARKERS.some((marker) => fs3.existsSync(path3.join(currentDir, marker)))) {
-      return currentDir;
-    }
-    const parentDir = path3.dirname(currentDir);
-    if (parentDir === currentDir) {
-      return null;
+  if ((payload.nextSteps?.length ?? 0) > 0) {
+    printLine("Next steps:");
+    for (const step of payload.nextSteps ?? []) {
+      printLine(`  ${step}`);
     }
-    currentDir = parentDir;
-  }
-}
-function scriptsLikelyNeedInstalledDependencies(project, target) {
-  const candidateScripts = target === "ai" ? [project.scripts["sync-ai"]] : project.scripts.sync ? [project.scripts.sync] : [
-    project.scripts["sync-types"],
-    project.scripts["sync-rest"],
-    project.scripts["sync-ai"]
-  ];
-  return candidateScripts.some((script) => script !== undefined && LOCAL_SYNC_TOOL_PATTERN.test(script.command));
-}
-function assertSyncDependenciesInstalled(project, target) {
-  if (!scriptsLikelyNeedInstalledDependencies(project, target)) {
-    return;
-  }
-  const markerDir = findInstalledDependencyMarkerDir(project.cwd);
-  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\`.`);
-}
-function getPackageManagerRunInvocation(packageManager, scriptName, extraArgs) {
-  switch (packageManager) {
-    case "bun":
-      return { args: ["run", scriptName, ...extraArgs], command: "bun" };
-    case "npm":
-      return {
-        args: [
-          "run",
-          scriptName,
-          ...extraArgs.length > 0 ? ["--", ...extraArgs] : []
-        ],
-        command: "npm"
-      };
-    case "pnpm":
-      return { args: ["run", scriptName, ...extraArgs], command: "pnpm" };
-    case "yarn":
-      return { args: ["run", scriptName, ...extraArgs], command: "yarn" };
-  }
-}
-function createSyncPlannedCommand(project, scriptName, extraArgs) {
-  const script = project.scripts[scriptName];
-  if (!script) {
-    return null;
-  }
-  const invocation = getPackageManagerRunInvocation(project.packageManager, script.scriptName, extraArgs);
-  return {
-    args: invocation.args,
-    command: invocation.command,
-    displayCommand: formatRunScript(project.packageManager, script.scriptName, extraArgs.join(" ")),
-    scriptName: script.scriptName
-  };
-}
-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\`.`);
+  if ((payload.optionalLines?.length ?? 0) > 0) {
+    printLine(`
+${payload.optionalTitle ?? "Optional:"}`);
+    for (const step of payload.optionalLines ?? []) {
+      printLine(`  ${step}`);
     }
-    return [syncAiCommand2];
-  }
-  if (project.scripts.sync) {
-    return [createSyncPlannedCommand(project, "sync", extraArgs)];
-  }
-  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.`);
   }
-  const plannedCommands = [syncTypesCommand];
-  const syncRestCommand = createSyncPlannedCommand(project, "sync-rest", extraArgs);
-  if (syncRestCommand) {
-    plannedCommands.push(syncRestCommand);
-  }
-  const syncAiCommand = createSyncPlannedCommand(project, "sync-ai", extraArgs);
-  if (syncAiCommand) {
-    plannedCommands.push(syncAiCommand);
-  }
-  return plannedCommands;
-}
-function runProjectScript(project, plannedCommand, options) {
-  const result = spawnSync(plannedCommand.command, plannedCommand.args, {
-    cwd: project.cwd,
-    encoding: options.captureOutput ? "utf8" : undefined,
-    ...options.captureOutput ? { maxBuffer: CAPTURED_SYNC_OUTPUT_MAX_BUFFER } : {},
-    shell: process.platform === "win32",
-    stdio: options.captureOutput ? "pipe" : "inherit"
-  });
-  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.`, {
-      cause: result.error ?? (stderr ? new Error(stderr.trim()) : undefined)
-    });
+  if (payload.optionalNote) {
+    printLine(`Note: ${payload.optionalNote}`);
   }
-  return {
-    ...plannedCommand,
-    exitCode: result.status ?? 0,
-    ...stderr !== undefined ? { stderr } : {},
-    ...stdout !== undefined ? { stdout } : {}
-  };
 }
-async function executeSyncCommand({
-  captureOutput = false,
-  check = false,
-  cwd,
-  dryRun = false,
-  target = "default"
-}) {
-  const project = resolveSyncProjectContext(cwd);
-  const extraArgs = check ? ["--check"] : [];
-  const plannedCommands = buildSyncPlannedCommands(project, extraArgs, target);
-  const result = {
-    check,
-    dryRun,
-    packageJsonPath: project.packageJsonPath,
-    packageManager: project.packageManager,
-    plannedCommands,
-    projectDir: project.cwd,
-    target
-  };
-  if (dryRun) {
-    return result;
-  }
-  assertSyncDependenciesInstalled(project, target);
-  result.executedCommands = plannedCommands.map((plannedCommand) => runProjectScript(project, plannedCommand, {
-    captureOutput
-  }));
-  return result;
+// src/runtime-capabilities.ts
+function isInteractiveTerminal({
+  stdin = process.stdin,
+  stdout = process.stdout,
+  term = process.env.TERM
+} = {}) {
+  return Boolean(stdin?.isTTY) && Boolean(stdout?.isTTY) && term !== "dumb";
 }
 
-// src/runtime-bridge.ts
-var loadCliAddRuntime = () => import("@wp-typia/project-tools/cli-add");
+// src/runtime-bridge-shared.ts
 var loadCliDiagnosticsRuntime = () => import("@wp-typia/project-tools/cli-diagnostics");
-var loadCliDoctorRuntime = () => import("@wp-typia/project-tools/cli-doctor");
-var loadCliInitRuntime = () => import("@wp-typia/project-tools/cli-init");
-var loadCliPromptRuntime = () => import("@wp-typia/project-tools/cli-prompt");
-var loadCliScaffoldRuntime = () => import("@wp-typia/project-tools/cli-scaffold");
-var loadCliTemplatesRuntime = () => import("@wp-typia/project-tools/cli-templates");
-var loadCreateTemplateValidationRuntime = () => import("@wp-typia/project-tools/create-template-validation");
-var loadMigrationsRuntime = () => import("@wp-typia/project-tools/migrations");
 async function wrapCliCommandError(command, error) {
   const { createCliCommandError: createCliCommandError3 } = await loadCliDiagnosticsRuntime();
   return createCliCommandError3({ command, error });
@@ -2288,6 +2245,15 @@ function shouldWrapCliCommandError(options) {
   }
   return true;
 }
+function emitCompletion(payload, options) {
+  if (options.emitOutput) {
+    printCompletionPayload(payload, {
+      printLine: options.printLine,
+      warnLine: options.warnLine
+    });
+  }
+  return payload;
+}
 function pushFlag(argv, name, value) {
   if (value === undefined || value === null || value === false) {
     return;
@@ -2298,6 +2264,10 @@ function pushFlag(argv, name, value) {
   }
   argv.push(`--${name}`, String(value));
 }
+
+// src/runtime-bridge-add.ts
+var loadCliAddRuntime = () => import("@wp-typia/project-tools/cli-add");
+var loadCliPromptRuntime = () => import("@wp-typia/project-tools/cli-prompt");
 async function executeWorkspaceAddWithOptionalDryRun(options) {
   const simulated = options.dryRun ? await simulateWorkspaceAddDryRun({
     cwd: options.cwd,
@@ -2341,6 +2311,72 @@ async function executePlannedAddKind(kind, executionContext, context) {
   const plan = await getAddKindExecutionPlan(kind, executionContext);
   return executePreparedAddKind(kind, context, plan);
 }
+async function executeAddCommand({
+  cwd,
+  emitOutput = true,
+  flags,
+  interactive,
+  kind,
+  name,
+  printLine = console.log,
+  prompt,
+  warnLine = console.warn
+}) {
+  let activePrompt;
+  const dryRun = Boolean(flags["dry-run"]);
+  try {
+    const addRuntime = await loadCliAddRuntime();
+    const isInteractiveSession = interactive ?? isInteractiveTerminal();
+    if (!kind) {
+      if (shouldPrintMissingAddKindHelp({ emitOutput })) {
+        printLine(addRuntime.formatAddHelpText());
+      }
+      throw createCliDiagnosticCodeError6(CLI_DIAGNOSTIC_CODES7.MISSING_ARGUMENT, formatMissingAddKindDetailLine());
+    }
+    if (!isAddKindId(kind)) {
+      throw createCliDiagnosticCodeError6(CLI_DIAGNOSTIC_CODES7.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.`);
+    }
+    const executionContext = {
+      addRuntime,
+      cwd,
+      flags,
+      getOrCreatePrompt: async () => {
+        if (activePrompt) {
+          return activePrompt;
+        }
+        const { createReadlinePrompt } = await loadCliPromptRuntime();
+        activePrompt = prompt ?? createReadlinePrompt();
+        return activePrompt;
+      },
+      isInteractiveSession,
+      name,
+      warnLine
+    };
+    return await executePlannedAddKind(kind, executionContext, {
+      cwd,
+      dryRun,
+      emitOutput,
+      printLine
+    });
+  } catch (error) {
+    if (!shouldWrapCliCommandError({ emitOutput })) {
+      throw error;
+    }
+    throw await wrapCliCommandError("add", error);
+  } finally {
+    if (activePrompt && activePrompt !== prompt) {
+      activePrompt.close();
+    }
+  }
+}
+// src/runtime-bridge-create.ts
+var loadCliPromptRuntime2 = () => import("@wp-typia/project-tools/cli-prompt");
+var loadCliScaffoldRuntime = () => import("@wp-typia/project-tools/cli-scaffold");
+var loadCliTemplatesRuntime = () => import("@wp-typia/project-tools/cli-templates");
+var loadCreateTemplateValidationRuntime = () => import("@wp-typia/project-tools/create-template-validation");
 var PACKAGE_MANAGER_PROMPT_OPTIONS = [
   { label: "npm", value: "npm", hint: "Use npm" },
   { label: "pnpm", value: "pnpm", hint: "Use pnpm" },
@@ -2367,15 +2403,6 @@ var BOOLEAN_PROMPT_OPTIONS = [
   { label: "Yes", value: "yes", hint: "Enable this option" },
   { label: "No", value: "no", hint: "Keep the default disabled state" }
 ];
-function emitCompletion(payload, options) {
-  if (options.emitOutput) {
-    printCompletionPayload(payload, {
-      printLine: options.printLine,
-      warnLine: options.warnLine
-    });
-  }
-  return payload;
-}
 async function executeCreateCommand({
   projectDir,
   cwd,
@@ -2396,7 +2423,7 @@ async function executeCreateCommand({
       { runScaffoldFlow },
       { getTemplateSelectOptions }
     ] = await Promise.all([
-      loadCliPromptRuntime(),
+      loadCliPromptRuntime2(),
       loadCliScaffoldRuntime(),
       loadCliTemplatesRuntime()
     ]);
@@ -2466,99 +2493,23 @@ async function executeCreateCommand({
     }
   }
 }
-async function executeAddCommand({
-  cwd,
-  emitOutput = true,
-  flags,
-  interactive,
-  kind,
-  name,
-  printLine = console.log,
-  prompt,
-  warnLine = console.warn
-}) {
-  let activePrompt;
-  const dryRun = Boolean(flags["dry-run"]);
+// src/runtime-bridge-doctor.ts
+var loadCliDoctorRuntime = () => import("@wp-typia/project-tools/cli-doctor");
+async function executeDoctorCommand(cwd) {
   try {
-    const addRuntime = await loadCliAddRuntime();
-    const isInteractiveSession = interactive ?? isInteractiveTerminal();
-    if (!kind) {
-      if (emitOutput) {
-        printLine(addRuntime.formatAddHelpText());
-      }
-      throw createCliDiagnosticCodeError6(CLI_DIAGNOSTIC_CODES7.MISSING_ARGUMENT, `\`wp-typia add\` requires <kind>. Usage: wp-typia add ${formatAddKindUsagePlaceholder()} ...`);
-    }
-    if (!isAddKindId(kind)) {
-      throw createCliDiagnosticCodeError6(CLI_DIAGNOSTIC_CODES7.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.`);
-    }
-    const executionContext = {
-      addRuntime,
-      cwd,
-      flags,
-      getOrCreatePrompt: async () => {
-        if (activePrompt) {
-          return activePrompt;
-        }
-        const { createReadlinePrompt } = await loadCliPromptRuntime();
-        activePrompt = prompt ?? createReadlinePrompt();
-        return activePrompt;
-      },
-      isInteractiveSession,
-      name,
-      warnLine
-    };
-    return await executePlannedAddKind(kind, executionContext, {
-      cwd,
-      dryRun,
-      emitOutput,
-      printLine
-    });
+    const { runDoctor } = await loadCliDoctorRuntime();
+    await runDoctor(cwd);
   } catch (error) {
-    if (!shouldWrapCliCommandError({ emitOutput })) {
-      throw error;
-    }
-    throw await wrapCliCommandError("add", error);
-  } finally {
-    if (activePrompt && activePrompt !== prompt) {
-      activePrompt.close();
-    }
-  }
-}
-async function executeTemplatesCommand({ flags }, printLine = console.log) {
-  const {
-    formatTemplateDetails,
-    formatTemplateFeatures,
-    formatTemplateSummary,
-    getTemplateById,
-    listTemplates
-  } = await loadCliTemplatesRuntime();
-  const subcommand = flags.subcommand ?? "list";
-  if (subcommand === "list") {
-    for (const template of listTemplates()) {
-      printBlock([formatTemplateSummary(template), formatTemplateFeatures(template)], printLine);
-    }
-    return;
-  }
-  if (subcommand === "inspect") {
-    if (!flags.id) {
-      throw createCliDiagnosticCodeError6(CLI_DIAGNOSTIC_CODES7.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}".`);
-    }
-    printBlock([formatTemplateDetails(template)], printLine);
-    return;
+    throw await wrapCliCommandError("doctor", error);
   }
-  throw createCliDiagnosticCodeError6(CLI_DIAGNOSTIC_CODES7.INVALID_COMMAND, `Unknown templates subcommand "${subcommand}". Expected list or inspect.`);
 }
+// src/runtime-bridge-init.ts
+import path3 from "node:path";
+var loadCliInitRuntime = () => import("@wp-typia/project-tools/cli-init");
 async function executeInitCommand({ apply, cwd, packageManager, projectDir }, options = {}) {
   try {
     const { runInitCommand } = await loadCliInitRuntime();
-    const resolvedProjectDir = projectDir ? (await import("node:path")).resolve(cwd, projectDir) : cwd;
+    const resolvedProjectDir = projectDir ? path3.resolve(cwd, projectDir) : cwd;
     const plan = await runInitCommand({
       apply,
       packageManager,
@@ -2575,18 +2526,12 @@ async function executeInitCommand({ apply, cwd, packageManager, projectDir }, op
   } catch (error) {
     if (!shouldWrapCliCommandError({ emitOutput: options.emitOutput })) {
       throw error;
-    }
-    throw await wrapCliCommandError("init", error);
-  }
-}
-async function executeDoctorCommand(cwd) {
-  try {
-    const { runDoctor } = await loadCliDoctorRuntime();
-    await runDoctor(cwd);
-  } catch (error) {
-    throw await wrapCliCommandError("doctor", error);
+    }
+    throw await wrapCliCommandError("init", error);
   }
 }
+// src/runtime-bridge-migrate.ts
+var loadMigrationsRuntime = () => import("@wp-typia/project-tools/migrations");
 async function executeMigrateCommand({
   command,
   cwd,
@@ -2594,12 +2539,17 @@ async function executeMigrateCommand({
   prompt,
   renderLine
 }) {
-  const { formatMigrationHelpText, parseMigrationArgs, runMigrationCommand } = await loadMigrationsRuntime();
-  if (!command) {
-    console.log(formatMigrationHelpText());
-    return;
-  }
   try {
+    const { formatMigrationHelpText, parseMigrationArgs, runMigrationCommand } = await loadMigrationsRuntime();
+    if (!command) {
+      const helpText = formatMigrationHelpText();
+      if (renderLine) {
+        renderLine(helpText);
+      } else {
+        console.log(helpText);
+      }
+      return;
+    }
     const argv = [command];
     pushFlag(argv, "all", flags.all);
     pushFlag(argv, "force", flags.force);
@@ -2639,13 +2589,261 @@ async function executeMigrateCommand({
     throw await wrapCliCommandError("migrate", error);
   }
 }
-
-// src/command-contract.ts
-import path4 from "node:path";
+// src/runtime-bridge-templates.ts
 import {
   CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES8,
   createCliDiagnosticCodeError as createCliDiagnosticCodeError7
 } from "@wp-typia/project-tools/cli-diagnostics";
+var loadCliTemplatesRuntime2 = () => import("@wp-typia/project-tools/cli-templates");
+async function executeTemplatesCommand({ flags }, printLine = console.log) {
+  const {
+    formatTemplateDetails,
+    formatTemplateFeatures,
+    formatTemplateSummary,
+    getTemplateById,
+    listTemplates
+  } = await loadCliTemplatesRuntime2();
+  const subcommand = flags.subcommand ?? "list";
+  if (subcommand === "list") {
+    for (const template of listTemplates()) {
+      printBlock(printLine, [formatTemplateSummary(template), formatTemplateFeatures(template)]);
+    }
+    return;
+  }
+  if (subcommand === "inspect") {
+    if (!flags.id) {
+      throw createCliDiagnosticCodeError7(CLI_DIAGNOSTIC_CODES8.MISSING_ARGUMENT, "`wp-typia templates inspect` requires <template-id>.");
+    }
+    const template = getTemplateById(flags.id);
+    if (!template) {
+      throw createCliDiagnosticCodeError7(CLI_DIAGNOSTIC_CODES8.INVALID_ARGUMENT, `Unknown template "${flags.id}".`);
+    }
+    printBlock(printLine, [formatTemplateDetails(template)]);
+    return;
+  }
+  throw createCliDiagnosticCodeError7(CLI_DIAGNOSTIC_CODES8.INVALID_COMMAND, `Unknown templates subcommand "${subcommand}". Expected list or inspect.`);
+}
+// src/runtime-bridge-sync.ts
+import { spawnSync } from "node:child_process";
+import fs3 from "node:fs";
+import path4 from "node:path";
+import {
+  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES9,
+  createCliDiagnosticCodeError as createCliDiagnosticCodeError8
+} from "@wp-typia/project-tools/cli-diagnostics";
+import {
+  formatInstallCommand,
+  formatRunScript,
+  inferPackageManagerId as inferPackageManagerId2
+} from "@wp-typia/project-tools/package-managers";
+var SYNC_INSTALL_MARKERS = [
+  "node_modules",
+  ".pnp.cjs",
+  ".pnp.loader.mjs"
+];
+var LOCAL_SYNC_TOOL_PATTERN = /(^|[\s;&|()])(?:tsx|wp-scripts)(?=($|[\s;&|()]))/u;
+var CAPTURED_SYNC_OUTPUT_MAX_BUFFER = 16 * 1024 * 1024;
+function resolveSyncExecutionTarget(subcommand) {
+  if (!subcommand) {
+    return "default";
+  }
+  if (subcommand === "ai") {
+    return "ai";
+  }
+  throw createCliDiagnosticCodeError8(CLI_DIAGNOSTIC_CODES9.INVALID_COMMAND, `Unknown sync subcommand "${subcommand}". Expected one of: "ai".`);
+}
+function getSyncRootError(cwd) {
+  return createCliDiagnosticCodeError8(CLI_DIAGNOSTIC_CODES9.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 readSyncPackageJson(packageJsonPath) {
+  const source = fs3.readFileSync(packageJsonPath, "utf8");
+  try {
+    return JSON.parse(source);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw createCliDiagnosticCodeError8(CLI_DIAGNOSTIC_CODES9.INVALID_ARGUMENT, `Unable to parse ${packageJsonPath}: ${message}`, error instanceof Error ? { cause: error } : undefined);
+  }
+}
+function resolveSyncProjectContext(cwd) {
+  const packageJsonPath = path4.join(cwd, "package.json");
+  if (!fs3.existsSync(packageJsonPath)) {
+    throw getSyncRootError(cwd);
+  }
+  const packageJson = readSyncPackageJson(packageJsonPath);
+  const scripts = packageJson.scripts ?? {};
+  const syncScripts = {
+    sync: typeof scripts.sync === "string" ? {
+      command: scripts.sync,
+      scriptName: "sync"
+    } : undefined,
+    "sync-ai": typeof scripts["sync-ai"] === "string" ? {
+      command: scripts["sync-ai"],
+      scriptName: "sync-ai"
+    } : typeof scripts["sync-wordpress-ai"] === "string" ? {
+      command: scripts["sync-wordpress-ai"],
+      scriptName: "sync-wordpress-ai"
+    } : undefined,
+    "sync-rest": typeof scripts["sync-rest"] === "string" ? {
+      command: scripts["sync-rest"],
+      scriptName: "sync-rest"
+    } : undefined,
+    "sync-types": typeof scripts["sync-types"] === "string" ? {
+      command: scripts["sync-types"],
+      scriptName: "sync-types"
+    } : undefined
+  };
+  return {
+    cwd,
+    packageJsonPath,
+    packageManager: inferPackageManagerId2(cwd, packageJson.packageManager),
+    scripts: syncScripts
+  };
+}
+function findInstalledDependencyMarkerDir(projectDir) {
+  let currentDir = path4.resolve(projectDir);
+  while (true) {
+    if (SYNC_INSTALL_MARKERS.some((marker) => fs3.existsSync(path4.join(currentDir, marker)))) {
+      return currentDir;
+    }
+    const parentDir = path4.dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+function scriptsLikelyNeedInstalledDependencies(project, target) {
+  const candidateScripts = target === "ai" ? [project.scripts["sync-ai"]] : project.scripts.sync ? [project.scripts.sync] : [
+    project.scripts["sync-types"],
+    project.scripts["sync-rest"],
+    project.scripts["sync-ai"]
+  ];
+  return candidateScripts.some((script) => script !== undefined && LOCAL_SYNC_TOOL_PATTERN.test(script.command));
+}
+function assertSyncDependenciesInstalled(project, target) {
+  if (!scriptsLikelyNeedInstalledDependencies(project, target)) {
+    return;
+  }
+  const markerDir = findInstalledDependencyMarkerDir(project.cwd);
+  if (markerDir) {
+    return;
+  }
+  throw createCliDiagnosticCodeError8(CLI_DIAGNOSTIC_CODES9.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) {
+    case "bun":
+      return { args: ["run", scriptName, ...extraArgs], command: "bun" };
+    case "npm":
+      return {
+        args: [
+          "run",
+          scriptName,
+          ...extraArgs.length > 0 ? ["--", ...extraArgs] : []
+        ],
+        command: "npm"
+      };
+    case "pnpm":
+      return { args: ["run", scriptName, ...extraArgs], command: "pnpm" };
+    case "yarn":
+      return { args: ["run", scriptName, ...extraArgs], command: "yarn" };
+  }
+}
+function createSyncPlannedCommand(project, scriptName, extraArgs) {
+  const script = project.scripts[scriptName];
+  if (!script) {
+    return null;
+  }
+  const invocation = getPackageManagerRunInvocation(project.packageManager, script.scriptName, extraArgs);
+  return {
+    args: invocation.args,
+    command: invocation.command,
+    displayCommand: formatRunScript(project.packageManager, script.scriptName, extraArgs.join(" ")),
+    scriptName: script.scriptName
+  };
+}
+function buildSyncPlannedCommands(project, extraArgs, target) {
+  if (target === "ai") {
+    const syncAiCommand2 = createSyncPlannedCommand(project, "sync-ai", extraArgs);
+    if (!syncAiCommand2) {
+      throw createCliDiagnosticCodeError8(CLI_DIAGNOSTIC_CODES9.CONFIGURATION_MISSING, `Expected ${project.packageJsonPath} to define a \`sync-ai\` script for \`wp-typia sync ai\`.`);
+    }
+    return [syncAiCommand2];
+  }
+  if (project.scripts.sync) {
+    return [createSyncPlannedCommand(project, "sync", extraArgs)];
+  }
+  const syncTypesCommand = createSyncPlannedCommand(project, "sync-types", extraArgs);
+  if (!syncTypesCommand) {
+    throw createCliDiagnosticCodeError8(CLI_DIAGNOSTIC_CODES9.CONFIGURATION_MISSING, `Expected ${project.packageJsonPath} to define either a \`sync\` or \`sync-types\` script.`);
+  }
+  const plannedCommands = [syncTypesCommand];
+  const syncRestCommand = createSyncPlannedCommand(project, "sync-rest", extraArgs);
+  if (syncRestCommand) {
+    plannedCommands.push(syncRestCommand);
+  }
+  const syncAiCommand = createSyncPlannedCommand(project, "sync-ai", extraArgs);
+  if (syncAiCommand) {
+    plannedCommands.push(syncAiCommand);
+  }
+  return plannedCommands;
+}
+function runProjectScript(project, plannedCommand, options) {
+  const result = spawnSync(plannedCommand.command, plannedCommand.args, {
+    cwd: project.cwd,
+    encoding: options.captureOutput ? "utf8" : undefined,
+    ...options.captureOutput ? { maxBuffer: CAPTURED_SYNC_OUTPUT_MAX_BUFFER } : {},
+    shell: process.platform === "win32",
+    stdio: options.captureOutput ? "pipe" : "inherit"
+  });
+  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 createCliDiagnosticCodeError8(CLI_DIAGNOSTIC_CODES9.COMMAND_EXECUTION, `\`${plannedCommand.displayCommand}\` failed.`, {
+      cause: result.error ?? (stderr ? new Error(stderr.trim()) : undefined)
+    });
+  }
+  return {
+    ...plannedCommand,
+    exitCode: result.status ?? 0,
+    ...stderr !== undefined ? { stderr } : {},
+    ...stdout !== undefined ? { stdout } : {}
+  };
+}
+async function executeSyncCommand({
+  captureOutput = false,
+  check = false,
+  cwd,
+  dryRun = false,
+  target = "default"
+}) {
+  const project = resolveSyncProjectContext(cwd);
+  const extraArgs = check ? ["--check"] : [];
+  const plannedCommands = buildSyncPlannedCommands(project, extraArgs, target);
+  const result = {
+    check,
+    dryRun,
+    packageJsonPath: project.packageJsonPath,
+    packageManager: project.packageManager,
+    plannedCommands,
+    projectDir: project.cwd,
+    target
+  };
+  if (dryRun) {
+    return result;
+  }
+  assertSyncDependenciesInstalled(project, target);
+  result.executedCommands = plannedCommands.map((plannedCommand) => runProjectScript(project, plannedCommand, {
+    captureOutput
+  }));
+  return result;
+}
+// src/command-contract.ts
+import path5 from "node:path";
+import {
+  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES10,
+  createCliDiagnosticCodeError as createCliDiagnosticCodeError9
+} from "@wp-typia/project-tools/cli-diagnostics";
 
 // src/command-registry.ts
 var WP_TYPIA_CANONICAL_CREATE_USAGE = "wp-typia create <project-dir>";
@@ -2686,7 +2884,7 @@ var WP_TYPIA_COMMAND_REGISTRY = [
     nodeFallback: true,
     optionGroups: ["add"],
     requiresBunRuntime: false,
-    subcommands: ADD_KIND_IDS
+    subcommands: ADD_KIND_IDS2
   },
   {
     commandTree: true,
@@ -2913,12 +3111,12 @@ function looksLikeStructuredProjectInput(value) {
   return value.startsWith("@") && value.includes("/");
 }
 function assertPositionalAliasProjectDir(projectDir) {
-  const normalizedProjectDir = path4.normalize(projectDir).replace(/[\\/]+$/u, "") || path4.normalize(projectDir);
+  const normalizedProjectDir = path5.normalize(projectDir).replace(/[\\/]+$/u, "") || path5.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 createCliDiagnosticCodeError9(CLI_DIAGNOSTIC_CODES10.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 createCliDiagnosticCodeError9(CLI_DIAGNOSTIC_CODES10.INVALID_ARGUMENT, `The positional alias only accepts unambiguous local project directories. Use \`${WP_TYPIA_CANONICAL_CREATE_USAGE}\` for \`${projectDir}\`.`);
   }
 }
 function normalizeWpTypiaArgv(argv) {
@@ -2932,7 +3130,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 createCliDiagnosticCodeError9(CLI_DIAGNOSTIC_CODES10.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 +3138,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 createCliDiagnosticCodeError9(CLI_DIAGNOSTIC_CODES10.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,26 +3152,25 @@ function normalizeWpTypiaArgv(argv) {
 
 // src/node-fallback/dispatchers/add.ts
 import {
-  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES9,
+  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES11,
   createCliCommandError as createCliCommandError3
 } from "@wp-typia/project-tools/cli-diagnostics";
 async function dispatchNodeFallbackAdd({
   cwd,
   mergedFlags,
   positionals,
-  printLine
+  printLine,
+  warnLine
 }) {
   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_CODES11.MISSING_ARGUMENT,
       command: "add",
-      detailLines: [
-        `\`wp-typia add\` requires <kind>. Usage: wp-typia add ${formatAddKindUsagePlaceholder()} ...`
-      ]
+      detailLines: buildMissingAddKindDetailLines()
     });
   }
   if (mergedFlags.format === "json") {
@@ -2985,7 +3182,9 @@ async function dispatchNodeFallbackAdd({
         flags: mergedFlags,
         interactive: false,
         kind: positionals[1],
-        name: positionals[2]
+        name: positionals[2],
+        printLine,
+        warnLine
       });
     } catch (error) {
       throw createCliCommandError3({
@@ -3006,30 +3205,30 @@ async function dispatchNodeFallbackAdd({
     flags: mergedFlags,
     interactive: undefined,
     kind: positionals[1],
-    name: positionals[2]
+    name: positionals[2],
+    printLine,
+    warnLine
   });
 }
 
 // src/node-fallback/dispatchers/create.ts
 import {
-  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES10,
+  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES12,
   createCliCommandError as createCliCommandError4
 } from "@wp-typia/project-tools/cli-diagnostics";
 async function dispatchNodeFallbackCreate({
   cwd,
   mergedFlags,
   positionals,
-  printLine
+  printLine,
+  warnLine
 }) {
   const projectDir = positionals[1];
   if (!projectDir) {
     throw createCliCommandError4({
-      code: CLI_DIAGNOSTIC_CODES10.MISSING_ARGUMENT,
+      code: CLI_DIAGNOSTIC_CODES12.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;
@@ -3039,7 +3238,9 @@ async function dispatchNodeFallbackCreate({
       emitOutput: mergedFlags.format !== "json",
       flags: mergedFlags,
       interactive: mergedFlags.format === "json" ? false : undefined,
-      projectDir
+      printLine,
+      projectDir,
+      warnLine
     });
   } catch (error) {
     throw createCliCommandError4({
@@ -3064,13 +3265,9 @@ 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);
-  }
-}
+var NODE_FALLBACK_NO_COMMAND_REASON_LINE = "No command provided. Run wp-typia --help for usage information.";
 function renderGeneralHelp(printLine) {
-  printBlock2(printLine, [
+  printBlock(printLine, [
     `wp-typia ${package_default.version}`,
     "",
     "Canonical CLI package for wp-typia scaffolding and project workflows.",
@@ -3087,8 +3284,12 @@ function renderGeneralHelp(printLine) {
     `- ${WP_TYPIA_POSITIONAL_ALIAS_USAGE}`
   ]);
 }
+function renderNoCommandHelp(printLine) {
+  printBlock(printLine, [NODE_FALLBACK_NO_COMMAND_REASON_LINE, ""]);
+  renderGeneralHelp(printLine);
+}
 function renderNodeFallbackCommandHelp(printLine, config) {
-  printBlock2(printLine, [
+  printBlock(printLine, [
     config.heading,
     "",
     ...NODE_FALLBACK_RUNTIME_SUMMARY_LINES,
@@ -3146,6 +3347,9 @@ var NODE_FALLBACK_BOOLEAN_OPTION_NAMES = ["help", "version"];
 var printLine = (line) => {
   console.log(line);
 };
+var warnLine = (line) => {
+  console.warn(line);
+};
 function hasFlagBeforeTerminator(argv, flag) {
   for (const arg of argv) {
     if (arg === "--") {
@@ -3226,7 +3430,7 @@ function renderTemplatesJson(flags, subcommand) {
   const templateId = flags.id;
   if (!templateId) {
     throw createCliCommandError5({
-      code: CLI_DIAGNOSTIC_CODES11.MISSING_ARGUMENT,
+      code: CLI_DIAGNOSTIC_CODES13.MISSING_ARGUMENT,
       command: "templates",
       detailLines: ["`wp-typia templates inspect` requires <template-id>."]
     });
@@ -3234,7 +3438,7 @@ function renderTemplatesJson(flags, subcommand) {
   const template = getTemplateById(templateId);
   if (!template) {
     throw createCliCommandError5({
-      code: CLI_DIAGNOSTIC_CODES11.INVALID_ARGUMENT,
+      code: CLI_DIAGNOSTIC_CODES13.INVALID_ARGUMENT,
       command: "templates",
       detailLines: [`Unknown template "${templateId}".`]
     });
@@ -3245,7 +3449,7 @@ function renderTemplatesJson(flags, subcommand) {
 }
 function renderUnsupportedCommand(command) {
   throw createCliCommandError5({
-    code: CLI_DIAGNOSTIC_CODES11.UNSUPPORTED_COMMAND,
+    code: CLI_DIAGNOSTIC_CODES13.UNSUPPORTED_COMMAND,
     command,
     detailLines: [
       [
@@ -3271,7 +3475,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_CODES13.DOCTOR_CHECK_FAILED,
       command: "doctor",
       detailLines: getDoctorFailureDetailLines(checks),
       summary: "One or more doctor checks failed."
@@ -3291,7 +3495,9 @@ var NODE_FALLBACK_COMMAND_DISPATCHERS = {
   init: async ({
     cwd,
     mergedFlags,
-    positionals
+    positionals,
+    printLine: printLine2,
+    warnLine: warnLine2
   }) => {
     const plan = await executeInitCommand({
       apply: Boolean(mergedFlags.apply),
@@ -3299,10 +3505,12 @@ var NODE_FALLBACK_COMMAND_DISPATCHERS = {
       packageManager: typeof mergedFlags["package-manager"] === "string" ? mergedFlags["package-manager"] : undefined,
       projectDir: positionals[1]
     }, {
-      emitOutput: mergedFlags.format !== "json"
+      emitOutput: mergedFlags.format !== "json",
+      printLine: printLine2,
+      warnLine: warnLine2
     });
     if (mergedFlags.format === "json") {
-      printLine(JSON.stringify(buildStructuredInitSuccessPayload(plan), null, 2));
+      printLine2(JSON.stringify(buildStructuredInitSuccessPayload(plan), null, 2));
     }
   },
   migrate: async ({
@@ -3319,7 +3527,9 @@ var NODE_FALLBACK_COMMAND_DISPATCHERS = {
   sync: async ({
     cwd,
     mergedFlags,
-    positionals
+    positionals,
+    printLine: printLine2,
+    warnLine: warnLine2
   }) => {
     try {
       const syncTarget = resolveSyncExecutionTarget(positionals[1]);
@@ -3331,7 +3541,7 @@ var NODE_FALLBACK_COMMAND_DISPATCHERS = {
         target: syncTarget
       });
       if (mergedFlags.format === "json") {
-        printLine(JSON.stringify({
+        printLine2(JSON.stringify({
           sync
         }, null, 2));
         return;
@@ -3343,7 +3553,10 @@ var NODE_FALLBACK_COMMAND_DISPATCHERS = {
           plannedCommands: sync.plannedCommands,
           projectDir: sync.projectDir,
           target: sync.target
-        }));
+        }), {
+          printLine: printLine2,
+          warnLine: warnLine2
+        });
       }
     } catch (error) {
       throw createCliCommandError5({
@@ -3361,7 +3574,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_CODES13.INVALID_COMMAND,
         command: "templates",
         detailLines: [
           `Unknown templates subcommand "${resolvedSubcommand}". Expected list or inspect.`
@@ -3399,7 +3612,7 @@ async function runNodeCli(argv = process.argv.slice(2)) {
   const helpTarget = command === "help" ? subcommand : command;
   const versionRequested = hasFlagBeforeTerminator(cliArgv, "--version") || command === "version";
   if (cliArgv.length === 0) {
-    renderGeneralHelp(printLine);
+    renderNoCommandHelp(printLine);
     process.exitCode = 1;
     return;
   }
@@ -3434,7 +3647,8 @@ async function runNodeCli(argv = process.argv.slice(2)) {
       cwd: process.cwd(),
       mergedFlags,
       positionals,
-      printLine
+      printLine,
+      warnLine
     });
     return;
   }
@@ -3469,4 +3683,4 @@ export {
   hasFlagBeforeTerminator
 };
 
-//# debugId=8C4AF690141E04CA64756E2164756E21
+//# debugId=7726AE527215959664756E2164756E21