@unbrained/pm-cli 2026.6.13 → 2026.6.17

package/dist/cli-bundle/chunks/{schema-ZZ7ZDM2X.js → schema-7U7JUYGK.js}

@@ -1,32 +1,41 @@
 
-!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]="43fa077e-1a25-5f5b-ba9c-600eef053de0")}catch(e){}}();
+!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]="f1d1bb61-520e-5d3d-8813-8dc1c6a0c38f")}catch(e){}}();
+import {
+  TYPE_PRESET_NAMES,
+  normalizeTypePresetName,
+  resolveTypePresetDefinitions
+} from "./chunk-4RTLBTYS.js";
 import {
   assertAliasesAvailable,
+  assertTypeFolderAvailable,
   buildInvalidTypeHint,
   escapeForDoubleQuotes,
+  matchBuiltinTypeName,
   normalizeAddTypeInput,
   parseItemTypesFile,
   removeItemType,
   serializeItemTypesFile,
   upsertItemType
-} from "./chunk-TSXWFN3L.js";
+} from "./chunk-6VFUEGOA.js";
 import {
   acquireLock,
   listAllFrontMatterLight
-} from "./chunk-L6YQONLM.js";
-import "./chunk-6ZFTM65G.js";
-import "./chunk-QQG4HEX7.js";
+} from "./chunk-FPDK5BZQ.js";
+import "./chunk-F5MSD5HE.js";
+import "./chunk-IROHIK2T.js";
 import {
   resolveItemTypeRegistry
-} from "./chunk-32XSW44C.js";
+} from "./chunk-V2GYOMEX.js";
 import {
   nowIso
-} from "./chunk-IZHCCG4S.js";
+} from "./chunk-VXRFAE7W.js";
 import {
   DEFAULT_RUNTIME_SCHEMA_FILE_PATHS,
   DEFAULT_RUNTIME_STATUS_DEFINITIONS,
   EXIT_CODE,
   PmCliError,
+  RUNTIME_FIELD_COMMAND_VALUES,
+  RUNTIME_FIELD_TYPE_VALUES,
   RUNTIME_STATUS_ROLE_VALUES,
   filePathForSchemaSection,
   getActiveExtensionRegistrations,
@@ -37,10 +46,11 @@ import {
   readSettings,
   resolveGovernanceKnobs,
   resolvePmRoot,
+  resolveRuntimeFieldRegistry,
   resolveRuntimeStatusRegistry,
   runActiveOnWriteHooks,
   writeFileAtomic
-} from "./chunk-S2CDTRJ6.js";
+} from "./chunk-SJCMTOEU.js";
 
 // dist/core/schema/status-defs-file.js
 var RUNTIME_STATUS_ROLE_SET = new Set(RUNTIME_STATUS_ROLE_VALUES);
@@ -217,18 +227,320 @@ function assertStatusTokensAvailable(input, resolvedAliasToId) {
   }
 }
 
