@unbrained/pm-cli 2026.5.31 → 2026.6.5

package/dist/cli-bundle/chunks/schema-V6BX65Q2.js

@@ -0,0 +1,780 @@
+import {
+  assertAliasesAvailable,
+  buildInvalidTypeHint,
+  escapeForDoubleQuotes,
+  normalizeAddTypeInput,
+  parseItemTypesFile,
+  removeItemType,
+  serializeItemTypesFile,
+  upsertItemType
+} from "./chunk-KK6YPGH3.js";
+import {
+  acquireLock,
+  listAllFrontMatterLight
+} from "./chunk-XG7RJYHV.js";
+import "./chunk-KA24HME7.js";
+import "./chunk-HPH6X4ZZ.js";
+import {
+  resolveItemTypeRegistry
+} from "./chunk-4PJQSECJ.js";
+import {
+  nowIso
+} from "./chunk-RANZIID5.js";
+import {
+  DEFAULT_RUNTIME_SCHEMA_FILE_PATHS,
+  DEFAULT_RUNTIME_STATUS_DEFINITIONS,
+  EXIT_CODE,
+  PmCliError,
+  RUNTIME_STATUS_ROLE_VALUES,
+  filePathForSchemaSection,
+  getActiveExtensionRegistrations,
+  getSettingsPath,
+  normalizeRuntimeSchemaSettings,
+  pathExists,
+  readFileIfExists,
+  readSettings,
+  resolveGovernanceKnobs,
+  resolvePmRoot,
+  resolveRuntimeStatusRegistry,
+  runActiveOnWriteHooks,
+  writeFileAtomic
+} from "./chunk-SRVKTWPR.js";
+
+// dist/core/schema/status-defs-file.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] = "d738db07-1d64-5ab0-9ebd-f9c9f6de5706");
+  } catch (e2) {
+  }
+})();
+var RUNTIME_STATUS_ROLE_SET = new Set(RUNTIME_STATUS_ROLE_VALUES);
+var BUILTIN_STATUS_IDS = new Set(DEFAULT_RUNTIME_STATUS_DEFINITIONS.map((definition) => normalizeStatusToken(definition.id)).filter((id) => id.length > 0));
+function normalizeStatusToken(value) {
+  return typeof value === "string" ? value.trim().toLowerCase().replaceAll(/[\s-]+/g, "_") : "";
+}
+function dedupeTokens(values) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    const token = normalizeStatusToken(value);
+    if (token.length > 0) {
+      seen.add(token);
+    }
+  }
+  return [...seen].sort((left, right) => left.localeCompare(right));
+}
+function normalizeAddStatusInput(raw) {
+  const id = normalizeStatusToken(raw.id);
+  if (id.length === 0) {
+    throw new Error("Status id must not be empty.");
+  }
+  if (BUILTIN_STATUS_IDS.has(id)) {
+    throw new Error(`Cannot add-status the built-in status "${id}". Built-in statuses are reserved: ${[...BUILTIN_STATUS_IDS].join(", ")}.`);
+  }
+  let roles;
+  if (raw.roles !== void 0) {
+    roles = [];
+    const seenRoles = /* @__PURE__ */ new Set();
+    for (const rawRole of raw.roles) {
+      const role = typeof rawRole === "string" ? rawRole.trim().toLowerCase() : "";
+      if (role.length === 0) {
+        continue;
+      }
+      if (!RUNTIME_STATUS_ROLE_SET.has(role)) {
+        throw new Error(`Invalid status role "${rawRole}". Allowed roles: ${RUNTIME_STATUS_ROLE_VALUES.join(", ")}.`);
+      }
+      if (!seenRoles.has(role)) {
+        seenRoles.add(role);
+        roles.push(role);
+      }
+    }
+  }
+  const aliases = raw.aliases === void 0 ? void 0 : dedupeTokens(raw.aliases).filter((alias) => alias !== id);
+  const description = raw.description?.trim();
+  const order = typeof raw.order === "number" && Number.isFinite(raw.order) ? Math.trunc(raw.order) : void 0;
+  return {
+    id,
+    roles,
+    aliases,
+    description: description && description.length > 0 ? description : void 0,
+    order
+  };
+}
+function selectStatusesArray(parsed) {
+  if (Array.isArray(parsed)) {
+    return parsed;
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return void 0;
+  }
+  const record = parsed;
+  if (Array.isArray(record.statuses)) {
+    return record.statuses;
+  }
+  if (Array.isArray(record.definitions)) {
+    return record.definitions;
+  }
+  return void 0;
+}
+function extractStatusDefinitions(parsed) {
+  const candidate = selectStatusesArray(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.id !== "string" || record.id.trim().length === 0) {
+      continue;
+    }
+    definitions.push(record);
+  }
+  return definitions;
+}
+function parseStatusDefsFile(raw) {
+  if (raw === null || raw === void 0 || raw.trim().length === 0) {
+    return { statuses: [] };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error("schema/statuses.json contains invalid JSON.");
+  }
+  return { statuses: extractStatusDefinitions(parsed) };
+}
+function serializeStatusDefsFile(file) {
+  return `${JSON.stringify({ statuses: file.statuses }, null, 2)}
+`;
+}
+function upsertStatusDef(file, input, baseDefinition) {
+  const statuses = file.statuses.slice();
+  const existingIndex = statuses.findIndex((definition) => normalizeStatusToken(definition.id) === input.id);
+  const existing = existingIndex >= 0 ? statuses[existingIndex] : baseDefinition;
+  const next = {
+    ...existing ?? {},
+    id: input.id
+  };
+  if (input.roles !== void 0) {
+    if (input.roles.length > 0) {
+      next.roles = [...input.roles];
+    } else if (next.roles !== void 0) {
+      delete next.roles;
+    }
+  }
+  if (input.aliases !== void 0) {
+    if (input.aliases.length > 0) {
+      next.aliases = [...input.aliases];
+    } else if (next.aliases !== void 0) {
+      delete next.aliases;
+    }
+  }
+  if (input.description !== void 0) {
+    next.description = input.description;
+  }
+  if (input.order !== void 0) {
+    next.order = input.order;
+  }
+  if (existingIndex >= 0) {
+    statuses[existingIndex] = next;
+  } else {
+    statuses.push(next);
+  }
+  return {
+    file: { statuses },
+    definition: next,
+    // "replaced" reflects whether the status already existed effectively (in the
+    // file OR in resolved settings), so the CLI reports "Updated" vs "Registered"
+    // correctly even when the prior definition lived only in settings.
+    replaced: existing !== void 0
+  };
+}
+function removeStatusDef(file, id) {
+  const normalizedId = normalizeStatusToken(id);
+  if (normalizedId.length === 0) {
+    throw new Error("Status id must not be empty.");
+  }
+  if (BUILTIN_STATUS_IDS.has(normalizedId)) {
+    throw new Error(`Cannot remove built-in status "${normalizedId}". Built-in statuses are reserved: ${[...BUILTIN_STATUS_IDS].join(", ")}.`);
+  }
+  const statuses = file.statuses.slice();
+  const existingIndex = statuses.findIndex((definition2) => normalizeStatusToken(definition2.id) === normalizedId);
+  if (existingIndex < 0) {
+    return { file: { statuses }, removed: false };
+  }
+  const [definition] = statuses.splice(existingIndex, 1);
+  return { file: { statuses }, removed: true, definition };
+}
+function assertStatusTokensAvailable(input, resolvedAliasToId) {
+  const candidates = [input.id, ...input.aliases ?? []];
+  for (const candidate of candidates) {
+    const token = normalizeStatusToken(candidate);
+    if (token.length === 0) {
+      continue;
+    }
+    const owner = resolvedAliasToId.get(token);
+    if (owner !== void 0 && owner !== input.id) {
+      throw new Error(`Status token "${token}" already belongs to status "${owner}". Choose a different id/alias to avoid shadowing it.`);
+    }
+  }
+}
+
+// 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] = "3ffacab6-b0b2-5c73-a13b-cd559b219adf");
+  } catch (e2) {
+  }
+})();
+var SCHEMA_SUBCOMMANDS = ["add-type", "remove-type", "add-status", "remove-status", "list", "show"];
+var SCHEMA_TYPES_LOCK_ID = "schema-types";
+var SCHEMA_STATUSES_LOCK_ID = "schema-statuses";
+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);
+  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);
+    } catch (error) {
+      throw new PmCliError(error instanceof Error ? error.message : String(error), EXIT_CODE.USAGE);
+    }
+    upsert = upsertItemType(parsed, normalized);
+    await writeFileAtomic(typesPath, serializeItemTypesFile(upsert.file));
+    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);
+  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);
+}
+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 resolvedExisting = statusRegistry.by_id.get(normalized.id);
+  const baseDefinition = resolvedExisting ? {
+    id: resolvedExisting.id,
+    ...Array.isArray(resolvedExisting.roles) && resolvedExisting.roles.length > 0 ? { roles: [...resolvedExisting.roles] } : {},
+    ...Array.isArray(resolvedExisting.aliases) && resolvedExisting.aliases.length > 0 ? { aliases: [...resolvedExisting.aliases] } : {},
+    ...resolvedExisting.description ? { description: resolvedExisting.description } : {},
+    ...typeof resolvedExisting.order === "number" ? { order: resolvedExisting.order } : {}
+  } : void 0;
+  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);
+  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 = /* @__PURE__ */ new Map();
+    for (const definition of parsed.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);
+        }
+      }
+    }
+    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);
+  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 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 source = BUILTIN_STATUS_IDS.has(definition.id) ? "builtin" : "custom";
+    const summary = {
+      id: definition.id,
+      source,
+      roles: Array.isArray(definition.roles) ? [...definition.roles] : [],
+      aliases: Array.isArray(definition.aliases) ? [...definition.aliases] : [],
+      ...definition.description ? { description: definition.description } : {}
+    };
+    if (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 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 {
+    typesPath,
+    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);
+  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
+      }
+    },
+    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()
+  };
+}
+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(`Inspect one: pm schema show <Type>`);
+  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");
+}
+export {
+  SCHEMA_SUBCOMMANDS,
+  buildInvalidTypeHint,
+  formatSchemaAddStatusHuman,
+  formatSchemaAddTypeHuman,
+  formatSchemaListHuman,
+  formatSchemaRemoveStatusHuman,
+  formatSchemaRemoveTypeHuman,
+  formatSchemaShowHuman,
+  runSchemaAddStatus,
+  runSchemaAddType,
+  runSchemaList,
+  runSchemaRemoveStatus,
+  runSchemaRemoveType,
+  runSchemaShow
+};
+//# sourceMappingURL=schema-V6BX65Q2.js.map