@unbrained/pm-cli 2026.7.5 → 2026.7.6

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

@@ -0,0 +1,1249 @@
+import {
+  acquireLock,
+  listAllFrontMatterLight
+} from "./chunk-5VAA4YHR.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-FT3QTERD.js";
+import {
+  nowIso
+} from "./chunk-FLZSGSQR.js";
+import {
+  PmCliError,
+  getActiveExtensionRegistrations,
+  readSettings,
+  resolveGovernanceKnobs,
+  runActiveOnWriteHooks
+} from "./chunk-SHQY2IDC.js";
+import {
+  assertAliasesAvailable,
+  assertTypeFolderAvailable,
+  escapeForDoubleQuotes,
+  matchBuiltinTypeName,
+  normalizeAddTypeInput,
+  parseItemTypesFile,
+  removeItemType,
+  serializeItemTypesFile,
+  upsertItemType
+} from "./chunk-NGXQ3PFT.js";
+import {
+  DEFAULT_RUNTIME_SCHEMA_FILE_PATHS,
+  EXIT_CODE,
+  filePathForSchemaSection,
+  getSettingsPath,
+  normalizeRuntimeSchemaSettings,
+  pathExists,
+  readFileIfExists,
+  resolveItemTypeRegistry,
+  resolvePmRoot,
+  resolveRuntimeFieldRegistry,
+  resolveRuntimeStatusRegistry,
+  toDefaultFolder,
+  writeFileAtomic
+} from "./chunk-LK6XLOGP.js";
+
+// dist/cli/commands/schema.js
+import path from "node:path";
+import { mkdir } from "node:fs/promises";
+
+// dist/core/schema/type-inference.js
+!(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] = "af432a0c-7f6b-5478-9815-c2f18eef6a88");
+  } catch (e2) {
+  }
+})();
+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
+!(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] = "de6e7ebd-3f26-5da7-82d2-dd839bef4fb2");
+  } catch (e2) {
+  }
+})();
+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, global2) {
+  const pmRoot = resolvePmRoot(process.cwd(), global2.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, global2) {
+  const pmRoot = resolvePmRoot(process.cwd(), global2.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, global2) {
+  const pmRoot = resolvePmRoot(process.cwd(), global2.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, global2) {
+  const pmRoot = resolvePmRoot(process.cwd(), global2.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(global2) {
+  const pmRoot = resolvePmRoot(process.cwd(), global2.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(global2) {
+  const context = await loadSchemaInspectionContext(global2);
+  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, global2) {
+  const typeName = (name ?? "").trim();
+  if (typeName.length === 0) {
+    throw new PmCliError("Type name must not be empty.", EXIT_CODE.USAGE);
+  }
+  const context = await loadSchemaInspectionContext(global2);
+  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, global2) {
+  const statusToken = normalizeStatusToken(id);
+  if (statusToken.length === 0) {
+    throw new PmCliError("Status id must not be empty.", EXIT_CODE.USAGE);
+  }
+  const context = await loadSchemaInspectionContext(global2);
+  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, global2) {
+  const pmRoot = resolvePmRoot(process.cwd(), global2.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, global2) {
+  const pmRoot = resolvePmRoot(process.cwd(), global2.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(global2) {
+  const context = await loadSchemaInspectionContext(global2);
+  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, global2) {
+  const fieldKey = normalizeFieldKey(key);
+  if (fieldKey.length === 0) {
+    throw new PmCliError("Field key must not be empty.", EXIT_CODE.USAGE);
+  }
+  const context = await loadSchemaInspectionContext(global2);
+  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, global2) {
+  const pmRoot = resolvePmRoot(process.cwd(), global2.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, global2) {
+  const pmRoot = resolvePmRoot(process.cwd(), global2.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-W572BIEB.js.map