+// dist/core/schema/fields-file.js
+var RUNTIME_FIELD_TYPE_SET = new Set(RUNTIME_FIELD_TYPE_VALUES);
+var RUNTIME_FIELD_COMMAND_SET = new Set(RUNTIME_FIELD_COMMAND_VALUES);
+var BUILTIN_FIELD_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "title",
+  "type",
+  "status",
+  "priority",
+  "tags",
+  "assignee",
+  "parent",
+  "description",
+  "body",
+  "created_at",
+  "updated_at",
+  "closed_at",
+  "author",
+  "deadline",
+  "estimate",
+  "sprint",
+  "release",
+  "risk",
+  "confidence",
+  "reviewer",
+  "resolution",
+  "expected",
+  "actual"
+]);
+var DEFAULT_FIELD_COMMANDS = ["create", "update"];
+function normalizeFieldKey(value) {
+  return typeof value === "string" ? value.trim().toLowerCase().replaceAll(/[\s-]+/g, "_") : "";
+}
+function normalizeCliToken(value) {
+  if (typeof value !== "string") {
+    return "";
+  }
+  const collapsed = value.trim().toLowerCase().replaceAll(/[\s_]+/g, "-");
+  return collapsed.startsWith("--") ? collapsed.slice(2) : collapsed;
+}
+function keyToDefaultCliFlag(key) {
+  return key.replaceAll("_", "-");
+}
+function dedupeCliTokens(values, exclude) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    const token = normalizeCliToken(value);
+    if (token.length > 0 && token !== exclude) {
+      seen.add(token);
+    }
+  }
+  return [...seen].sort((left, right) => left.localeCompare(right));
+}
+function dedupeStringList(values) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of values ?? []) {
+    const trimmed = value.trim();
+    if (trimmed.length > 0) {
+      seen.add(trimmed);
+    }
+  }
+  return [...seen].sort((left, right) => left.localeCompare(right));
+}
+function normalizeAddFieldInput(raw) {
+  const key = normalizeFieldKey(raw.key);
+  if (key.length === 0) {
+    throw new Error("Field key must not be empty.");
+  }
+  if (BUILTIN_FIELD_KEYS.has(key)) {
+    throw new Error(`Cannot define custom field "${key}": it shadows a built-in field. Built-in fields are reserved.`);
+  }
+  const typeCandidate = typeof raw.type === "string" && raw.type.trim().length > 0 ? raw.type.trim().toLowerCase() : "string";
+  if (!RUNTIME_FIELD_TYPE_SET.has(typeCandidate)) {
+    throw new Error(`Invalid field type "${raw.type}". Allowed: ${RUNTIME_FIELD_TYPE_VALUES.join(", ")}.`);
+  }
+  const type = typeCandidate;
+  let commands;
+  if (raw.commands === void 0) {
+    commands = [...DEFAULT_FIELD_COMMANDS];
+  } else {
+    const seen = /* @__PURE__ */ new Set();
+    const normalized = [];
+    for (const rawCommand of raw.commands) {
+      const command = rawCommand.trim().toLowerCase();
+      if (command.length === 0) {
+        continue;
+      }
+      if (!RUNTIME_FIELD_COMMAND_SET.has(command)) {
+        throw new Error(`Invalid field command "${rawCommand}". Allowed: ${RUNTIME_FIELD_COMMAND_VALUES.join(", ")}.`);
+      }
+      if (!seen.has(command)) {
+        seen.add(command);
+        normalized.push(command);
+      }
+    }
+    commands = normalized.length > 0 ? normalized : [...DEFAULT_FIELD_COMMANDS];
+  }
+  const cliFlagToken = normalizeCliToken(raw.cliFlag);
+  const cliFlag = cliFlagToken.length > 0 && cliFlagToken !== keyToDefaultCliFlag(key) ? cliFlagToken : void 0;
+  const effectiveFlag = cliFlag ?? keyToDefaultCliFlag(key);
+  const cliAliases = dedupeCliTokens(raw.aliases ?? [], effectiveFlag);
+  const description = raw.description?.trim();
+  return {
+    key,
+    type,
+    commands,
+    description: description && description.length > 0 ? description : void 0,
+    cliFlag,
+    cliAliases,
+    required: raw.required === true,
+    requiredOnCreate: raw.requiredOnCreate === true,
+    // allow_unset defaults to true (omitted) and is only persisted when an
+    // operator explicitly disables it with --no-allow-unset (allowUnset === false).
+    allowUnset: raw.allowUnset !== false,
+    requiredTypes: dedupeStringList(raw.requiredTypes)
+  };
+}
+function selectFieldsArray(parsed) {
+  if (Array.isArray(parsed)) {
+    return parsed;
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return void 0;
+  }
+  const record = parsed;
+  if (Array.isArray(record.fields)) {
+    return record.fields;
+  }
+  if (Array.isArray(record.definitions)) {
+    return record.definitions;
+  }
+  return void 0;
+}
+function extractFieldDefinitions(parsed) {
+  const candidate = selectFieldsArray(parsed);
+  if (!candidate) {
+    return [];
+  }
+  const definitions = [];
+  for (const entry of candidate) {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+      continue;
+    }
+    const record = entry;
+    if (typeof record.key !== "string" || record.key.trim().length === 0) {
+      continue;
+    }
+    definitions.push(record);
+  }
+  return definitions;
+}
+function parseFieldsFile(raw) {
+  if (raw === null || raw === void 0 || raw.trim().length === 0) {
+    return { fields: [] };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error("schema/fields.json contains invalid JSON.");
+  }
+  return { fields: extractFieldDefinitions(parsed) };
+}
+function serializeFieldsFile(file) {
+  return `${JSON.stringify({ fields: file.fields }, null, 2)}
+`;
+}
+function upsertField(file, input) {
+  const existing = file.fields.find((definition) => normalizeFieldKey(definition.key) === input.key);
+  const replaced = existing !== void 0;
+  const fields = file.fields.filter((definition) => normalizeFieldKey(definition.key) !== input.key);
+  const next = {
+    ...existing ?? {},
+    key: input.key,
+    type: input.type,
+    commands: [...input.commands]
+  };
+  applyOptionalString(next, "description", input.description);
+  applyOptionalString(next, "cli_flag", input.cliFlag);
+  if (input.cliAliases.length > 0) {
+    next.cli_aliases = [...input.cliAliases];
+  } else {
+    delete next.cli_aliases;
+  }
+  applyBooleanFlag(next, "required", input.required);
+  applyBooleanFlag(next, "required_on_create", input.requiredOnCreate);
+  if (input.allowUnset === false) {
+    next.allow_unset = false;
+  } else {
+    delete next.allow_unset;
+  }
+  if (input.requiredTypes.length > 0) {
+    next.required_types = [...input.requiredTypes];
+  } else {
+    delete next.required_types;
+  }
+  fields.push(next);
+  fields.sort((left, right) => normalizeFieldKey(left.key).localeCompare(normalizeFieldKey(right.key)));
+  return {
+    file: { fields },
+    definition: next,
+    replaced
+  };
+}
+function removeField(file, key) {
+  const normalizedKey = normalizeFieldKey(key);
+  if (normalizedKey.length === 0) {
+    throw new Error("Field key must not be empty.");
+  }
+  const removed = [];
+  const fields = file.fields.filter((definition) => {
+    if (normalizeFieldKey(definition.key) === normalizedKey) {
+      removed.push(definition);
+      return false;
+    }
+    return true;
+  });
+  if (removed.length === 0) {
+    return { file: { fields }, removed: false };
+  }
+  return { file: { fields }, removed: true, definition: removed[0] };
+}
+function applyOptionalString(definition, key, value) {
+  const record = definition;
+  if (value !== void 0 && value.length > 0) {
+    record[key] = value;
+  } else {
+    delete record[key];
+  }
+}
+function applyBooleanFlag(definition, key, value) {
+  const record = definition;
+  if (value) {
+    record[key] = true;
+  } else {
+    delete record[key];
+  }
+}
+
+// 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();
@@ -269,10 +581,22 @@ async function runSchemaAddType(name, options, global) {
     }
     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));
     warnings.push(...await runActiveOnWriteHooks({
       path: typesPath,
@@ -385,6 +709,26 @@ async function runSchemaRemoveType(name, options, global) {
 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);
+}
+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]
+  };
+}
 async function runSchemaAddStatus(id, options, global) {
   const pmRoot = resolvePmRoot(process.cwd(), global.path);
   await ensureInitialized(pmRoot);
@@ -620,6 +964,7 @@ async function loadSchemaInspectionContext(global) {
   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,
@@ -645,6 +990,7 @@ async function runSchemaList(global) {
     }
   }
   const statusSummaries = buildSchemaStatusSummaries(context.schema);
+  const fieldSummaries = resolveRuntimeFieldRegistry(context.schema).definitions.map(toSchemaFieldSummary);
   return {
     action: "list",
     builtin,
@@ -665,6 +1011,12 @@ async function runSchemaList(global) {
         total: statusSummaries.builtin.length + statusSummaries.custom.length
       }
     },
+    fields: {
+      custom: fieldSummaries,
+      counts: {
+        total: fieldSummaries.length
+      }
+    },
     file: {
       path: context.typesPath
     },
@@ -711,6 +1063,331 @@ async function runSchemaShowStatus(id, global) {
     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);
+  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);
+  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);
+  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));
+    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);
+  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));
+    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(", ")})` : "";
@@ -760,8 +1437,13 @@ function formatSchemaListHuman(result) {
     }
     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) {
@@ -803,24 +1485,129 @@ function formatSchemaShowStatusHuman(result) {
   }
   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,
+  _testOnlySchemaCommand,
   buildInvalidTypeHint,
+  formatSchemaAddFieldHuman,
   formatSchemaAddStatusHuman,
   formatSchemaAddTypeHuman,
+  formatSchemaApplyPresetHuman,
+  formatSchemaInferTypesHuman,
+  formatSchemaListFieldsHuman,
   formatSchemaListHuman,
+  formatSchemaRemoveFieldHuman,
   formatSchemaRemoveStatusHuman,
   formatSchemaRemoveTypeHuman,
+  formatSchemaShowFieldHuman,
   formatSchemaShowHuman,
   formatSchemaShowStatusHuman,
+  runSchemaAddField,
   runSchemaAddStatus,
   runSchemaAddType,
+  runSchemaApplyPreset,
+  runSchemaInferTypes,
   runSchemaList,
+  runSchemaListFields,
+  runSchemaRemoveField,
   runSchemaRemoveStatus,
   runSchemaRemoveType,
   runSchemaShow,
+  runSchemaShowField,
   runSchemaShowStatus
 };
-//# sourceMappingURL=schema-ZZ7ZDM2X.js.map
+//# sourceMappingURL=schema-7U7JUYGK.js.map
 
-//# debugId=43fa077e-1a25-5f5b-ba9c-600eef053de0
+//# debugId=f1d1bb61-520e-5d3d-8813-8dc1c6a0c38f