@unbrained/pm-cli 2026.7.5 → 2026.7.6

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

@@ -0,0 +1,784 @@
+
+!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]="0631e6e9-60b6-5d96-9c1a-9ceed0a85d7f")}catch(e){}}();
+import {
+  resolveAuthor
+} from "./chunk-T5RRNDA7.js";
+import {
+  lintProjectProfile,
+  resolveProfileCatalog,
+  resolveProfileEntry
+} from "./chunk-GJ7QC5DJ.js";
+import {
+  CREATE_COMMANDER_REPEATABLE_OPTION_CONTRACTS
+} from "./chunk-EGAP5OWD.js";
+import {
+  ensureTypeFolderScaffold
+} from "./chunk-LPSSSDJR.js";
+import {
+  acquireLock
+} from "./chunk-ENGQOEUY.js";
+import {
+  normalizeAddFieldInput,
+  normalizeAddStatusInput,
+  parseFieldsFile,
+  parseStatusDefsFile,
+  serializeFieldsFile,
+  serializeStatusDefsFile,
+  upsertField,
+  upsertStatusDef
+} from "./chunk-XB7KFVFI.js";
+import {
+  parseNestedSettingValue,
+  readNestedSettingValue,
+  resolveNestedSettingDescriptor,
+  writeNestedSettingValue
+} from "./chunk-7LQKVMPA.js";
+import {
+  nowIso
+} from "./chunk-3GCS5SKL.js";
+import {
+  PmCliError,
+  getActiveExtensionRegistrations,
+  readSettings,
+  resolveGovernanceKnobs,
+  runActiveOnWriteHooks,
+  writeSettings
+} from "./chunk-E3SZTQ4K.js";
+import {
+  normalizeAddTypeInput,
+  parseItemTypesFile,
+  serializeItemTypesFile,
+  upsertItemType
+} from "./chunk-KUOOJR35.js";
+import {
+  DEFAULT_RUNTIME_SCHEMA_FILE_PATHS,
+  EXIT_CODE,
+  filePathForSchemaSection,
+  getSettingsPath,
+  normalizeRuntimeSchemaSettings,
+  pathExists,
+  readFileIfExists,
+  resolvePmRoot,
+  writeFileAtomic
+} from "./chunk-57NWPFF2.js";
+
+// dist/cli/commands/profile.js
+import path2 from "node:path";
+
+// dist/core/profile/profile-describe.js
+function describeProfileComposition(profile) {
+  return {
+    types: profile.types.length,
+    statuses: profile.statuses.length,
+    fields: profile.fields.length,
+    workflows: profile.workflows.length,
+    config: profile.config.length,
+    templates: profile.templates.length,
+    packages: profile.packages.length
+  };
+}
+function describeProjectProfile(profile) {
+  return {
+    name: profile.name,
+    title: profile.title,
+    summary: profile.summary,
+    composition: describeProfileComposition(profile),
+    types: profile.types.map((type) => lenientIdentifier(() => normalizeAddTypeInput(type).name, () => String(type.name ?? ""))),
+    statuses: profile.statuses.map((status) => lenientIdentifier(() => normalizeAddStatusInput(status).id, () => String(status.id ?? ""))),
+    fields: profile.fields.map((field) => lenientIdentifier(() => normalizeAddFieldInput(field).key, () => String(field.key ?? ""))),
+    workflows: profile.workflows.map((workflow) => workflow.type),
+    config: profile.config.map((entry) => `${entry.key}=${entry.value}`),
+    templates: profile.templates.map((template) => template.name),
+    packages: profile.packages.map((recommendation) => ({ spec: recommendation.spec, reason: recommendation.reason }))
+  };
+}
+function lenientIdentifier(normalize, raw) {
+  try {
+    return normalize();
+  } catch {
+    return raw();
+  }
+}
+
+// dist/core/profile/profile-plan.js
+function planSchemaComponent(initialFile, inputs, keyOf, serialize, upsert) {
+  let file = initialFile;
+  const changes = [];
+  for (const input of inputs) {
+    const before = serialize(file);
+    const result = upsert(file, input);
+    const after = serialize(result.file);
+    file = result.file;
+    const status = before === after ? "unchanged" : result.replaced ? "update" : "add";
+    changes.push({ key: keyOf(input), status });
+  }
+  return { file, changes, changed: changes.some((change) => change.status !== "unchanged") };
+}
+function canonicalTransitions(transitions) {
+  return JSON.stringify(transitions.map((pair) => pair.join("\0")).sort());
+}
+function planWorkflows(current, desired) {
+  const result = current.map((entry) => ({ ...entry }));
+  const changes = [];
+  for (const workflow of desired) {
+    const index = result.findIndex((entry) => entry.type === workflow.type);
+    const next = { type: workflow.type, allowed_transitions: workflow.allowed_transitions };
+    if (index < 0) {
+      result.push(next);
+      changes.push({ type: workflow.type, status: "add" });
+    } else if (canonicalTransitions(result[index].allowed_transitions) === canonicalTransitions(workflow.allowed_transitions)) {
+      changes.push({ type: workflow.type, status: "unchanged" });
+    } else {
+      result[index] = next;
+      changes.push({ type: workflow.type, status: "update" });
+    }
+  }
+  return { changes, result, changed: changes.some((change) => change.status !== "unchanged") };
+}
+function planConfig(profile, settings) {
+  const changes = [];
+  for (const entry of profile.config) {
+    const descriptor = resolveNestedSettingDescriptor(entry.key);
+    if (descriptor === void 0) {
+      throw new Error(`Profile "${profile.name}" references unknown config key "${entry.key}".`);
+    }
+    const parsed = parseNestedSettingValue(descriptor, entry.value);
+    if (!parsed.ok) {
+      throw new Error(`Profile "${profile.name}" config ${entry.key}: ${parsed.error.message}`);
+    }
+    const current = readNestedSettingValue(settings, descriptor);
+    const status = current === null ? "add" : current === parsed.parsed.value ? "unchanged" : "update";
+    changes.push({ key: descriptor.key, path: descriptor.path, value: parsed.parsed.value, status });
+  }
+  return { changes, changed: changes.some((change) => change.status !== "unchanged") };
+}
+function canonicalTemplateOptions(options) {
+  const sorted = Object.entries(options).sort(([left], [right]) => left.localeCompare(right));
+  return JSON.stringify(sorted);
+}
+function planTemplates(profile, existing) {
+  const changes = [];
+  for (const template of profile.templates) {
+    const current = existing.get(template.name);
+    let status;
+    if (current === void 0) {
+      status = "add";
+    } else if (canonicalTemplateOptions(current) === canonicalTemplateOptions(template.options)) {
+      status = "unchanged";
+    } else {
+      status = "update";
+    }
+    changes.push({ name: template.name, options: template.options, status });
+  }
+  return { changes, changed: changes.some((change) => change.status !== "unchanged") };
+}
+function planProfileApplication(profile, current) {
+  const types = planSchemaComponent(parseItemTypesFile(current.typesRaw), profile.types, (input) => normalizeAddTypeInput(input).name, serializeItemTypesFile, (file, input) => upsertItemType(file, normalizeAddTypeInput(input)));
+  const statuses = planSchemaComponent(parseStatusDefsFile(current.statusesRaw), profile.statuses, (input) => normalizeAddStatusInput(input).id, serializeStatusDefsFile, (file, input) => upsertStatusDef(file, normalizeAddStatusInput(input)));
+  const fields = planSchemaComponent(parseFieldsFile(current.fieldsRaw), profile.fields, (input) => normalizeAddFieldInput(input).key, serializeFieldsFile, (file, input) => upsertField(file, normalizeAddFieldInput(input)));
+  const workflows = planWorkflows(current.workflows, profile.workflows);
+  const config = planConfig(profile, current.settings);
+  const templates = planTemplates(profile, current.templates);
+  const packages = profile.packages.map((recommendation) => ({
+    spec: recommendation.spec,
+    reason: recommendation.reason,
+    status: current.installedPackages.has(recommendation.spec) ? "installed" : "recommended"
+  }));
+  const changed = types.changed || statuses.changed || fields.changed || workflows.changed || config.changed || templates.changed;
+  return {
+    profile: { name: profile.name, title: profile.title, summary: profile.summary },
+    types,
+    statuses,
+    fields,
+    workflows,
+    config,
+    templates,
+    packages,
+    changed
+  };
+}
+
+// dist/cli/commands/templates.js
+import fs from "node:fs/promises";
+import path from "node:path";
+var TEMPLATE_DIRECTORY_NAME = "templates";
+var TEMPLATE_FILE_EXTENSION = ".json";
+var TEMPLATE_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+var TEMPLATE_OPTION_REPEATABLE_KEYS = CREATE_COMMANDER_REPEATABLE_OPTION_CONTRACTS.map((entry) => entry.target);
+var TEMPLATE_OPTION_REPEATABLE_KEY_SET = new Set(TEMPLATE_OPTION_REPEATABLE_KEYS);
+var BUILTIN_TEMPLATE_TIMESTAMP = "1970-01-01T00:00:00.000Z";
+var BUILTIN_TEMPLATES = {
+  bug: {
+    type: "Issue",
+    priority: "1",
+    tags: "bug",
+    acceptanceCriteria: "Bug no longer reproduces with the steps below and a regression test guards it.",
+    expectedResult: "Describe the correct behavior.",
+    actualResult: "Describe the observed (buggy) behavior.",
+    body: "## Repro steps\n1. \n2. \n3. \n\n## Expected\n\n## Actual\n"
+  },
+  feature: {
+    type: "Feature",
+    priority: "2",
+    tags: "feature",
+    acceptanceCriteria: "Feature is shipped behind agreed scope with tests and docs updated.",
+    whyNow: "Explain why this is worth doing now (impact / urgency).",
+    body: "## Goal\n\n## Why now\n\n## Out of scope\n"
+  },
+  spike: {
+    type: "Task",
+    priority: "2",
+    tags: "spike",
+    estimatedMinutes: "120",
+    acceptanceCriteria: "Timeboxed investigation complete; findings and a recommendation are recorded.",
+    body: "## Question to answer\n\n## Timebox\n2h\n\n## Findings\n\n## Recommendation\n"
+  },
+  chore: {
+    type: "Chore",
+    priority: "3",
+    tags: "chore",
+    acceptanceCriteria: "Maintenance task done with no behavior change and green checks.",
+    body: "## What\n\n## Why\n"
+  }
+};
+function normalizeTemplateName(rawName) {
+  const name = rawName.trim();
+  if (!TEMPLATE_NAME_PATTERN.test(name)) {
+    throw new PmCliError(`Invalid template name "${rawName}". Expected 1-64 characters matching [A-Za-z0-9][A-Za-z0-9._-]*.`, EXIT_CODE.USAGE);
+  }
+  return name;
+}
+function templatesDirectory(pmRoot) {
+  return path.join(pmRoot, TEMPLATE_DIRECTORY_NAME);
+}
+function templatePath(pmRoot, normalizedName) {
+  return path.join(templatesDirectory(pmRoot), `${normalizedName}${TEMPLATE_FILE_EXTENSION}`);
+}
+async function ensureTrackerInitialized(pmRoot) {
+  if (!await pathExists(getSettingsPath(pmRoot))) {
+    throw new PmCliError(`Tracker is not initialized at ${pmRoot}. Run pm init first.`, EXIT_CODE.NOT_FOUND);
+  }
+}
+function sortTemplateOptions(options) {
+  return Object.fromEntries(Object.entries(options).sort(([left], [right]) => left.localeCompare(right)));
+}
+function extractTemplateOptions(rawOptions) {
+  const next = {};
+  for (const [key, value] of Object.entries(rawOptions)) {
+    if (value === void 0) {
+      continue;
+    }
+    if (TEMPLATE_OPTION_REPEATABLE_KEY_SET.has(key)) {
+      if (typeof value === "string") {
+        next[key] = [value];
+        continue;
+      }
+      if (!Array.isArray(value)) {
+        continue;
+      }
+      const values = value.filter((entry) => typeof entry === "string");
+      if (values.length > 0) {
+        next[key] = values;
+      }
+      continue;
+    }
+    if (typeof value === "string") {
+      next[key] = value;
+      continue;
+    }
+    if (Array.isArray(value) && value.every((entry) => typeof entry === "string")) {
+      next[key] = [...value];
+    }
+  }
+  return sortTemplateOptions(next);
+}
+function parseStoredTemplateOptions(rawOptions, templateName) {
+  if (typeof rawOptions !== "object" || rawOptions === null || Array.isArray(rawOptions)) {
+    throw new PmCliError(`Template "${templateName}" has invalid options payload.`, EXIT_CODE.GENERIC_FAILURE);
+  }
+  const optionsRecord = rawOptions;
+  const normalized = {};
+  for (const [key, value] of Object.entries(optionsRecord)) {
+    const normalizedKey = key.trim();
+    if (normalizedKey.length === 0) {
+      throw new PmCliError(`Template "${templateName}" contains an empty option key.`, EXIT_CODE.GENERIC_FAILURE);
+    }
+    if (typeof value === "string") {
+      normalized[normalizedKey] = value;
+      continue;
+    }
+    if (Array.isArray(value) && value.every((entry) => typeof entry === "string")) {
+      normalized[normalizedKey] = [...value];
+      continue;
+    }
+    throw new PmCliError(`Template "${templateName}" contains invalid value for option "${normalizedKey}".`, EXIT_CODE.GENERIC_FAILURE);
+  }
+  return sortTemplateOptions(normalized);
+}
+function parseStoredTemplateDocument(raw, normalizedName) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new PmCliError(`Template "${normalizedName}" contains invalid JSON.`, EXIT_CODE.GENERIC_FAILURE);
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new PmCliError(`Template "${normalizedName}" has invalid document shape.`, EXIT_CODE.GENERIC_FAILURE);
+  }
+  const record = parsed;
+  const options = parseStoredTemplateOptions(record.options, normalizedName);
+  const now = nowIso();
+  return {
+    name: typeof record.name === "string" && record.name.trim().length > 0 ? record.name.trim() : normalizedName,
+    created_at: typeof record.created_at === "string" ? record.created_at : now,
+    updated_at: typeof record.updated_at === "string" ? record.updated_at : now,
+    options
+  };
+}
+function builtinTemplateDocument(normalizedName) {
+  const options = BUILTIN_TEMPLATES[normalizedName];
+  if (!options) {
+    return null;
+  }
+  return {
+    name: normalizedName,
+    created_at: BUILTIN_TEMPLATE_TIMESTAMP,
+    updated_at: BUILTIN_TEMPLATE_TIMESTAMP,
+    options: sortTemplateOptions({ ...options })
+  };
+}
+async function resolveTemplateDocument(pmRoot, normalizedName) {
+  const raw = await readFileIfExists(templatePath(pmRoot, normalizedName));
+  if (raw !== null) {
+    return { document: parseStoredTemplateDocument(raw, normalizedName), source: "user" };
+  }
+  const builtin = builtinTemplateDocument(normalizedName);
+  if (builtin) {
+    return { document: builtin, source: "builtin" };
+  }
+  throw new PmCliError(`Template "${normalizedName}" not found`, EXIT_CODE.NOT_FOUND);
+}
+async function readStoredTemplateDocument(pmRoot, normalizedName) {
+  const raw = await readFileIfExists(templatePath(pmRoot, normalizedName));
+  if (raw === null) {
+    throw new PmCliError(`Template "${normalizedName}" not found`, EXIT_CODE.NOT_FOUND);
+  }
+  return parseStoredTemplateDocument(raw, normalizedName);
+}
+async function loadCreateTemplateOptions(pmRoot, rawTemplateName) {
+  const normalizedName = normalizeTemplateName(rawTemplateName);
+  const { document } = await resolveTemplateDocument(pmRoot, normalizedName);
+  return document.options;
+}
+async function runTemplatesSave(rawTemplateName, options, global) {
+  const pmRoot = resolvePmRoot(process.cwd(), global.path);
+  await ensureTrackerInitialized(pmRoot);
+  const normalizedName = normalizeTemplateName(rawTemplateName);
+  const nextOptions = extractTemplateOptions(options);
+  if (Object.keys(nextOptions).length === 0) {
+    throw new PmCliError("templates save requires at least one create option flag", EXIT_CODE.USAGE);
+  }
+  const now = nowIso();
+  const storedPath = templatePath(pmRoot, normalizedName);
+  let createdAt = now;
+  if (await pathExists(storedPath)) {
+    const existing = await readStoredTemplateDocument(pmRoot, normalizedName);
+    createdAt = existing.created_at;
+  }
+  const document = {
+    name: normalizedName,
+    created_at: createdAt,
+    updated_at: now,
+    options: nextOptions
+  };
+  await fs.mkdir(templatesDirectory(pmRoot), { recursive: true });
+  await writeFileAtomic(storedPath, `${JSON.stringify(document, null, 2)}
+`);
+  return {
+    name: document.name,
+    created_at: document.created_at,
+    updated_at: document.updated_at,
+    path: storedPath,
+    options: document.options
+  };
+}
+async function readUserTemplateNames(pmRoot) {
+  const dirPath = templatesDirectory(pmRoot);
+  if (!await pathExists(dirPath)) {
+    return [];
+  }
+  const entries = await fs.readdir(dirPath);
+  return entries.filter((entry) => entry.toLowerCase().endsWith(TEMPLATE_FILE_EXTENSION)).map((entry) => entry.slice(0, -TEMPLATE_FILE_EXTENSION.length)).filter((entry) => TEMPLATE_NAME_PATTERN.test(entry));
+}
+async function runTemplatesList(global) {
+  const pmRoot = resolvePmRoot(process.cwd(), global.path);
+  await ensureTrackerInitialized(pmRoot);
+  const userTemplates = await readUserTemplateNames(pmRoot);
+  const userTemplateSet = new Set(userTemplates);
+  const builtinTemplates = Object.keys(BUILTIN_TEMPLATES).filter((name) => !userTemplateSet.has(name));
+  const sortedUser = [...userTemplates].sort((left, right) => left.localeCompare(right));
+  const sortedBuiltin = [...builtinTemplates].sort((left, right) => left.localeCompare(right));
+  const templates = [.../* @__PURE__ */ new Set([...sortedUser, ...sortedBuiltin])].sort((left, right) => left.localeCompare(right));
+  return {
+    templates,
+    count: templates.length,
+    builtin_templates: sortedBuiltin,
+    user_templates: sortedUser
+  };
+}
+async function runTemplatesShow(rawTemplateName, global) {
+  const pmRoot = resolvePmRoot(process.cwd(), global.path);
+  await ensureTrackerInitialized(pmRoot);
+  const normalizedName = normalizeTemplateName(rawTemplateName);
+  const { document, source } = await resolveTemplateDocument(pmRoot, normalizedName);
+  return {
+    name: document.name,
+    source,
+    created_at: document.created_at,
+    updated_at: document.updated_at,
+    path: source === "builtin" ? `builtin:${normalizedName}` : templatePath(pmRoot, normalizedName),
+    options: document.options
+  };
+}
+
+// dist/cli/commands/profile.js
+var PROFILE_SUBCOMMANDS = ["list", "show", "apply", "lint"];
+var PROFILE_TYPES_LOCK_ID = "schema-types";
+var PROFILE_STATUSES_LOCK_ID = "schema-statuses";
+var PROFILE_FIELDS_LOCK_ID = "schema-fields";
+function collectExtensionProfileContributions() {
+  const registrations = getActiveExtensionRegistrations();
+  if (registrations === null) {
+    return [];
+  }
+  return registrations.profiles.map((entry) => ({ name: entry.name, profile: entry.profile }));
+}
+function runProfileList() {
+  const { profiles, warnings } = resolveProfileCatalog(collectExtensionProfileContributions());
+  return {
+    action: "list",
+    profiles: profiles.map((resolved) => ({
+      name: resolved.definition.name,
+      title: resolved.definition.title,
+      summary: resolved.definition.summary,
+      source: resolved.source,
+      ...resolved.package !== void 0 ? { package: resolved.package } : {},
+      composition: describeProfileComposition(resolved.definition)
+    })),
+    warnings,
+    generated_at: nowIso()
+  };
+}
+function runProfileShow(name) {
+  let entry;
+  try {
+    entry = resolveProfileEntry(name, collectExtensionProfileContributions());
+  } catch (error) {
+    throw new PmCliError(error instanceof Error ? error.message : String(error), EXIT_CODE.USAGE);
+  }
+  const { resolved } = entry;
+  return {
+    action: "show",
+    ...describeProjectProfile(resolved.definition),
+    source: resolved.source,
+    ...resolved.package !== void 0 ? { package: resolved.package } : {},
+    warnings: entry.warnings,
+    generated_at: nowIso()
+  };
+}
+function runProfileLint(name) {
+  let entry;
+  try {
+    entry = resolveProfileEntry(name, collectExtensionProfileContributions());
+  } catch (error) {
+    throw new PmCliError(error instanceof Error ? error.message : String(error), EXIT_CODE.USAGE);
+  }
+  const { resolved } = entry;
+  const report = lintProjectProfile(resolved.definition);
+  return {
+    action: "lint",
+    name: resolved.definition.name,
+    title: resolved.definition.title,
+    source: resolved.source,
+    ...resolved.package !== void 0 ? { package: resolved.package } : {},
+    ok: report.ok,
+    error_count: report.errorCount,
+    warning_count: report.warningCount,
+    findings: report.findings,
+    warnings: entry.warnings,
+    generated_at: nowIso()
+  };
+}
+function templateFilePath(pmRoot, name) {
+  return path2.join(pmRoot, "templates", `${name}.json`);
+}
+async function readStoredTemplateOptions(pmRoot, name) {
+  const raw = await readFileIfExists(templateFilePath(pmRoot, name));
+  if (raw === null) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+      const options = parsed.options;
+      if (options !== null && typeof options === "object" && !Array.isArray(options)) {
+        return options;
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+async function loadProfileCurrentState(pmRoot, schema, settings, profile) {
+  const templates = /* @__PURE__ */ new Map();
+  for (const template of profile.templates) {
+    const stored = await readStoredTemplateOptions(pmRoot, template.name);
+    if (stored !== void 0) {
+      templates.set(template.name, stored);
+    }
+  }
+  return {
+    typesRaw: await readFileIfExists(filePathForSchemaSection(pmRoot, schema.files.types, DEFAULT_RUNTIME_SCHEMA_FILE_PATHS.types)),
+    statusesRaw: await readFileIfExists(filePathForSchemaSection(pmRoot, schema.files.statuses, DEFAULT_RUNTIME_SCHEMA_FILE_PATHS.statuses)),
+    fieldsRaw: await readFileIfExists(filePathForSchemaSection(pmRoot, schema.files.fields, DEFAULT_RUNTIME_SCHEMA_FILE_PATHS.fields)),
+    workflows: settings.schema.type_workflows ?? [],
+    settings,
+    templates,
+    // Package recommendations are advisory: apply never installs and never
+    // inspects install state, so every recommendation surfaces as "recommended".
+    // The planner still supports an install-state set for SDK consumers that want
+    // richer reporting.
+    installedPackages: /* @__PURE__ */ new Set()
+  };
+}
+function dimensionFrom(changes) {
+  const added = [];
+  const updated = [];
+  const unchanged = [];
+  for (const change of changes) {
+    (change.status === "add" ? added : change.status === "update" ? updated : unchanged).push(change.key);
+  }
+  return { added, updated, unchanged };
+}
+function buildApplyResult(profile, plan, applied, dryRun, warnings) {
+  return {
+    action: "apply",
+    name: profile.name,
+    title: profile.title,
+    applied,
+    dry_run: dryRun,
+    changed: plan.changed,
+    types: dimensionFrom(plan.types.changes),
+    statuses: dimensionFrom(plan.statuses.changes),
+    fields: dimensionFrom(plan.fields.changes),
+    workflows: dimensionFrom(plan.workflows.changes.map((change) => ({ key: change.type, status: change.status }))),
+    config: dimensionFrom(plan.config.changes),
+    templates: dimensionFrom(plan.templates.changes.map((change) => ({ key: change.name, status: change.status }))),
+    packages: plan.packages,
+    warnings: [...new Set(warnings)].sort((left, right) => left.localeCompare(right)),
+    generated_at: nowIso()
+  };
+}
+async function assertProfileTrackerInitialized(pmRoot) {
+  if (!await pathExists(getSettingsPath(pmRoot))) {
+    throw new PmCliError(`Tracker is not initialized at ${pmRoot}. Run pm init first.`, EXIT_CODE.NOT_FOUND);
+  }
+}
+function resolveProfileForCommand(name) {
+  try {
+    const entry = resolveProfileEntry(name, collectExtensionProfileContributions());
+    return {
+      profile: entry.resolved.definition,
+      warnings: entry.warnings
+    };
+  } catch (error) {
+    throw new PmCliError(error instanceof Error ? error.message : String(error), EXIT_CODE.USAGE);
+  }
+}
+async function runProfileApply(name, options, global) {
+  const pmRoot = resolvePmRoot(process.cwd(), global.path);
+  await assertProfileTrackerInitialized(pmRoot);
+  const resolvedProfile = resolveProfileForCommand(name);
+  const profile = resolvedProfile.profile;
+  const mergeWarnings = resolvedProfile.warnings;
+  const dryRun = options.dryRun === true;
+  const settings = await readSettings(pmRoot);
+  const schema = normalizeRuntimeSchemaSettings(settings.schema);
+  if (dryRun) {
+    const state = await loadProfileCurrentState(pmRoot, schema, settings, profile);
+    const plan2 = planProfile(profile, state);
+    return buildApplyResult(profile, plan2, false, true, [...mergeWarnings]);
+  }
+  const author = resolveAuthor(options.author, settings.author_default);
+  const governance = resolveGovernanceKnobs(settings);
+  const force = Boolean(options.force);
+  const warnings = [...mergeWarnings];
+  const releasers = [];
+  const acquire = async (lockId) => {
+    releasers.push(await acquireLock(pmRoot, lockId, settings.locks.ttl_seconds, author, force, governance.force_required_for_stale_lock, settings.locks.wait_ms));
+  };
+  let plan;
+  try {
+    await acquire(PROFILE_TYPES_LOCK_ID);
+    await acquire(PROFILE_STATUSES_LOCK_ID);
+    await acquire(PROFILE_FIELDS_LOCK_ID);
+    const state = await loadProfileCurrentState(pmRoot, schema, settings, profile);
+    plan = planProfile(profile, state);
+    if (plan.types.changed) {
+      const typesPath = filePathForSchemaSection(pmRoot, schema.files.types, DEFAULT_RUNTIME_SCHEMA_FILE_PATHS.types);
+      await writeFileAtomic(typesPath, serializeItemTypesFile(plan.types.file));
+      const stagedNames = new Set(profile.types.map((type) => normalizeAddTypeInput(type).name));
+      const stagedDefinitions = plan.types.file.definitions.filter((definition) => stagedNames.has(definition.name));
+      await ensureTypeFolderScaffold(pmRoot, stagedDefinitions, warnings, "profile:apply-type-folder");
+      warnings.push(...await runActiveOnWriteHooks({ path: typesPath, scope: "project", op: "profile:apply-types" }));
+    }
+    if (plan.statuses.changed) {
+      const statusesPath = filePathForSchemaSection(pmRoot, schema.files.statuses, DEFAULT_RUNTIME_SCHEMA_FILE_PATHS.statuses);
+      await writeFileAtomic(statusesPath, serializeStatusDefsFile(plan.statuses.file));
+      warnings.push(...await runActiveOnWriteHooks({ path: statusesPath, scope: "project", op: "profile:apply-statuses" }));
+    }
+    if (plan.fields.changed) {
+      const fieldsPath = filePathForSchemaSection(pmRoot, schema.files.fields, DEFAULT_RUNTIME_SCHEMA_FILE_PATHS.fields);
+      await writeFileAtomic(fieldsPath, serializeFieldsFile(plan.fields.file));
+      warnings.push(...await runActiveOnWriteHooks({ path: fieldsPath, scope: "project", op: "profile:apply-fields" }));
+    }
+    if (plan.config.changed || plan.workflows.changed) {
+      for (const change of plan.config.changes) {
+        if (change.status === "unchanged") {
+          continue;
+        }
+        const descriptor = resolveNestedSettingDescriptor(change.key);
+        if (descriptor !== void 0) {
+          writeNestedSettingValue(settings, descriptor, change.value);
+        }
+      }
+      settings.schema.type_workflows = plan.workflows.result;
+      await writeSettings(pmRoot, settings, "profile:apply-config");
+    }
+    for (const change of plan.templates.changes) {
+      if (change.status === "unchanged") {
+        continue;
+      }
+      await runTemplatesSave(change.name, { ...change.options }, global);
+    }
+  } finally {
+    for (const release of releasers.reverse()) {
+      try {
+        await release();
+      } catch {
+      }
+    }
+  }
+  return buildApplyResult(profile, plan, plan.changed, false, warnings);
+}
+function planProfile(profile, state) {
+  try {
+    return planProfileApplication(profile, state);
+  } catch (error) {
+    throw new PmCliError(error instanceof Error ? error.message : String(error), EXIT_CODE.USAGE);
+  }
+}
+function formatDimensionLine(label, dimension) {
+  const segments = [];
+  if (dimension.added.length > 0) {
+    segments.push(`+${dimension.added.join(", ")}`);
+  }
+  if (dimension.updated.length > 0) {
+    segments.push(`~${dimension.updated.join(", ")}`);
+  }
+  if (segments.length === 0) {
+    return void 0;
+  }
+  return `  ${label}: ${segments.join("  ")}`;
+}
+function formatProfileListHuman(result) {
+  const lines = ["Project profiles:"];
+  for (const profile of result.profiles) {
+    const origin = profile.source === "extension" ? ` [${profile.package ?? "extension"}]` : "";
+    lines.push(`  ${profile.name} \u2014 ${profile.title}: ${profile.summary}${origin}`);
+  }
+  for (const warning of result.warnings) {
+    lines.push(`  warning: ${warning}`);
+  }
+  return lines.join("\n");
+}
+function formatProfileShowHuman(result) {
+  const origin = result.source === "extension" ? ` [${result.package ?? "extension"}]` : "";
+  const lines = [`${result.name} \u2014 ${result.title}${origin}`, result.summary, ""];
+  lines.push(`types: ${result.types.join(", ") || "(none)"}`);
+  lines.push(`statuses: ${result.statuses.join(", ") || "(none)"}`);
+  lines.push(`fields: ${result.fields.join(", ") || "(none)"}`);
+  lines.push(`workflows: ${result.workflows.join(", ") || "(none)"}`);
+  lines.push(`config: ${result.config.join(", ") || "(none)"}`);
+  lines.push(`templates: ${result.templates.join(", ") || "(none)"}`);
+  lines.push(`packages: ${result.packages.map((pkg) => pkg.spec).join(", ") || "(none)"}`);
+  for (const warning of result.warnings) {
+    lines.push(`warning: ${warning}`);
+  }
+  return lines.join("\n");
+}
+function formatProfileLintHuman(result) {
+  const origin = result.source === "extension" ? ` [${result.package ?? "extension"}]` : "";
+  const totalWarningCount = result.warning_count + result.warnings.length;
+  const verdict = result.ok ? `Profile ${result.name}${origin}: ok (${totalWarningCount} warning${totalWarningCount === 1 ? "" : "s"})` : `Profile ${result.name}${origin}: ${result.error_count} error${result.error_count === 1 ? "" : "s"}, ${totalWarningCount} warning${totalWarningCount === 1 ? "" : "s"}`;
+  const lines = [verdict];
+  for (const finding of result.findings) {
+    const target = finding.target !== void 0 ? ` (${finding.target})` : "";
+    lines.push(`  ${finding.severity} [${finding.code}] ${finding.dimension}${target}: ${finding.message}`);
+  }
+  for (const warning of result.warnings) {
+    lines.push(`  warning: ${warning}`);
+  }
+  return lines.join("\n");
+}
+function formatProfileApplyHuman(result) {
+  const mode = result.dry_run ? "dry-run" : result.applied ? "applied" : "no changes";
+  const lines = [`Profile ${result.name} (${mode})`];
+  if (!result.changed) {
+    lines.push("  already up to date");
+  } else {
+    for (const [label, dimension] of [
+      ["types", result.types],
+      ["statuses", result.statuses],
+      ["fields", result.fields],
+      ["workflows", result.workflows],
+      ["config", result.config],
+      ["templates", result.templates]
+    ]) {
+      const line = formatDimensionLine(label, dimension);
+      if (line !== void 0) {
+        lines.push(line);
+      }
+    }
+  }
+  const recommended = result.packages.filter((pkg) => pkg.status === "recommended");
+  if (recommended.length > 0) {
+    lines.push(`  recommended packages: ${recommended.map((pkg) => pkg.spec).join(", ")}`);
+  }
+  for (const warning of result.warnings) {
+    lines.push(`  warning: ${warning}`);
+  }
+  return lines.join("\n");
+}
+
+export {
+  describeProfileComposition,
+  describeProjectProfile,
+  planProfileApplication,
+  loadCreateTemplateOptions,
+  runTemplatesSave,
+  runTemplatesList,
+  runTemplatesShow,
+  PROFILE_SUBCOMMANDS,
+  runProfileList,
+  runProfileShow,
+  runProfileLint,
+  runProfileApply,
+  formatProfileListHuman,
+  formatProfileShowHuman,
+  formatProfileLintHuman,
+  formatProfileApplyHuman
+};
+//# sourceMappingURL=chunk-CFNGIXZP.js.map
+
+//# debugId=0631e6e9-60b6-5d96-9c1a-9ceed0a85d7f