@unbrained/pm-cli 2026.7.5 → 2026.7.6

package/dist/cli-bundle/chunks/chunk-PJ3A56YF.js

@@ -1,1239 +0,0 @@
-
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="d5198112-9083-5c72-8583-3c24e460da48")}catch(e){}}();
-import {
-  acquireLock,
-  listAllFrontMatterLight
-} from "./chunk-57C2RLW5.js";
-import {
-  BUILTIN_STATUS_IDS,
-  TYPE_PRESET_NAMES,
-  assertStatusTokensAvailable,
-  normalizeAddFieldInput,
-  normalizeAddStatusInput,
-  normalizeFieldKey,
-  normalizeStatusToken,
-  normalizeTypePresetName,
-  parseFieldsFile,
-  parseStatusDefsFile,
-  removeField,
-  removeStatusDef,
-  resolveTypePresetDefinitions,
-  serializeFieldsFile,
-  serializeStatusDefsFile,
-  upsertField,
-  upsertStatusDef
-} from "./chunk-ZAHXPXVY.js";
-import {
-  nowIso
-} from "./chunk-FJRKQREY.js";
-import {
-  PmCliError,
-  getActiveExtensionRegistrations,
-  readSettings,
-  resolveGovernanceKnobs,
-  runActiveOnWriteHooks
-} from "./chunk-US3T3W5J.js";
-import {
-  assertAliasesAvailable,
-  assertTypeFolderAvailable,
-  escapeForDoubleQuotes,
-  matchBuiltinTypeName,
-  normalizeAddTypeInput,
-  parseItemTypesFile,
-  removeItemType,
-  serializeItemTypesFile,
-  upsertItemType
-} from "./chunk-NER3KUUS.js";
-import {
-  DEFAULT_RUNTIME_SCHEMA_FILE_PATHS,
-  EXIT_CODE,
-  filePathForSchemaSection,
-  getSettingsPath,
-  normalizeRuntimeSchemaSettings,
-  pathExists,
-  readFileIfExists,
-  resolveItemTypeRegistry,
-  resolvePmRoot,
-  resolveRuntimeFieldRegistry,
-  resolveRuntimeStatusRegistry,
-  toDefaultFolder,
-  writeFileAtomic
-} from "./chunk-YD5FML7K.js";
-
-// dist/cli/commands/schema.js
-import path from "node:path";
-import { mkdir } from "node:fs/promises";
-
-// dist/core/schema/type-inference.js
-var PREFIX_PATTERN = /^([A-Za-z][A-Za-z0-9_-]*?)\s*[-:]\s+\S/;
-function extractTitlePrefix(title) {
-  const match = PREFIX_PATTERN.exec(title.trim());
-  if (!match) {
-    return void 0;
-  }
-  const token = match[1];
-  if (token.length < 2) {
-    return void 0;
-  }
-  if (/^[A-Za-z]\d+$/.test(token)) {
-    return void 0;
-  }
-  return token.toLowerCase();
-}
-function prefixToTypeName(prefix) {
-  return prefix.split(/[-_]+/).filter((segment) => segment.length > 0).map((segment) => `${segment.slice(0, 1).toUpperCase()}${segment.slice(1).toLowerCase()}`).join("");
-}
-function inferTypesFromTitles(titles, options = {}) {
-  const minCount = typeof options.minCount === "number" && options.minCount > 0 ? Math.trunc(options.minCount) : 10;
-  const maxExamples = typeof options.maxExamples === "number" && options.maxExamples > 0 ? Math.trunc(options.maxExamples) : 3;
-  const byPrefix = /* @__PURE__ */ new Map();
-  for (const rawTitle of titles) {
-    const title = typeof rawTitle === "string" ? rawTitle.trim() : "";
-    if (title.length === 0) {
-      continue;
-    }
-    const prefix = extractTitlePrefix(title);
-    if (prefix === void 0) {
-      continue;
-    }
-    const bucket = byPrefix.get(prefix) ?? { count: 0, examples: [] };
-    bucket.count += 1;
-    if (bucket.examples.length < maxExamples) {
-      bucket.examples.push(title);
-    }
-    byPrefix.set(prefix, bucket);
-  }
-  const candidates = [];
-  for (const [prefix, bucket] of byPrefix.entries()) {
-    if (bucket.count < minCount) {
-      continue;
-    }
-    const name = prefixToTypeName(prefix);
-    candidates.push({
-      name,
-      prefix,
-      count: bucket.count,
-      examples: bucket.examples,
-      shadows_builtin: matchBuiltinTypeName(name) !== void 0
-    });
-  }
-  candidates.sort((left, right) => right.count - left.count || left.name.localeCompare(right.name));
-  return candidates;
-}
-
-// dist/cli/commands/schema.js
-var SCHEMA_SUBCOMMANDS = [
-  "add-type",
-  "remove-type",
-  "add-status",
-  "remove-status",
-  "add-field",
-  "remove-field",
-  "list-fields",
-  "show-field",
-  "apply-preset",
-  "list",
-  "show",
-  "show-status"
-];
-var SCHEMA_TYPES_LOCK_ID = "schema-types";
-var SCHEMA_STATUSES_LOCK_ID = "schema-statuses";
-var SCHEMA_FIELDS_LOCK_ID = "schema-fields";
-function toAuthor(candidate, defaultAuthor) {
-  const resolved = candidate ?? process.env.PM_AUTHOR ?? defaultAuthor;
-  const trimmed = resolved.trim();
-  return trimmed.length > 0 ? trimmed : "unknown";
-}
-async function runSchemaAddType(name, options, global) {
-  const pmRoot = resolvePmRoot(process.cwd(), global.path);
-  if (!await pathExists(getSettingsPath(pmRoot))) {
-    throw new PmCliError(`Tracker is not initialized at ${pmRoot}. Run pm init first.`, EXIT_CODE.NOT_FOUND);
-  }
-  let normalized;
-  try {
-    normalized = normalizeAddTypeInput({
-      name,
-      description: options.description,
-      defaultStatus: options.defaultStatus,
-      folder: options.folder,
-      aliases: options.alias
-    });
-  } catch (error) {
-    throw new PmCliError(error instanceof Error ? error.message : String(error), EXIT_CODE.USAGE);
-  }
-  const settings = await readSettings(pmRoot);
-  const schema = normalizeRuntimeSchemaSettings(settings.schema);
-  const typesPath = filePathForSchemaSection(pmRoot, schema.files.types, DEFAULT_RUNTIME_SCHEMA_FILE_PATHS.types);
-  const warnings = [];
-  const author = toAuthor(options.author, settings.author_default);
-  const governance = resolveGovernanceKnobs(settings);
-  const releaseLock = await acquireLock(pmRoot, SCHEMA_TYPES_LOCK_ID, settings.locks.ttl_seconds, author, Boolean(options.force), governance.force_required_for_stale_lock, settings.locks.wait_ms);
-  let upsert;
-  try {
-    const previousRaw = await readFileIfExists(typesPath);
-    let parsed;
-    try {
-      parsed = parseItemTypesFile(previousRaw);
-    } catch (error) {
-      throw new PmCliError(error instanceof Error ? error.message : String(error), EXIT_CODE.GENERIC_FAILURE);
-    }
-    try {
-      assertAliasesAvailable(normalized, parsed);
-      const reservedFolders = /* @__PURE__ */ new Map();
-      const resolvedRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
-      for (const [typeName, folder] of Object.entries(resolvedRegistry.type_to_folder)) {
-        const folderKey = folder.trim().toLowerCase();
-        if (folderKey.length > 0 && !reservedFolders.has(folderKey)) {
-          reservedFolders.set(folderKey, typeName);
-        }
-      }
-      assertTypeFolderAvailable(normalized, parsed, reservedFolders);
-    } catch (error) {
-      throw new PmCliError(error instanceof Error ? error.message : String(error), EXIT_CODE.USAGE);
-    }
-    upsert = upsertItemType(parsed, normalized);
-    if (upsert.replaced && upsert.previousName !== void 0 && upsert.previousName !== upsert.definition.name) {
-      warnings.push(`type_recased:${upsert.previousName}->${upsert.definition.name}`);
-    }
-    await writeFileAtomic(typesPath, serializeItemTypesFile(upsert.file));
-    await ensureTypeFolderScaffold(pmRoot, [upsert.definition], warnings, "schema:add-type-folder");
-    warnings.push(...await runActiveOnWriteHooks({
-      path: typesPath,
-      scope: "project",
-      op: "schema:add-type"
-    }));
-  } finally {
-    await releaseLock();
-  }
-  return {
-    action: "add-type",
-    registered: true,
-    replaced: upsert.replaced,
-    type: upsert.definition,
-    file: {
-      path: typesPath,
-      definitions: upsert.file.definitions.length
-    },
-    warnings: [...new Set(warnings)].sort((left, right) => left.localeCompare(right)),
-    generated_at: nowIso()
-  };
-}
-async function ensureInitialized(pmRoot) {
-  if (!await pathExists(getSettingsPath(pmRoot))) {
-    throw new PmCliError(`Tracker is not initialized at ${pmRoot}. Run pm init first.`, EXIT_CODE.NOT_FOUND);
-  }
-}
-async function countItemsUsingType(pmRoot, settings, schema, typeName) {
-  const registry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
-  const lowerName = typeName.trim().toLowerCase();
-  const items = await listAllFrontMatterLight(pmRoot, settings.item_format, registry.type_to_folder, [], schema);
-  return items.filter((item) => typeof item.type === "string" && item.type.toLowerCase() === lowerName).length;
-}
-async function countItemsUsingStatus(pmRoot, settings, schema, statusId) {
-  const registry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
-  const statusRegistry = resolveRuntimeStatusRegistry(schema);
-  const normalizedId = normalizeStatusToken(statusId);
-  const items = await listAllFrontMatterLight(pmRoot, settings.item_format, registry.type_to_folder, [], schema);
-  return items.filter((item) => {
-    const itemStatus = typeof item.status === "string" ? item.status : "";
-    const resolved = statusRegistry.alias_to_id.get(normalizeStatusToken(itemStatus)) ?? normalizeStatusToken(itemStatus);
-    return resolved === normalizedId;
-  }).length;
-}
-function workflowSlotsReferencing(workflow, statusId) {
-  const slots = [
-    ["draft_status", workflow.draft_status],
-    ["open_status", workflow.open_status],
-    ["in_progress_status", workflow.in_progress_status],
-    ["blocked_status", workflow.blocked_status],
-    ["close_status", workflow.close_status],
-    ["canceled_status", workflow.canceled_status]
-  ];
-  return slots.filter(([, value]) => value !== void 0 && normalizeStatusToken(value) === statusId).map(([slot]) => slot);
-}
-async function runSchemaRemoveType(name, options, global) {
-  const pmRoot = resolvePmRoot(process.cwd(), global.path);
-  await ensureInitialized(pmRoot);
-  const settings = await readSettings(pmRoot);
-  const schema = normalizeRuntimeSchemaSettings(settings.schema);
-  const typesPath = filePathForSchemaSection(pmRoot, schema.files.types, DEFAULT_RUNTIME_SCHEMA_FILE_PATHS.types);
-  const warnings = [];
-  const author = toAuthor(options.author, settings.author_default);
-  const governance = resolveGovernanceKnobs(settings);
-  const releaseLock = await acquireLock(pmRoot, SCHEMA_TYPES_LOCK_ID, settings.locks.ttl_seconds, author, Boolean(options.force), governance.force_required_for_stale_lock, settings.locks.wait_ms);
-  let removal;
-  try {
-    const previousRaw = await readFileIfExists(typesPath);
-    let parsed;
-    try {
-      parsed = parseItemTypesFile(previousRaw);
-    } catch (error) {
-      throw new PmCliError(error instanceof Error ? error.message : String(error), EXIT_CODE.GENERIC_FAILURE);
-    }
-    try {
-      removal = removeItemType(parsed, name);
-    } catch (error) {
-      throw new PmCliError(error instanceof Error ? error.message : String(error), EXIT_CODE.USAGE);
-    }
-    if (removal.removed) {
-      const removedName = (removal.definition?.name ?? name ?? "").trim();
-      if (removedName.length > 0) {
-        const usingType = await countItemsUsingType(pmRoot, settings, schema, removedName);
-        if (usingType > 0) {
-          warnings.push(`items_using_type:${usingType}`);
-        }
-      }
-      await writeFileAtomic(typesPath, serializeItemTypesFile(removal.file));
-      warnings.push(...await runActiveOnWriteHooks({
-        path: typesPath,
-        scope: "project",
-        op: "schema:remove-type"
-      }));
-    }
-  } finally {
-    await releaseLock();
-  }
-  return {
-    action: "remove-type",
-    removed: removal.removed,
-    ...removal.definition ? { type: removal.definition } : {},
-    file: {
-      path: typesPath,
-      definitions: removal.file.definitions.length
-    },
-    warnings: [...new Set(warnings)].sort((left, right) => left.localeCompare(right)),
-    generated_at: nowIso()
-  };
-}
-function statusesPathFor(pmRoot, schema) {
-  return filePathForSchemaSection(pmRoot, schema.files.statuses, DEFAULT_RUNTIME_SCHEMA_FILE_PATHS.statuses);
-}
-function fieldsPathFor(pmRoot, schema) {
-  return filePathForSchemaSection(pmRoot, schema.files.fields, DEFAULT_RUNTIME_SCHEMA_FILE_PATHS.fields);
-}
-function typesPathFor(pmRoot, schema) {
-  return filePathForSchemaSection(pmRoot, schema.files.types, DEFAULT_RUNTIME_SCHEMA_FILE_PATHS.types);
-}
-async function ensureTypeFolderScaffold(pmRoot, definitions, warnings, op) {
-  for (const definition of definitions) {
-    const folder = definition.folder ?? toDefaultFolder(definition.name);
-    const target = path.join(pmRoot, folder);
-    if (await pathExists(target)) {
-      continue;
-    }
-    await mkdir(target, { recursive: true });
-    warnings.push(...await runActiveOnWriteHooks({
-      path: target,
-      scope: "project",
-      op
-    }));
-  }
-}
-function toSchemaFieldSummary(field) {
-  return {
-    key: field.key,
-    type: field.type,
-    commands: [...field.commands],
-    cli_flag: `--${field.cli_flag}`,
-    cli_aliases: field.cli_aliases.map((alias) => `--${alias}`),
-    ...field.description ? { description: field.description } : {},
-    required: field.required,
-    required_on_create: field.required_on_create,
-    allow_unset: field.allow_unset,
-    required_types: [...field.required_types]
-  };
-}
-function toExistingStatusDefinition(resolvedExisting) {
-  if (!resolvedExisting) {
-    return void 0;
-  }
-  return {
-    id: resolvedExisting.id,
-    ...resolvedExisting.roles.length > 0 ? { roles: [...resolvedExisting.roles] } : {},
-    ...resolvedExisting.aliases.length > 0 ? { aliases: [...resolvedExisting.aliases] } : {},
-    ...resolvedExisting.description ? { description: resolvedExisting.description } : {},
-    ...typeof resolvedExisting.order === "number" ? { order: resolvedExisting.order } : {}
-  };
-}
-function buildStatusFileAliasMap(statuses) {
-  const fileAliasToId = /* @__PURE__ */ new Map();
-  for (const definition of statuses) {
-    const defId = normalizeStatusToken(definition.id);
-    if (defId.length === 0) {
-      continue;
-    }
-    fileAliasToId.set(defId, defId);
-    for (const alias of Array.isArray(definition.aliases) ? definition.aliases : []) {
-      const aliasToken = normalizeStatusToken(alias);
-      if (aliasToken.length > 0 && !fileAliasToId.has(aliasToken)) {
-        fileAliasToId.set(aliasToken, defId);
-      }
-    }
-  }
-  return fileAliasToId;
-}
-async function runSchemaAddStatus(id, options, global) {
-  const pmRoot = resolvePmRoot(process.cwd(), global.path);
-  await ensureInitialized(pmRoot);
-  let normalized;
-  try {
-    normalized = normalizeAddStatusInput({
-      id,
-      roles: options.role,
-      aliases: options.alias,
-      description: options.description,
-      order: options.order
-    });
-  } catch (error) {
-    throw new PmCliError(error instanceof Error ? error.message : String(error), EXIT_CODE.USAGE);
-  }
-  const settings = await readSettings(pmRoot);
-  const schema = normalizeRuntimeSchemaSettings(settings.schema);
-  const statusesPath = statusesPathFor(pmRoot, schema);
-  const statusRegistry = resolveRuntimeStatusRegistry(schema);
-  try {
-    assertStatusTokensAvailable(normalized, statusRegistry.alias_to_id);
-  } catch (error) {
-    throw new PmCliError(error instanceof Error ? error.message : String(error), EXIT_CODE.USAGE);
-  }
-  const baseDefinition = toExistingStatusDefinition(statusRegistry.by_id.get(normalized.id));
-  const warnings = [];
-  const author = toAuthor(options.author, settings.author_default);
-  const governance = resolveGovernanceKnobs(settings);
-  const releaseLock = await acquireLock(pmRoot, SCHEMA_STATUSES_LOCK_ID, settings.locks.ttl_seconds, author, Boolean(options.force), governance.force_required_for_stale_lock, settings.locks.wait_ms);
-  let upsert;
-  try {
-    const previousRaw = await readFileIfExists(statusesPath);
-    let parsed;
-    try {
-      parsed = parseStatusDefsFile(previousRaw);
-    } catch (error) {
-      throw new PmCliError(error instanceof Error ? error.message : String(error), EXIT_CODE.GENERIC_FAILURE);
-    }
-    const fileAliasToId = buildStatusFileAliasMap(parsed.statuses);
-    try {
-      assertStatusTokensAvailable(normalized, fileAliasToId);
-    } catch (error) {
-      throw new PmCliError(error instanceof Error ? error.message : String(error), EXIT_CODE.USAGE);
-    }
-    upsert = upsertStatusDef(parsed, normalized, baseDefinition);
-    await writeFileAtomic(statusesPath, serializeStatusDefsFile(upsert.file));
-    warnings.push(...await runActiveOnWriteHooks({
-      path: statusesPath,
-      scope: "project",
-      op: "schema:add-status"
-    }));
-  } finally {
-    await releaseLock();
-  }
-  return {
-    action: "add-status",
-    registered: true,
-    replaced: upsert.replaced,
-    status: upsert.definition,
-    file: {
-      path: statusesPath,
-      statuses: upsert.file.statuses.length
-    },
-    warnings: [...new Set(warnings)].sort((left, right) => left.localeCompare(right)),
-    generated_at: nowIso()
-  };
-}
-async function runSchemaRemoveStatus(id, options, global) {
-  const pmRoot = resolvePmRoot(process.cwd(), global.path);
-  await ensureInitialized(pmRoot);
-  const settings = await readSettings(pmRoot);
-  const schema = normalizeRuntimeSchemaSettings(settings.schema);
-  const statusesPath = statusesPathFor(pmRoot, schema);
-  const warnings = [];
-  const author = toAuthor(options.author, settings.author_default);
-  const governance = resolveGovernanceKnobs(settings);
-  const releaseLock = await acquireLock(pmRoot, SCHEMA_STATUSES_LOCK_ID, settings.locks.ttl_seconds, author, Boolean(options.force), governance.force_required_for_stale_lock, settings.locks.wait_ms);
-  let removal;
-  try {
-    const previousRaw = await readFileIfExists(statusesPath);
-    let parsed;
-    try {
-      parsed = parseStatusDefsFile(previousRaw);
-    } catch (error) {
-      throw new PmCliError(error instanceof Error ? error.message : String(error), EXIT_CODE.GENERIC_FAILURE);
-    }
-    try {
-      removal = removeStatusDef(parsed, id);
-    } catch (error) {
-      throw new PmCliError(error instanceof Error ? error.message : String(error), EXIT_CODE.USAGE);
-    }
-    if (removal.removed) {
-      const removedId = normalizeStatusToken(removal.definition?.id ?? id);
-      if (removedId.length > 0 && !BUILTIN_STATUS_IDS.has(removedId)) {
-        const usingStatus = await countItemsUsingStatus(pmRoot, settings, schema, removedId);
-        if (usingStatus > 0) {
-          warnings.push(`items_using_status:${usingStatus}`);
-        }
-        const referencingSlots = workflowSlotsReferencing(schema.workflow, removedId);
-        if (referencingSlots.length > 0) {
-          warnings.push(`status_referenced_by_workflow:${referencingSlots.join(",")}`);
-        }
-      }
-      await writeFileAtomic(statusesPath, serializeStatusDefsFile(removal.file));
-      warnings.push(...await runActiveOnWriteHooks({
-        path: statusesPath,
-        scope: "project",
-        op: "schema:remove-status"
-      }));
-    }
-  } finally {
-    await releaseLock();
-  }
-  return {
-    action: "remove-status",
-    removed: removal.removed,
-    ...removal.definition ? { status: removal.definition } : {},
-    file: {
-      path: statusesPath,
-      statuses: removal.file.statuses.length
-    },
-    warnings: [...new Set(warnings)].sort((left, right) => left.localeCompare(right)),
-    generated_at: nowIso()
-  };
-}
-function toSchemaTypeSummary(definition) {
-  return {
-    name: definition.name,
-    folder: definition.folder,
-    aliases: Array.isArray(definition.aliases) ? [...definition.aliases] : [],
-    ...definition.default_status ? { default_status: definition.default_status } : {},
-    ...definition.description ? { description: definition.description } : {}
-  };
-}
-function toSchemaTypeDefinition(definition, source, extensionProvenance) {
-  return {
-    ...toSchemaTypeSummary(definition),
-    source,
-    ...extensionProvenance ? { extension: extensionProvenance } : {},
-    required_create_fields: [...definition.required_create_fields],
-    required_create_repeatables: [...definition.required_create_repeatables],
-    options: structuredClone(definition.options),
-    command_option_policies: structuredClone(definition.command_option_policies)
-  };
-}
-function toSchemaStatusSummary(definition) {
-  return {
-    id: definition.id,
-    source: BUILTIN_STATUS_IDS.has(definition.id) ? "builtin" : "custom",
-    roles: Array.isArray(definition.roles) ? [...definition.roles] : [],
-    aliases: Array.isArray(definition.aliases) ? [...definition.aliases] : [],
-    ...definition.description ? { description: definition.description } : {},
-    ...typeof definition.order === "number" ? { order: definition.order } : {}
-  };
-}
-function classifyTypeSource(name, customNames, extensionNames) {
-  const lowerName = name.toLowerCase();
-  if (extensionNames.has(lowerName)) {
-    return "extension";
-  }
-  if (customNames.has(lowerName)) {
-    return "custom";
-  }
-  return "builtin";
-}
-function collectExtensionTypeProvenance() {
-  const provenance = /* @__PURE__ */ new Map();
-  const registrations = getActiveExtensionRegistrations();
-  for (const registration of registrations?.item_types ?? []) {
-    const rawTypes = registration.types;
-    if (!Array.isArray(rawTypes)) {
-      continue;
-    }
-    for (const rawType of rawTypes) {
-      if (typeof rawType !== "object" || rawType === null || Array.isArray(rawType)) {
-        continue;
-      }
-      const name = rawType.name;
-      if (typeof name === "string" && name.trim().length > 0) {
-        provenance.set(name.trim().toLowerCase(), {
-          layer: registration.layer,
-          name: registration.name
-        });
-      }
-    }
-  }
-  return provenance;
-}
-function buildSchemaStatusSummaries(schema) {
-  const registry = resolveRuntimeStatusRegistry(schema);
-  const builtin = [];
-  const custom = [];
-  for (const definition of registry.definitions) {
-    const summary = toSchemaStatusSummary(definition);
-    if (summary.source === "builtin") {
-      builtin.push(summary);
-    } else {
-      custom.push(summary);
-    }
-  }
-  return { builtin, custom };
-}
-async function loadSchemaInspectionContext(global) {
-  const pmRoot = resolvePmRoot(process.cwd(), global.path);
-  if (!await pathExists(getSettingsPath(pmRoot))) {
-    throw new PmCliError(`Tracker is not initialized at ${pmRoot}. Run pm init first.`, EXIT_CODE.NOT_FOUND);
-  }
-  const settings = await readSettings(pmRoot);
-  const schema = normalizeRuntimeSchemaSettings(settings.schema);
-  const typesPath = filePathForSchemaSection(pmRoot, schema.files.types, DEFAULT_RUNTIME_SCHEMA_FILE_PATHS.types);
-  const statusesPath = statusesPathFor(pmRoot, schema);
-  const registry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
-  const extensionProvenance = collectExtensionTypeProvenance();
-  const customNames = new Set((settings.item_types?.definitions ?? []).map((definition) => definition.name.trim().toLowerCase()).filter((name) => name.length > 0 && !extensionProvenance.has(name)));
-  return {
-    pmRoot,
-    typesPath,
-    statusesPath,
-    byType: registry.by_type,
-    customNames,
-    extensionProvenance,
-    schema
-  };
-}
-async function runSchemaList(global) {
-  const context = await loadSchemaInspectionContext(global);
-  const builtin = [];
-  const custom = [];
-  const extension = [];
-  for (const definition of Object.values(context.byType).sort((left, right) => left.name.localeCompare(right.name))) {
-    const source = classifyTypeSource(definition.name, context.customNames, new Set(context.extensionProvenance.keys()));
-    const summary = toSchemaTypeSummary(definition);
-    if (source === "extension") {
-      extension.push(summary);
-    } else if (source === "custom") {
-      custom.push(summary);
-    } else {
-      builtin.push(summary);
-    }
-  }
-  const statusSummaries = buildSchemaStatusSummaries(context.schema);
-  const fieldSummaries = resolveRuntimeFieldRegistry(context.schema).definitions.map(toSchemaFieldSummary);
-  return {
-    action: "list",
-    builtin,
-    custom,
-    extension,
-    counts: {
-      builtin: builtin.length,
-      custom: custom.length,
-      extension: extension.length,
-      total: builtin.length + custom.length + extension.length
-    },
-    statuses: {
-      builtin: statusSummaries.builtin,
-      custom: statusSummaries.custom,
-      counts: {
-        builtin: statusSummaries.builtin.length,
-        custom: statusSummaries.custom.length,
-        total: statusSummaries.builtin.length + statusSummaries.custom.length
-      }
-    },
-    fields: {
-      custom: fieldSummaries,
-      counts: {
-        total: fieldSummaries.length
-      }
-    },
-    file: {
-      path: context.typesPath
-    },
-    generated_at: nowIso()
-  };
-}
-async function runSchemaShow(name, global) {
-  const typeName = (name ?? "").trim();
-  if (typeName.length === 0) {
-    throw new PmCliError("Type name must not be empty.", EXIT_CODE.USAGE);
-  }
-  const context = await loadSchemaInspectionContext(global);
-  const match = Object.values(context.byType).find((definition) => definition.name.toLowerCase() === typeName.toLowerCase() || definition.aliases.some((alias) => alias.toLowerCase() === typeName.toLowerCase()));
-  if (!match) {
-    throw new PmCliError(`Unknown item type "${typeName}". Run pm schema list to inspect registered types, or pm schema add-type "${escapeForDoubleQuotes(typeName)}" to register it.`, EXIT_CODE.NOT_FOUND, { code: "unknown_item_type" });
-  }
-  return {
-    action: "show",
-    type: toSchemaTypeDefinition(match, classifyTypeSource(match.name, context.customNames, new Set(context.extensionProvenance.keys())), context.extensionProvenance.get(match.name.toLowerCase())),
-    file: {
-      path: context.typesPath
-    },
-    generated_at: nowIso()
-  };
-}
-async function runSchemaShowStatus(id, global) {
-  const statusToken = normalizeStatusToken(id);
-  if (statusToken.length === 0) {
-    throw new PmCliError("Status id must not be empty.", EXIT_CODE.USAGE);
-  }
-  const context = await loadSchemaInspectionContext(global);
-  const statusRegistry = resolveRuntimeStatusRegistry(context.schema);
-  const resolvedId = statusRegistry.alias_to_id.get(statusToken) ?? statusToken;
-  const match = statusRegistry.by_id.get(resolvedId);
-  if (!match) {
-    throw new PmCliError(`Unknown status "${id}". Run pm schema list to inspect registered statuses, or pm schema add-status "${escapeForDoubleQuotes(id ?? "")}" to register it.`, EXIT_CODE.NOT_FOUND, { code: "unknown_status" });
-  }
-  return {
-    action: "show-status",
-    status: toSchemaStatusSummary(match),
-    file: {
-      path: context.statusesPath
-    },
-    generated_at: nowIso()
-  };
-}
-async function runSchemaAddField(key, options, global) {
-  const pmRoot = resolvePmRoot(process.cwd(), global.path);
-  await ensureInitialized(pmRoot);
-  let normalized;
-  try {
-    normalized = normalizeAddFieldInput({
-      key,
-      type: options.type,
-      commands: options.commands,
-      description: options.description,
-      cliFlag: options.cliFlag,
-      aliases: options.alias,
-      required: options.required,
-      requiredOnCreate: options.requiredOnCreate,
-      allowUnset: options.allowUnset,
-      requiredTypes: options.requiredTypes
-    });
-  } catch (error) {
-    throw new PmCliError(error instanceof Error ? error.message : String(error), EXIT_CODE.USAGE);
-  }
-  const settings = await readSettings(pmRoot);
-  const schema = normalizeRuntimeSchemaSettings(settings.schema);
-  const fieldsPath = fieldsPathFor(pmRoot, schema);
-  const warnings = [];
-  const author = toAuthor(options.author, settings.author_default);
-  const governance = resolveGovernanceKnobs(settings);
-  const releaseLock = await acquireLock(pmRoot, SCHEMA_FIELDS_LOCK_ID, settings.locks.ttl_seconds, author, Boolean(options.force), governance.force_required_for_stale_lock, settings.locks.wait_ms);
-  let upsert;
-  try {
-    const previousRaw = await readFileIfExists(fieldsPath);
-    let parsed;
-    try {
-      parsed = parseFieldsFile(previousRaw);
-    } catch (error) {
-      throw new PmCliError(error instanceof Error ? error.message : String(error), EXIT_CODE.GENERIC_FAILURE);
-    }
-    upsert = upsertField(parsed, normalized);
-    await writeFileAtomic(fieldsPath, serializeFieldsFile(upsert.file));
-    warnings.push(...await runActiveOnWriteHooks({
-      path: fieldsPath,
-      scope: "project",
-      op: "schema:add-field"
-    }));
-  } finally {
-    await releaseLock();
-  }
-  return {
-    action: "add-field",
-    registered: true,
-    replaced: upsert.replaced,
-    field: upsert.definition,
-    file: {
-      path: fieldsPath,
-      fields: upsert.file.fields.length
-    },
-    warnings: [...new Set(warnings)].sort((left, right) => left.localeCompare(right)),
-    generated_at: nowIso()
-  };
-}
-async function countItemsUsingField(pmRoot, settings, schema, metadataKey) {
-  const registry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
-  const items = await listAllFrontMatterLight(pmRoot, settings.item_format, registry.type_to_folder, [], schema);
-  return items.filter((item) => {
-    const value = item[metadataKey];
-    if (value === void 0 || value === null) {
-      return false;
-    }
-    if (Array.isArray(value)) {
-      return value.length > 0;
-    }
-    if (typeof value === "string") {
-      return value.trim().length > 0;
-    }
-    return true;
-  }).length;
-}
-async function runSchemaRemoveField(key, options, global) {
-  const pmRoot = resolvePmRoot(process.cwd(), global.path);
-  await ensureInitialized(pmRoot);
-  const settings = await readSettings(pmRoot);
-  const schema = normalizeRuntimeSchemaSettings(settings.schema);
-  const fieldsPath = fieldsPathFor(pmRoot, schema);
-  const warnings = [];
-  const author = toAuthor(options.author, settings.author_default);
-  const governance = resolveGovernanceKnobs(settings);
-  const releaseLock = await acquireLock(pmRoot, SCHEMA_FIELDS_LOCK_ID, settings.locks.ttl_seconds, author, Boolean(options.force), governance.force_required_for_stale_lock, settings.locks.wait_ms);
-  let removal;
-  try {
-    const previousRaw = await readFileIfExists(fieldsPath);
-    let parsed;
-    try {
-      parsed = parseFieldsFile(previousRaw);
-    } catch (error) {
-      throw new PmCliError(error instanceof Error ? error.message : String(error), EXIT_CODE.GENERIC_FAILURE);
-    }
-    try {
-      removal = removeField(parsed, key);
-    } catch (error) {
-      throw new PmCliError(error instanceof Error ? error.message : String(error), EXIT_CODE.USAGE);
-    }
-    if (removal.removed) {
-      const removedKey = normalizeFieldKey(removal.definition?.key ?? key);
-      const metadataKey = normalizeFieldKey(removal.definition?.metadata_key ?? removal.definition?.front_matter_key ?? removedKey);
-      if (metadataKey.length > 0) {
-        const usingField = await countItemsUsingField(pmRoot, settings, schema, metadataKey);
-        if (usingField > 0) {
-          warnings.push(`items_using_field:${usingField}`);
-        }
-      }
-      await writeFileAtomic(fieldsPath, serializeFieldsFile(removal.file));
-      warnings.push(...await runActiveOnWriteHooks({
-        path: fieldsPath,
-        scope: "project",
-        op: "schema:remove-field"
-      }));
-    }
-  } finally {
-    await releaseLock();
-  }
-  return {
-    action: "remove-field",
-    removed: removal.removed,
-    ...removal.definition ? { field: removal.definition } : {},
-    file: {
-      path: fieldsPath,
-      fields: removal.file.fields.length
-    },
-    warnings: [...new Set(warnings)].sort((left, right) => left.localeCompare(right)),
-    generated_at: nowIso()
-  };
-}
-async function runSchemaListFields(global) {
-  const context = await loadSchemaInspectionContext(global);
-  const fields = resolveRuntimeFieldRegistry(context.schema).definitions.map(toSchemaFieldSummary);
-  return {
-    action: "list-fields",
-    fields,
-    counts: {
-      total: fields.length
-    },
-    file: {
-      path: fieldsPathFor(context.pmRoot, context.schema)
-    },
-    generated_at: nowIso()
-  };
-}
-async function runSchemaShowField(key, global) {
-  const fieldKey = normalizeFieldKey(key);
-  if (fieldKey.length === 0) {
-    throw new PmCliError("Field key must not be empty.", EXIT_CODE.USAGE);
-  }
-  const context = await loadSchemaInspectionContext(global);
-  const match = resolveRuntimeFieldRegistry(context.schema).by_key.get(fieldKey);
-  if (!match) {
-    throw new PmCliError(`Unknown custom field "${key}". Run pm schema list-fields to inspect registered fields, or pm schema add-field "${escapeForDoubleQuotes(key ?? "")}" to register it.`, EXIT_CODE.NOT_FOUND, { code: "unknown_field" });
-  }
-  return {
-    action: "show-field",
-    field: toSchemaFieldSummary(match),
-    file: {
-      path: fieldsPathFor(context.pmRoot, context.schema)
-    },
-    generated_at: nowIso()
-  };
-}
-async function runSchemaApplyPreset(preset, options, global) {
-  const pmRoot = resolvePmRoot(process.cwd(), global.path);
-  await ensureInitialized(pmRoot);
-  let presetName;
-  try {
-    const normalized = normalizeTypePresetName(preset);
-    if (normalized === void 0) {
-      throw new Error(`Type preset name is required. Allowed: ${TYPE_PRESET_NAMES.join(", ")}.`);
-    }
-    presetName = normalized;
-  } catch (error) {
-    throw new PmCliError(error instanceof Error ? error.message : String(error), EXIT_CODE.USAGE);
-  }
-  const settings = await readSettings(pmRoot);
-  const schema = normalizeRuntimeSchemaSettings(settings.schema);
-  const typesPath = typesPathFor(pmRoot, schema);
-  const warnings = [];
-  const author = toAuthor(options.author, settings.author_default);
-  const governance = resolveGovernanceKnobs(settings);
-  const registered = [];
-  const replaced = [];
-  let definitionsCount = 0;
-  const releaseLock = await acquireLock(pmRoot, SCHEMA_TYPES_LOCK_ID, settings.locks.ttl_seconds, author, Boolean(options.force), governance.force_required_for_stale_lock, settings.locks.wait_ms);
-  try {
-    const previousRaw = await readFileIfExists(typesPath);
-    let parsed;
-    try {
-      parsed = parseItemTypesFile(previousRaw);
-    } catch (error) {
-      throw new PmCliError(error instanceof Error ? error.message : String(error), EXIT_CODE.GENERIC_FAILURE);
-    }
-    let nextFile = parsed;
-    for (const normalized of resolveTypePresetDefinitions(presetName)) {
-      const upsert = upsertItemType(nextFile, normalized);
-      nextFile = upsert.file;
-      (upsert.replaced ? replaced : registered).push(upsert.definition.name);
-    }
-    definitionsCount = nextFile.definitions.length;
-    await writeFileAtomic(typesPath, serializeItemTypesFile(nextFile));
-    await ensureTypeFolderScaffold(pmRoot, resolveTypePresetDefinitions(presetName), warnings, "schema:apply-preset-folder");
-    warnings.push(...await runActiveOnWriteHooks({
-      path: typesPath,
-      scope: "project",
-      op: "schema:apply-preset"
-    }));
-  } finally {
-    await releaseLock();
-  }
-  return {
-    action: "apply-preset",
-    preset: presetName,
-    registered,
-    replaced,
-    file: {
-      path: typesPath,
-      definitions: definitionsCount
-    },
-    warnings: [...new Set(warnings)].sort((left, right) => left.localeCompare(right)),
-    generated_at: nowIso()
-  };
-}
-async function runSchemaInferTypes(options, global) {
-  const pmRoot = resolvePmRoot(process.cwd(), global.path);
-  await ensureInitialized(pmRoot);
-  const settings = await readSettings(pmRoot);
-  const schema = normalizeRuntimeSchemaSettings(settings.schema);
-  const typesPath = typesPathFor(pmRoot, schema);
-  let minCount = 10;
-  if (options.minCount !== void 0) {
-    if (!Number.isInteger(options.minCount) || options.minCount < 1) {
-      throw new PmCliError("--min-count must be a positive integer (>= 1).", EXIT_CODE.USAGE);
-    }
-    minCount = options.minCount;
-  }
-  const registry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
-  const items = await listAllFrontMatterLight(pmRoot, settings.item_format, registry.type_to_folder, [], schema);
-  const titles = items.map((item) => typeof item.title === "string" ? item.title : "");
-  const candidates = inferTypesFromTitles(titles, { minCount });
-  const warnings = [];
-  const registered = [];
-  const replaced = [];
-  const skipped = [];
-  let definitionsCount;
-  if (!options.apply) {
-    let parsed;
-    try {
-      parsed = parseItemTypesFile(await readFileIfExists(typesPath));
-    } catch (error) {
-      throw new PmCliError(error instanceof Error ? error.message : String(error), EXIT_CODE.GENERIC_FAILURE);
-    }
-    definitionsCount = parsed.definitions.length;
-    return {
-      action: "infer-types",
-      applied: false,
-      min_count: minCount,
-      candidates,
-      registered,
-      replaced,
-      skipped,
-      file: {
-        path: typesPath,
-        definitions: definitionsCount
-      },
-      warnings,
-      generated_at: nowIso()
-    };
-  }
-  const author = toAuthor(options.author, settings.author_default);
-  const governance = resolveGovernanceKnobs(settings);
-  const releaseLock = await acquireLock(pmRoot, SCHEMA_TYPES_LOCK_ID, settings.locks.ttl_seconds, author, Boolean(options.force), governance.force_required_for_stale_lock, settings.locks.wait_ms);
-  try {
-    const previousRaw = await readFileIfExists(typesPath);
-    let parsed;
-    try {
-      parsed = parseItemTypesFile(previousRaw);
-    } catch (error) {
-      throw new PmCliError(error instanceof Error ? error.message : String(error), EXIT_CODE.GENERIC_FAILURE);
-    }
-    let nextFile = parsed;
-    for (const candidate of candidates) {
-      if (candidate.shadows_builtin) {
-        skipped.push({ name: candidate.name, reason: "shadows_builtin" });
-        continue;
-      }
-      let normalized;
-      try {
-        normalized = normalizeAddTypeInput({ name: candidate.name });
-      } catch {
-        skipped.push({ name: candidate.name, reason: "invalid_type_token" });
-        continue;
-      }
-      const upsert = upsertItemType(nextFile, normalized);
-      nextFile = upsert.file;
-      (upsert.replaced ? replaced : registered).push(upsert.definition.name);
-    }
-    definitionsCount = nextFile.definitions.length;
-    await writeFileAtomic(typesPath, serializeItemTypesFile(nextFile));
-    await ensureTypeFolderScaffold(pmRoot, nextFile.definitions.filter((definition) => registered.includes(definition.name) || replaced.includes(definition.name)), warnings, "schema:infer-types-folder");
-    warnings.push(...await runActiveOnWriteHooks({
-      path: typesPath,
-      scope: "project",
-      op: "schema:infer-types"
-    }));
-  } finally {
-    await releaseLock();
-  }
-  return {
-    action: "infer-types",
-    applied: true,
-    min_count: minCount,
-    candidates,
-    registered,
-    replaced,
-    skipped,
-    file: {
-      path: typesPath,
-      definitions: definitionsCount
-    },
-    warnings: [...new Set(warnings)].sort((left, right) => left.localeCompare(right)),
-    generated_at: nowIso()
-  };
-}
-function formatSchemaAddTypeHuman(result) {
-  const verb = result.replaced ? "Updated" : "Registered";
-  const aliasSuffix = result.type.aliases && result.type.aliases.length > 0 ? ` (aliases: ${result.type.aliases.join(", ")})` : "";
-  return `${verb} custom item type "${result.type.name}"${aliasSuffix} in ${result.file.path}. Run: pm create "${escapeForDoubleQuotes(result.type.name)}" "<title>"`;
-}
-function formatSchemaRemoveTypeHuman(result) {
-  if (!result.removed) {
-    return `No custom item type matched; nothing removed from ${result.file.path}.`;
-  }
-  const name = result.type?.name ?? "(unknown)";
-  return `Removed custom item type "${name}" from ${result.file.path}.`;
-}
-function formatSchemaAddStatusHuman(result) {
-  const verb = result.replaced ? "Updated" : "Registered";
-  const roleSuffix = result.status.roles && result.status.roles.length > 0 ? ` (roles: ${result.status.roles.join(", ")})` : "";
-  const aliasSuffix = result.status.aliases && result.status.aliases.length > 0 ? ` (aliases: ${result.status.aliases.join(", ")})` : "";
-  return `${verb} status "${result.status.id}"${roleSuffix}${aliasSuffix} in ${result.file.path}.`;
-}
-function formatSchemaRemoveStatusHuman(result) {
-  if (!result.removed) {
-    return `No custom status matched; nothing removed from ${result.file.path}.`;
-  }
-  const id = result.status?.id ?? "(unknown)";
-  return `Removed custom status "${id}" from ${result.file.path}.`;
-}
-function formatSchemaListHuman(result) {
-  const lines = [
-    `Schema types: ${result.counts.total} total (${result.counts.builtin} builtin, ${result.counts.custom} custom, ${result.counts.extension} extension)`
-  ];
-  for (const [label, entries] of [
-    ["builtin", result.builtin],
-    ["custom", result.custom],
-    ["extension", result.extension]
-  ]) {
-    if (entries.length === 0) {
-      continue;
-    }
-    lines.push(`${label}: ${entries.map((entry) => entry.name).join(", ")}`);
-  }
-  lines.push(`statuses: ${result.statuses.counts.total} total (${result.statuses.counts.builtin} builtin, ${result.statuses.counts.custom} custom)`);
-  for (const [label, entries] of [
-    ["builtin statuses", result.statuses.builtin],
-    ["custom statuses", result.statuses.custom]
-  ]) {
-    if (entries.length === 0) {
-      continue;
-    }
-    lines.push(`${label}: ${entries.map((entry) => entry.id).join(", ")}`);
-  }
-  lines.push(`custom fields: ${result.fields.counts.total} total`);
-  if (result.fields.custom.length > 0) {
-    lines.push(`fields: ${result.fields.custom.map((field) => `${field.key} (${field.type}, ${field.cli_flag})`).join(", ")}`);
-  }
-  lines.push(`Inspect one: pm schema show <Type>`);
-  lines.push(`Inspect one status: pm schema show-status <status>`);
-  lines.push(`Inspect one field: pm schema show-field <key>`);
-  return lines.join("\n");
-}
-function formatSchemaShowHuman(result) {
-  const parts = [
-    `type: ${result.type.name}`,
-    `source: ${result.type.source}`,
-    `folder: ${result.type.folder}`
-  ];
-  if (result.type.default_status) {
-    parts.push(`default_status: ${result.type.default_status}`);
-  }
-  if (result.type.aliases.length > 0) {
-    parts.push(`aliases: ${result.type.aliases.join(", ")}`);
-  }
-  if (result.type.description) {
-    parts.push(`description: ${result.type.description}`);
-  }
-  if (result.type.options.length > 0) {
-    parts.push(`options: ${result.type.options.map((option) => option.key).join(", ")}`);
-  }
-  return parts.join("\n");
-}
-function formatSchemaShowStatusHuman(result) {
-  const parts = [
-    `status: ${result.status.id}`,
-    `source: ${result.status.source}`
-  ];
-  if (result.status.roles.length > 0) {
-    parts.push(`roles: ${result.status.roles.join(", ")}`);
-  }
-  if (result.status.aliases.length > 0) {
-    parts.push(`aliases: ${result.status.aliases.join(", ")}`);
-  }
-  if (result.status.description) {
-    parts.push(`description: ${result.status.description}`);
-  }
-  if (typeof result.status.order === "number") {
-    parts.push(`order: ${result.status.order}`);
-  }
-  return parts.join("\n");
-}
-function formatFieldSummaryLine(field) {
-  const flags = [];
-  if (field.required) {
-    flags.push("required");
-  }
-  if (field.required_on_create) {
-    flags.push("required_on_create");
-  }
-  if (!field.allow_unset) {
-    flags.push("no_unset");
-  }
-  const flagSuffix = flags.length > 0 ? ` [${flags.join(", ")}]` : "";
-  return `${field.key} (${field.type}) ${field.cli_flag} commands=${field.commands.join("/")}${flagSuffix}`;
-}
-function formatSchemaAddFieldHuman(result) {
-  const verb = result.replaced ? "Updated" : "Registered";
-  return `${verb} custom field "${result.field.key}" in ${result.file.path}. Use it: pm create "<title>" --${(result.field.cli_flag ?? result.field.key).replaceAll("_", "-")} <value>`;
-}
-function formatSchemaRemoveFieldHuman(result) {
-  if (!result.removed) {
-    return `No custom field matched; nothing removed from ${result.file.path}.`;
-  }
-  const key = result.field?.key ?? "(unknown)";
-  return `Removed custom field "${key}" from ${result.file.path}.`;
-}
-function formatSchemaListFieldsHuman(result) {
-  const lines = [`Custom fields: ${result.counts.total} total`];
-  for (const field of result.fields) {
-    lines.push(`  ${formatFieldSummaryLine(field)}`);
-  }
-  lines.push(`Inspect one: pm schema show-field <key>`);
-  return lines.join("\n");
-}
-function formatSchemaShowFieldHuman(result) {
-  const field = result.field;
-  const parts = [
-    `field: ${field.key}`,
-    `type: ${field.type}`,
-    `cli_flag: ${field.cli_flag}`,
-    `commands: ${field.commands.join(", ")}`
-  ];
-  if (field.cli_aliases.length > 0) {
-    parts.push(`cli_aliases: ${field.cli_aliases.join(", ")}`);
-  }
-  if (field.description) {
-    parts.push(`description: ${field.description}`);
-  }
-  if (field.required) {
-    parts.push(`required: true`);
-  }
-  if (field.required_on_create) {
-    parts.push(`required_on_create: true`);
-  }
-  if (!field.allow_unset) {
-    parts.push(`allow_unset: false`);
-  }
-  if (field.required_types.length > 0) {
-    parts.push(`required_types: ${field.required_types.join(", ")}`);
-  }
-  return parts.join("\n");
-}
-function formatSchemaApplyPresetHuman(result) {
-  const registered = result.registered.length > 0 ? `registered: ${result.registered.join(", ")}` : "";
-  const replaced = result.replaced.length > 0 ? `updated: ${result.replaced.join(", ")}` : "";
-  const detail = [registered, replaced].filter((part) => part.length > 0).join("; ");
-  return `Applied "${result.preset}" type preset to ${result.file.path}${detail.length > 0 ? ` (${detail})` : ""}.`;
-}
-function formatSchemaInferTypesHuman(result) {
-  if (result.candidates.length === 0) {
-    return `No title-prefix conventions found with at least ${result.min_count} items. Lower the threshold with --min-count <n>.`;
-  }
-  const lines = result.applied ? [`Inferred and registered custom types from title prefixes (min-count ${result.min_count}):`] : [`Inferred custom type candidates from title prefixes (min-count ${result.min_count}, dry-run):`];
-  for (const candidate of result.candidates) {
-    const note = candidate.shadows_builtin ? " [shadows built-in, skipped]" : "";
-    lines.push(`  ${candidate.name} <- "${candidate.prefix}" (${candidate.count} items)${note}`);
-  }
-  if (!result.applied) {
-    lines.push(`Re-run with --apply to register the non-shadowing candidates.`);
-  } else {
-    if (result.registered.length > 0) {
-      lines.push(`registered: ${result.registered.join(", ")}`);
-    }
-    if (result.replaced.length > 0) {
-      lines.push(`updated: ${result.replaced.join(", ")}`);
-    }
-  }
-  return lines.join("\n");
-}
-var _testOnlySchemaCommand = {
-  toAuthor,
-  workflowSlotsReferencing
-};
-
-export {
-  SCHEMA_SUBCOMMANDS,
-  runSchemaAddType,
-  runSchemaRemoveType,
-  ensureTypeFolderScaffold,
-  runSchemaAddStatus,
-  runSchemaRemoveStatus,
-  runSchemaList,
-  runSchemaShow,
-  runSchemaShowStatus,
-  runSchemaAddField,
-  runSchemaRemoveField,
-  runSchemaListFields,
-  runSchemaShowField,
-  runSchemaApplyPreset,
-  runSchemaInferTypes,
-  formatSchemaAddTypeHuman,
-  formatSchemaRemoveTypeHuman,
-  formatSchemaAddStatusHuman,
-  formatSchemaRemoveStatusHuman,
-  formatSchemaListHuman,
-  formatSchemaShowHuman,
-  formatSchemaShowStatusHuman,
-  formatSchemaAddFieldHuman,
-  formatSchemaRemoveFieldHuman,
-  formatSchemaListFieldsHuman,
-  formatSchemaShowFieldHuman,
-  formatSchemaApplyPresetHuman,
-  formatSchemaInferTypesHuman,
-  _testOnlySchemaCommand
-};
-//# sourceMappingURL=chunk-PJ3A56YF.js.map
-
-//# debugId=d5198112-9083-5c72-8583-3c24e460da48