@unbrained/pm-cli 2026.6.24 → 2026.7.1

package/dist/cli-bundle/chunks/profile-QLER5ENE.js

@@ -0,0 +1,1197 @@
+
+!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]="772b3e4a-0a59-501b-a0fa-0a6596a9a1fb")}catch(e){}}();
+import {
+  normalizeStatusToken
+} from "./chunk-YJIEJRZB.js";
+import {
+  resolveAuthor
+} from "./chunk-T5RRNDA7.js";
+import {
+  parseNestedSettingValue,
+  readNestedSettingValue,
+  resolveNestedSettingDescriptor,
+  writeNestedSettingValue
+} from "./chunk-OKQ22KTH.js";
+import {
+  TYPE_PRESET_DEFINITIONS,
+  ensureTypeFolderScaffold,
+  normalizeAddFieldInput,
+  normalizeAddStatusInput,
+  parseFieldsFile,
+  parseStatusDefsFile,
+  serializeFieldsFile,
+  serializeStatusDefsFile,
+  upsertField,
+  upsertStatusDef
+} from "./chunk-2D4HATP2.js";
+import {
+  normalizeAddTypeInput,
+  parseItemTypesFile,
+  serializeItemTypesFile,
+  upsertItemType
+} from "./chunk-MAUKX7JC.js";
+import {
+  CREATE_COMMANDER_REPEATABLE_OPTION_CONTRACTS
+} from "./chunk-HXTQJXWT.js";
+import {
+  acquireLock
+} from "./chunk-JSU5P7VS.js";
+import "./chunk-QCWF6IYD.js";
+import {
+  nowIso
+} from "./chunk-AXIDKKAT.js";
+import {
+  BUILTIN_ITEM_TYPE_VALUES,
+  DEFAULT_RUNTIME_SCHEMA_FILE_PATHS,
+  DEFAULT_RUNTIME_STATUS_DEFINITIONS,
+  EXIT_CODE,
+  PmCliError,
+  filePathForSchemaSection,
+  getActiveExtensionRegistrations,
+  getSettingsPath,
+  normalizeRuntimeSchemaSettings,
+  pathExists,
+  readFileIfExists,
+  readSettings,
+  resolveGovernanceKnobs,
+  resolvePmRoot,
+  runActiveOnWriteHooks,
+  toErrorMessage,
+  writeFileAtomic,
+  writeSettings
+} from "./chunk-7R4QEMZZ.js";
+
+// dist/cli/commands/profile.js
+import path2 from "node:path";
+
+// dist/core/profile/profile-presets.js
+var PROFILE_NAMES = ["agile", "ops", "research"];
+var BUILTIN_PROFILES = {
+  agile: {
+    name: "agile",
+    title: "Agile delivery",
+    summary: "Story/Spike delivery with a review stage, story points, and acceptance ownership.",
+    types: TYPE_PRESET_DEFINITIONS.agile,
+    statuses: [
+      {
+        id: "review",
+        roles: ["active"],
+        aliases: ["in-review"],
+        description: "Work is implementation-complete and awaiting peer review."
+      }
+    ],
+    fields: [
+      {
+        key: "story_points",
+        type: "number",
+        commands: ["create", "update", "list"],
+        description: "Relative estimation size for a story or spike.",
+        aliases: ["points"]
+      },
+      {
+        key: "acceptance_owner",
+        type: "string",
+        commands: ["create", "update", "list"],
+        description: "Stakeholder accountable for accepting the delivered story.",
+        aliases: ["acceptor"]
+      }
+    ],
+    workflows: [
+      {
+        type: "Story",
+        allowed_transitions: [
+          ["open", "in_progress"],
+          ["in_progress", "review"],
+          ["review", "in_progress"],
+          ["review", "closed"],
+          ["in_progress", "blocked"],
+          ["blocked", "in_progress"]
+        ]
+      }
+    ],
+    config: [
+      { key: "search_provider", value: "bm25", summary: "Offline BM25 lexical search works without an embedding service." },
+      { key: "search_max_results", value: "20", summary: "Sprint-sized result cap for quick triage." }
+    ],
+    templates: [
+      {
+        name: "story",
+        options: {
+          type: "Story",
+          priority: "2",
+          tags: "story",
+          acceptanceCriteria: "Story delivers the stated user outcome with tests and docs updated.",
+          body: "## As a\n\n## I want\n\n## So that\n\n## Acceptance\n- [ ] \n"
+        }
+      }
+    ],
+    packages: [
+      { spec: "templates", reason: "Reusable create templates for recurring story shapes." },
+      { spec: "calendar", reason: "Sprint and iteration scheduling views." },
+      { spec: "search-advanced", reason: "Richer retrieval as the backlog grows." }
+    ]
+  },
+  ops: {
+    name: "ops",
+    title: "Operations",
+    summary: "Incident/Runbook response with mitigation and monitoring stages, severity, and service fields.",
+    types: TYPE_PRESET_DEFINITIONS.ops,
+    statuses: [
+      {
+        id: "mitigating",
+        roles: ["active"],
+        aliases: ["mitigation"],
+        description: "Active mitigation is underway to restore service."
+      },
+      {
+        id: "monitoring",
+        roles: ["active"],
+        aliases: ["observing"],
+        description: "Mitigation applied; monitoring for recurrence before closure."
+      }
+    ],
+    fields: [
+      {
+        key: "severity",
+        type: "string",
+        commands: ["create", "update", "list"],
+        description: "Incident severity classification (e.g. sev1, sev2, sev3).",
+        aliases: ["sev"]
+      },
+      {
+        key: "service",
+        type: "string",
+        commands: ["create", "update", "list"],
+        description: "Primary affected service or component."
+      }
+    ],
+    workflows: [
+      {
+        type: "Incident",
+        allowed_transitions: [
+          ["open", "mitigating"],
+          ["mitigating", "monitoring"],
+          ["monitoring", "mitigating"],
+          ["monitoring", "closed"],
+          ["mitigating", "blocked"],
+          ["blocked", "mitigating"]
+        ]
+      }
+    ],
+    config: [
+      { key: "search_provider", value: "bm25", summary: "Offline BM25 lexical search for fast incident lookup." },
+      { key: "search_max_results", value: "25", summary: "Wider result cap to surface related incidents and runbooks." }
+    ],
+    templates: [
+      {
+        name: "incident",
+        options: {
+          type: "Incident",
+          priority: "1",
+          tags: "incident",
+          acceptanceCriteria: "Service restored, root cause documented, and follow-ups filed.",
+          body: "## Impact\n\n## Timeline\n\n## Root cause\n\n## Mitigation\n\n## Follow-ups\n"
+        }
+      }
+    ],
+    packages: [
+      { spec: "lifecycle-hooks", reason: "Automate transitions and notifications on incident state changes." },
+      { spec: "governance-audit", reason: "Audit incident metadata completeness and closure quality." },
+      { spec: "calendar", reason: "On-call and follow-up scheduling." }
+    ]
+  },
+  research: {
+    name: "research",
+    title: "Research",
+    summary: "Experiment/Hypothesis investigation with an analysis stage, hypothesis, and method fields.",
+    types: TYPE_PRESET_DEFINITIONS.research,
+    statuses: [
+      {
+        id: "analyzing",
+        roles: ["active"],
+        aliases: ["analysis"],
+        description: "Data collected; analysis and synthesis in progress."
+      }
+    ],
+    fields: [
+      {
+        key: "hypothesis",
+        type: "string",
+        commands: ["create", "update"],
+        description: "The testable claim the experiment evaluates."
+      },
+      {
+        key: "method",
+        type: "string",
+        commands: ["create", "update", "list"],
+        description: "Experimental method or protocol used to evaluate the hypothesis.",
+        aliases: ["protocol"]
+      }
+    ],
+    workflows: [
+      {
+        type: "Experiment",
+        allowed_transitions: [
+          ["open", "in_progress"],
+          ["in_progress", "analyzing"],
+          ["analyzing", "in_progress"],
+          ["analyzing", "closed"],
+          ["in_progress", "blocked"],
+          ["blocked", "in_progress"]
+        ]
+      }
+    ],
+    config: [
+      { key: "search_provider", value: "bm25", summary: "Offline BM25 lexical search across the research corpus." },
+      { key: "search_max_results", value: "50", summary: "Broader recall cap for literature and prior-experiment discovery." }
+    ],
+    templates: [
+      {
+        name: "experiment",
+        options: {
+          type: "Experiment",
+          priority: "2",
+          tags: "experiment",
+          acceptanceCriteria: "Hypothesis is supported, rejected, or refined with recorded evidence.",
+          body: "## Hypothesis\n\n## Method\n\n## Results\n\n## Conclusion\n"
+        }
+      }
+    ],
+    packages: [
+      { spec: "search-advanced", reason: "Semantic retrieval over experiments and findings." },
+      { spec: "templates", reason: "Consistent experiment and hypothesis scaffolds." },
+      { spec: "beads", reason: "Import structured prior work into the tracker." }
+    ]
+  }
+};
+function normalizeProfileLookupKey(rawValue) {
+  return rawValue.trim().toLowerCase().replaceAll("-", "_");
+}
+function formatAvailableProfileNames(profiles) {
+  return profiles.map((entry) => entry.definition.name).join(", ");
+}
+function resolveProfileCatalog(contributions = []) {
+  const profiles = PROFILE_NAMES.map((name) => ({
+    definition: BUILTIN_PROFILES[name],
+    source: "builtin"
+  }));
+  const builtinKeys = new Set(PROFILE_NAMES.map((name) => normalizeProfileLookupKey(name)));
+  const seen = new Set(builtinKeys);
+  const warnings = [];
+  for (const contribution of contributions) {
+    const key = normalizeProfileLookupKey(contribution.profile.name);
+    if (builtinKeys.has(key)) {
+      warnings.push(`Extension "${contribution.name}" profile "${contribution.profile.name}" uses a name reserved by a built-in archetype and was ignored.`);
+      continue;
+    }
+    if (seen.has(key)) {
+      warnings.push(`Profile "${contribution.profile.name}" from extension "${contribution.name}" duplicates an already-registered profile and was ignored.`);
+      continue;
+    }
+    seen.add(key);
+    profiles.push({ definition: contribution.profile, source: "extension", package: contribution.name });
+  }
+  return { profiles, warnings };
+}
+function resolveProfileEntry(rawValue, contributions = []) {
+  const { profiles, warnings } = resolveProfileCatalog(contributions);
+  if (typeof rawValue !== "string" || rawValue.trim().length === 0) {
+    throw new Error(`Profile name is required. Allowed: ${formatAvailableProfileNames(profiles)}.`);
+  }
+  const key = normalizeProfileLookupKey(rawValue);
+  const match = profiles.find((entry) => normalizeProfileLookupKey(entry.definition.name) === key);
+  if (match === void 0) {
+    throw new Error(`Invalid profile "${rawValue}". Allowed: ${formatAvailableProfileNames(profiles)}.`);
+  }
+  return { resolved: match, warnings };
+}
+
+// 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-lint.js
+var BUILTIN_STATUS_TOKENS = new Set(DEFAULT_RUNTIME_STATUS_DEFINITIONS.flatMap((definition) => [
+  normalizeStatusToken(definition.id),
+  ...(definition.aliases ?? []).map((alias) => normalizeStatusToken(alias))
+]).filter((token) => token.length > 0));
+var BUILTIN_TYPE_KEYS = new Set(BUILTIN_ITEM_TYPE_VALUES.map((name) => name.toLowerCase()));
+function lintProfileIdentity(profile, findings) {
+  if (profile.name.trim().length === 0) {
+    findings.push({
+      severity: "error",
+      code: "profile_name_empty",
+      dimension: "profile",
+      message: "Profile name must not be empty; profile resolution requires a non-blank name."
+    });
+  } else if (profile.name !== normalizeProfileLookupKey(profile.name)) {
+    findings.push({
+      severity: "warning",
+      code: "profile_name_not_normalized",
+      dimension: "profile",
+      target: profile.name,
+      message: `Profile name "${profile.name}" is not in canonical form; resolution folds it to "${normalizeProfileLookupKey(profile.name)}" (lowercase, hyphens as underscores).`
+    });
+  }
+  if (profile.title.trim().length === 0) {
+    findings.push({
+      severity: "warning",
+      code: "profile_title_empty",
+      dimension: "profile",
+      message: "Profile title is empty; list and show surfaces will render a blank title."
+    });
+  }
+  if (profile.summary.trim().length === 0) {
+    findings.push({
+      severity: "warning",
+      code: "profile_summary_empty",
+      dimension: "profile",
+      message: "Profile summary is empty; list and show surfaces will render a blank archetype description."
+    });
+  }
+}
+function lintTypes(profile, findings) {
+  const declared = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, type] of profile.types.entries()) {
+    let name;
+    try {
+      name = normalizeAddTypeInput(type).name;
+    } catch (error) {
+      findings.push({
+        severity: "error",
+        code: "type_invalid",
+        dimension: "types",
+        target: typeof type.name === "string" ? type.name : `#${index}`,
+        message: toErrorMessage(error)
+      });
+      continue;
+    }
+    const key = name.toLowerCase();
+    if (seen.has(key)) {
+      findings.push({
+        severity: "error",
+        code: "type_duplicate",
+        dimension: "types",
+        target: name,
+        message: `Item type "${name}" is declared more than once; the later definition silently overwrites the earlier upsert.`
+      });
+      continue;
+    }
+    seen.add(key);
+    declared.add(key);
+  }
+  return declared;
+}
+function lintStatuses(profile, findings) {
+  const declared = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, status] of profile.statuses.entries()) {
+    let normalized;
+    try {
+      normalized = normalizeAddStatusInput(status);
+    } catch (error) {
+      findings.push({
+        severity: "error",
+        code: "status_invalid",
+        dimension: "statuses",
+        target: typeof status.id === "string" ? status.id : `#${index}`,
+        message: toErrorMessage(error)
+      });
+      continue;
+    }
+    if (seen.has(normalized.id)) {
+      findings.push({
+        severity: "error",
+        code: "status_duplicate",
+        dimension: "statuses",
+        target: normalized.id,
+        message: `Status "${normalized.id}" is declared more than once; the later definition silently overwrites the earlier upsert.`
+      });
+      continue;
+    }
+    seen.add(normalized.id);
+    declared.add(normalized.id);
+    for (const alias of normalized.aliases ?? []) {
+      declared.add(normalizeStatusToken(alias));
+    }
+  }
+  return declared;
+}
+function lintFields(profile, findings) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, field] of profile.fields.entries()) {
+    let key;
+    try {
+      key = normalizeAddFieldInput(field).key;
+    } catch (error) {
+      findings.push({
+        severity: "error",
+        code: "field_invalid",
+        dimension: "fields",
+        target: typeof field.key === "string" ? field.key : `#${index}`,
+        message: toErrorMessage(error)
+      });
+      continue;
+    }
+    if (seen.has(key)) {
+      findings.push({
+        severity: "error",
+        code: "field_duplicate",
+        dimension: "fields",
+        target: key,
+        message: `Field "${key}" is declared more than once; the later definition silently overwrites the earlier upsert.`
+      });
+      continue;
+    }
+    seen.add(key);
+  }
+}
+function lintWorkflows(profile, declaredTypes, declaredStatuses, findings) {
+  const seenTypes = /* @__PURE__ */ new Set();
+  for (const [index, workflow] of profile.workflows.entries()) {
+    const typeKey = workflow.type.trim().toLowerCase();
+    if (typeKey.length === 0) {
+      findings.push({
+        severity: "error",
+        code: "workflow_type_empty",
+        dimension: "workflows",
+        target: `#${index}`,
+        message: "Workflow has an empty type; the workflow resolver drops entries without a type."
+      });
+      continue;
+    }
+    const duplicate = seenTypes.has(typeKey);
+    seenTypes.add(typeKey);
+    if (duplicate) {
+      findings.push({
+        severity: "warning",
+        code: "workflow_duplicate_type",
+        dimension: "workflows",
+        target: workflow.type,
+        message: `Workflow type "${workflow.type}" is declared more than once; the later transition set wins.`
+      });
+    } else if (!BUILTIN_TYPE_KEYS.has(typeKey) && !declaredTypes.has(typeKey)) {
+      findings.push({
+        severity: "warning",
+        code: "workflow_type_unknown",
+        dimension: "workflows",
+        target: workflow.type,
+        message: `Workflow governs type "${workflow.type}" which is neither a built-in type nor declared by this profile; it has no effect unless that type already exists.`
+      });
+    }
+    const reportedUnknownStatuses = /* @__PURE__ */ new Set();
+    for (const pair of workflow.allowed_transitions) {
+      const from = normalizeStatusToken(pair[0]);
+      const to = normalizeStatusToken(pair[1]);
+      if (from.length === 0 || to.length === 0) {
+        findings.push({
+          severity: "error",
+          code: "workflow_transition_malformed",
+          dimension: "workflows",
+          target: workflow.type,
+          message: `Workflow "${workflow.type}" has a transition with an empty status; the workflow resolver silently drops it.`
+        });
+        continue;
+      }
+      for (const token of [from, to]) {
+        if (BUILTIN_STATUS_TOKENS.has(token) || declaredStatuses.has(token) || reportedUnknownStatuses.has(token)) {
+          continue;
+        }
+        reportedUnknownStatuses.add(token);
+        findings.push({
+          severity: "warning",
+          code: "workflow_status_unknown",
+          dimension: "workflows",
+          target: token,
+          message: `Workflow "${workflow.type}" references status "${token}" which is neither a built-in status nor declared by this profile; transitions to or from it are unreachable.`
+        });
+      }
+    }
+  }
+}
+function lintConfig(profile, findings) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of profile.config) {
+    const descriptor = resolveNestedSettingDescriptor(entry.key);
+    if (descriptor === void 0) {
+      findings.push({
+        severity: "error",
+        code: "config_key_unknown",
+        dimension: "config",
+        target: entry.key,
+        message: `Config knob "${entry.key}" is not a recognized setting; apply rejects it with a usage error.`
+      });
+      continue;
+    }
+    if (seen.has(descriptor.key)) {
+      findings.push({
+        severity: "error",
+        code: "config_duplicate",
+        dimension: "config",
+        target: descriptor.key,
+        message: `Config knob "${descriptor.key}" is set more than once; the later value silently overwrites the earlier one.`
+      });
+    } else {
+      seen.add(descriptor.key);
+    }
+    const parsed = parseNestedSettingValue(descriptor, entry.value);
+    if (!parsed.ok) {
+      findings.push({
+        severity: "error",
+        code: "config_value_invalid",
+        dimension: "config",
+        target: entry.key,
+        message: parsed.error.message
+      });
+    }
+  }
+}
+function lintTemplates(profile, declaredTypes, findings) {
+  for (const template of profile.templates) {
+    const typeOption = template.options.type;
+    if (typeof typeOption !== "string" || typeOption.trim().length === 0) {
+      continue;
+    }
+    const typeKey = typeOption.trim().toLowerCase();
+    if (!BUILTIN_TYPE_KEYS.has(typeKey) && !declaredTypes.has(typeKey)) {
+      findings.push({
+        severity: "warning",
+        code: "template_type_unknown",
+        dimension: "templates",
+        target: template.name,
+        message: `Template "${template.name}" creates type "${typeOption}" which is neither a built-in type nor declared by this profile.`
+      });
+    }
+  }
+}
+function lintPackages(profile, findings) {
+  for (const [index, recommendation] of profile.packages.entries()) {
+    if (recommendation.spec.trim().length === 0) {
+      findings.push({
+        severity: "warning",
+        code: "package_spec_empty",
+        dimension: "packages",
+        target: `#${index}`,
+        message: "Package recommendation has an empty spec; it cannot be surfaced as an install hint."
+      });
+    }
+  }
+}
+function lintProjectProfile(profile) {
+  const findings = [];
+  lintProfileIdentity(profile, findings);
+  const declaredTypes = lintTypes(profile, findings);
+  const declaredStatuses = lintStatuses(profile, findings);
+  lintFields(profile, findings);
+  lintWorkflows(profile, declaredTypes, declaredStatuses, findings);
+  lintConfig(profile, findings);
+  lintTemplates(profile, declaredTypes, findings);
+  lintPackages(profile, findings);
+  const errorCount = findings.filter((finding) => finding.severity === "error").length;
+  const warningCount = findings.length - errorCount;
+  return {
+    profile: profile.name,
+    ok: errorCount === 0,
+    findings,
+    errorCount,
+    warningCount
+  };
+}
+
+// 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);
+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
+  };
+}
+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 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
+  };
+}
+
+// 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 runProfileApply(name, options, global) {
+  const pmRoot = resolvePmRoot(process.cwd(), global.path);
+  if (!await pathExists(getSettingsPath(pmRoot))) {
+    throw new PmCliError(`Tracker is not initialized at ${pmRoot}. Run pm init first.`, EXIT_CODE.NOT_FOUND);
+  }
+  let profile;
+  const mergeWarnings = [];
+  try {
+    const entry = resolveProfileEntry(name, collectExtensionProfileContributions());
+    profile = entry.resolved.definition;
+    mergeWarnings.push(...entry.warnings);
+  } catch (error) {
+    throw new PmCliError(error instanceof Error ? error.message : String(error), EXIT_CODE.USAGE);
+  }
+  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));
+  };
+  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 {
+  PROFILE_SUBCOMMANDS,
+  formatProfileApplyHuman,
+  formatProfileLintHuman,
+  formatProfileListHuman,
+  formatProfileShowHuman,
+  runProfileApply,
+  runProfileLint,
+  runProfileList,
+  runProfileShow
+};
+//# sourceMappingURL=profile-QLER5ENE.js.map
+
+//# debugId=772b3e4a-0a59-501b-a0fa-0a6596a9a1fb