@unbrained/pm-cli 2026.7.6 → 2026.7.8

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

@@ -1,1932 +0,0 @@
-
-!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]="d4ede2fb-7525-501d-a1f0-77276019f794")}catch(e){}}();
-import {
-  DEFAULT_RUNTIME_SCHEMA_FILE_PATHS,
-  GOVERNANCE_PRESET_DEFAULTS,
-  GOVERNANCE_PRESET_VALUES,
-  RUNTIME_FIELD_COMMAND_VALUES,
-  RUNTIME_FIELD_TYPE_VALUES,
-  RUNTIME_STATUS_ROLE_VALUES,
-  RUNTIME_UNKNOWN_FIELD_POLICY_VALUES,
-  SETTINGS_DEFAULTS,
-  ensureRuntimeSchemaFileScaffold,
-  filePathForSchemaSection,
-  getSettingsPath,
-  loadRuntimeSchemaFromOptionalFiles,
-  normalizeItemTypeDefinition,
-  normalizeRuntimeSchemaSettings,
-  readFileIfExists,
-  runCommandHandler,
-  runCommandOverride,
-  runOnIndexHooks,
-  runOnReadHooks,
-  runOnWriteHooks,
-  runParserOverride,
-  runPreflightOverride,
-  runRendererOverride,
-  runServiceOverride,
-  runServiceOverrideSync,
-  writeFileAtomic
-} from "./chunk-57NWPFF2.js";
-
-// dist/core/extensions/index.js
-var activeExtensionHooks = null;
-var activeExtensionCommands = null;
-var activeExtensionParsers = null;
-var activeExtensionPreflight = null;
-var activeExtensionServices = null;
-var activeExtensionRenderers = null;
-var activeExtensionRegistrations = null;
-var activeCommandContext = null;
-var activeCommandResult = void 0;
-var activeAfterCommandAffectedItems = [];
-var AFTER_COMMAND_SNAPSHOT_OMITTED_FIELDS = /* @__PURE__ */ new Set([
-  "body",
-  "comments",
-  "dependencies",
-  "docs",
-  "events",
-  "files",
-  "learnings",
-  "notes",
-  "reminders",
-  "test_runs",
-  "tests"
-]);
-function setActiveExtensionHooks(hooks) {
-  activeExtensionHooks = hooks;
-}
-function setActiveExtensionCommands(commands) {
-  activeExtensionCommands = commands;
-}
-function setActiveExtensionParsers(parsers) {
-  activeExtensionParsers = parsers;
-}
-function setActiveExtensionPreflight(preflight) {
-  activeExtensionPreflight = preflight;
-}
-function setActiveExtensionServices(services) {
-  activeExtensionServices = services;
-}
-function setActiveExtensionRenderers(renderers) {
-  activeExtensionRenderers = renderers;
-}
-function setActiveExtensionRegistrations(registrations) {
-  activeExtensionRegistrations = registrations;
-}
-function getActiveExtensionRegistrations() {
-  return activeExtensionRegistrations;
-}
-function setActiveCommandContext(context) {
-  activeCommandContext = context;
-}
-function setActiveCommandResult(result) {
-  activeCommandResult = result;
-}
-function getActiveCommandResult() {
-  return activeCommandResult;
-}
-function recordAfterCommandAffectedItem(item) {
-  if (!item || (activeExtensionHooks?.afterCommand?.length ?? 0) === 0) {
-    return;
-  }
-  activeAfterCommandAffectedItems.push(item);
-}
-function projectAfterCommandItemSnapshot(metadata, changedFields) {
-  if (!metadata || !metadata.id) {
-    return {};
-  }
-  const snapshot = {
-    id: metadata.id,
-    type: metadata.type,
-    status: metadata.status
-  };
-  if (!Array.isArray(changedFields)) {
-    return snapshot;
-  }
-  const source = metadata;
-  for (const field of changedFields) {
-    if (typeof field !== "string") {
-      continue;
-    }
-    const actualField = field.startsWith("unset:") ? field.slice("unset:".length) : field;
-    if (actualField === "id" || actualField === "type" || actualField === "status" || AFTER_COMMAND_SNAPSHOT_OMITTED_FIELDS.has(actualField)) {
-      continue;
-    }
-    if (Object.hasOwn(source, actualField) && source[actualField] !== void 0) {
-      snapshot[actualField] = source[actualField];
-    }
-  }
-  return snapshot;
-}
-function consumeAfterCommandAffectedItems() {
-  if (activeAfterCommandAffectedItems.length === 0) {
-    return void 0;
-  }
-  const affected = activeAfterCommandAffectedItems;
-  activeAfterCommandAffectedItems = [];
-  return affected;
-}
-function clearActiveExtensionHooks() {
-  activeExtensionHooks = null;
-  activeExtensionCommands = null;
-  activeExtensionParsers = null;
-  activeExtensionPreflight = null;
-  activeExtensionServices = null;
-  activeExtensionRenderers = null;
-  activeExtensionRegistrations = null;
-  activeCommandContext = null;
-  activeCommandResult = void 0;
-  activeAfterCommandAffectedItems = [];
-}
-async function runActiveOnWriteHooks(context) {
-  if (!activeExtensionHooks) {
-    return [];
-  }
-  return runOnWriteHooks(activeExtensionHooks, context);
-}
-async function runActiveOnReadHooks(context) {
-  if (!activeExtensionHooks) {
-    return [];
-  }
-  return runOnReadHooks(activeExtensionHooks, context);
-}
-function hasActiveOnReadHooks() {
-  return (activeExtensionHooks?.onRead?.length ?? 0) > 0;
-}
-async function runActiveOnIndexHooks(context) {
-  if (!activeExtensionHooks) {
-    return [];
-  }
-  return runOnIndexHooks(activeExtensionHooks, context);
-}
-function runActiveCommandOverride(result) {
-  if (!activeExtensionCommands || !activeCommandContext) {
-    return {
-      overridden: false,
-      result,
-      warnings: []
-    };
-  }
-  return runCommandOverride(activeExtensionCommands, {
-    command: activeCommandContext.command,
-    args: [...activeCommandContext.args],
-    options: activeCommandContext.options ? { ...activeCommandContext.options } : {},
-    global: activeCommandContext.global ? { ...activeCommandContext.global } : void 0,
-    pm_root: activeCommandContext.pm_root,
-    result
-  });
-}
-async function runActiveCommandHandler(context) {
-  if (!activeExtensionCommands) {
-    return {
-      handled: false,
-      result: null,
-      warnings: []
-    };
-  }
-  return runCommandHandler(activeExtensionCommands, context);
-}
-async function runActiveParserOverride(context) {
-  if (!activeExtensionParsers) {
-    return {
-      overridden: false,
-      context: {
-        command: context.command,
-        args: [...context.args],
-        options: { ...context.options },
-        global: { ...context.global },
-        pm_root: context.pm_root
-      },
-      warnings: []
-    };
-  }
-  return runParserOverride(activeExtensionParsers, context);
-}
-async function runActivePreflightOverride(context) {
-  if (!activeExtensionPreflight) {
-    return {
-      overridden: false,
-      context: {
-        command: context.command,
-        args: [...context.args],
-        options: { ...context.options },
-        global: { ...context.global },
-        pm_root: context.pm_root
-      },
-      decision: { ...context.decision },
-      warnings: []
-    };
-  }
-  return runPreflightOverride(activeExtensionPreflight, context);
-}
-function runActiveRendererOverride(format, result) {
-  if (!activeExtensionRenderers) {
-    return {
-      overridden: false,
-      rendered: null,
-      warnings: []
-    };
-  }
-  return runRendererOverride(activeExtensionRenderers, {
-    format,
-    command: activeCommandContext?.command,
-    args: activeCommandContext ? [...activeCommandContext.args] : [],
-    options: activeCommandContext?.options ? { ...activeCommandContext.options } : {},
-    global: activeCommandContext?.global ? { ...activeCommandContext.global } : void 0,
-    pm_root: activeCommandContext?.pm_root,
-    result
-  });
-}
-function buildServiceContext(service, payload) {
-  return {
-    service,
-    command: activeCommandContext?.command,
-    args: activeCommandContext ? [...activeCommandContext.args] : [],
-    options: activeCommandContext?.options ? { ...activeCommandContext.options } : {},
-    global: activeCommandContext?.global ? { ...activeCommandContext.global } : void 0,
-    pm_root: activeCommandContext?.pm_root,
-    payload
-  };
-}
-async function runActiveServiceOverride(service, payload) {
-  if (!activeExtensionServices) {
-    return {
-      handled: false,
-      result: payload,
-      warnings: []
-    };
-  }
-  return runServiceOverride(activeExtensionServices, buildServiceContext(service, payload));
-}
-function runActiveServiceOverrideSync(service, payload) {
-  if (!activeExtensionServices) {
-    return {
-      handled: false,
-      result: payload,
-      warnings: []
-    };
-  }
-  return runServiceOverrideSync(activeExtensionServices, buildServiceContext(service, payload));
-}
-
-// dist/core/shared/errors.js
-var PmCliError = class extends Error {
-  exitCode;
-  context;
-  constructor(message, exitCode, context = {}) {
-    super(message);
-    this.name = "PmCliError";
-    this.exitCode = exitCode;
-    this.context = context;
-  }
-};
-
-// dist/core/shared/serialization.js
-import crypto from "node:crypto";
-function sortScalarValue(value) {
-  if (value === null)
-    return null;
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return value;
-  }
-  if (typeof value === "bigint") {
-    return value.toString();
-  }
-  if (value === void 0) {
-    return "undefined";
-  }
-  if (typeof value === "symbol") {
-    return value.toString();
-  }
-  if (typeof value === "function") {
-    return `[function:${value.name || "anonymous"}]`;
-  }
-  return void 0;
-}
-function sortPlainObjectKeys(value) {
-  const sortedKeys = Object.keys(value).sort();
-  const result = {};
-  for (const key of sortedKeys) {
-    const nested = value[key];
-    if (nested === void 0) {
-      continue;
-    }
-    result[key] = sortObjectKeys(nested);
-  }
-  return result;
-}
-function sortObjectKeys(value) {
-  const scalarValue = sortScalarValue(value);
-  if (scalarValue !== void 0) {
-    return scalarValue;
-  }
-  if (Array.isArray(value)) {
-    return value.map((entry) => sortObjectKeys(entry));
-  }
-  if (value instanceof Date) {
-    return value.toISOString();
-  }
-  const maybeJson = value;
-  if (typeof maybeJson.toJSON === "function") {
-    const normalized = maybeJson.toJSON();
-    if (normalized !== value) {
-      return sortObjectKeys(normalized);
-    }
-  }
-  return sortPlainObjectKeys(value);
-}
-function stableStringify(value) {
-  return JSON.stringify(sortObjectKeys(value));
-}
-function hasUnmatchedEquivalent(leftValue, rightValues, matchedIndexes, equals) {
-  for (let index = 0; index < rightValues.length; index += 1) {
-    if (matchedIndexes.has(index)) {
-      continue;
-    }
-    if (equals(leftValue, rightValues[index])) {
-      matchedIndexes.add(index);
-      return true;
-    }
-  }
-  return false;
-}
-function compareRegExpValues(left, right) {
-  if (!(left instanceof RegExp || right instanceof RegExp)) {
-    return void 0;
-  }
-  return left instanceof RegExp && right instanceof RegExp && left.toString() === right.toString();
-}
-function compareDateValues(left, right) {
-  if (!(left instanceof Date || right instanceof Date)) {
-    return void 0;
-  }
-  return left instanceof Date && right instanceof Date && left.getTime() === right.getTime();
-}
-function compareSetValues(left, right) {
-  if (!(left instanceof Set || right instanceof Set)) {
-    return void 0;
-  }
-  if (!(left instanceof Set && right instanceof Set) || left.size !== right.size) {
-    return false;
-  }
-  const rightValues = [...right];
-  const matched = /* @__PURE__ */ new Set();
-  for (const leftValue of left) {
-    if (!hasUnmatchedEquivalent(leftValue, rightValues, matched, stableValueEquals)) {
-      return false;
-    }
-  }
-  return true;
-}
-function compareMapValues(left, right) {
-  if (!(left instanceof Map || right instanceof Map)) {
-    return void 0;
-  }
-  if (!(left instanceof Map && right instanceof Map) || left.size !== right.size) {
-    return false;
-  }
-  const rightEntries = [...right.entries()];
-  const matched = /* @__PURE__ */ new Set();
-  for (const [leftKey, leftValue] of left.entries()) {
-    const leftEntry = [leftKey, leftValue];
-    if (!hasUnmatchedEquivalent(leftEntry, rightEntries, matched, ([candidateKey, candidateValue], [rightKey, rightValue]) => stableValueEquals(candidateKey, rightKey) && stableValueEquals(candidateValue, rightValue))) {
-      return false;
-    }
-  }
-  return true;
-}
-function compareArrayValues(left, right) {
-  if (!(Array.isArray(left) || Array.isArray(right))) {
-    return void 0;
-  }
-  if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) {
-    return false;
-  }
-  return left.every((value, index) => stableValueEquals(value, right[index]));
-}
-function comparePlainObjectValues(left, right) {
-  const leftKeys = Object.keys(left).sort((a, b) => a.localeCompare(b));
-  const rightKeys = Object.keys(right).sort((a, b) => a.localeCompare(b));
-  if (leftKeys.length !== rightKeys.length) {
-    return false;
-  }
-  for (let index = 0; index < leftKeys.length; index += 1) {
-    const leftKey = leftKeys[index];
-    if (leftKey !== rightKeys[index]) {
-      return false;
-    }
-    if (!stableValueEquals(left[leftKey], right[leftKey])) {
-      return false;
-    }
-  }
-  return true;
-}
-var SPECIALIZED_STABLE_VALUE_COMPARISONS = [
-  compareRegExpValues,
-  compareDateValues,
-  compareSetValues,
-  compareMapValues,
-  compareArrayValues
-];
-function stableValueEquals(left, right) {
-  if (Object.is(left, right)) {
-    return true;
-  }
-  if (left === null || right === null || typeof left !== "object" || typeof right !== "object") {
-    return false;
-  }
-  for (const compare of SPECIALIZED_STABLE_VALUE_COMPARISONS) {
-    const result = compare(left, right);
-    if (result !== void 0) {
-      return result;
-    }
-  }
-  return comparePlainObjectValues(left, right);
-}
-function sha256Hex(value) {
-  return crypto.createHash("sha256").update(value, "utf8").digest("hex");
-}
-function orderObject(value, keyOrder) {
-  const ordered = {};
-  for (const key of keyOrder) {
-    const entry = value[key];
-    if (entry !== void 0) {
-      ordered[key] = entry;
-    }
-  }
-  const unknownKeys = Object.keys(value).filter((key) => !keyOrder.includes(key)).sort((a, b) => a.localeCompare(b));
-  for (const key of unknownKeys) {
-    const entry = value[key];
-    if (entry !== void 0) {
-      ordered[key] = entry;
-    }
-  }
-  return ordered;
-}
-
-// dist/core/store/settings-validator.js
-var FAIL = { ok: false };
-var vString = (input) => typeof input === "string" ? { ok: true, value: input } : FAIL;
-var vBoolean = (input) => typeof input === "boolean" ? { ok: true, value: input } : FAIL;
-function vNumber(options = {}) {
-  return (input) => {
-    if (typeof input !== "number" || !Number.isFinite(input)) {
-      return FAIL;
-    }
-    if (options.int && (!Number.isInteger(input) || !Number.isSafeInteger(input))) {
-      return FAIL;
-    }
-    if (options.positive && input <= 0) {
-      return FAIL;
-    }
-    if (typeof options.min === "number" && input < options.min) {
-      return FAIL;
-    }
-    return { ok: true, value: input };
-  };
-}
-function vLiteral(...allowed) {
-  return (input) => typeof input === "string" && allowed.includes(input) ? { ok: true, value: input } : FAIL;
-}
-function vArray(item) {
-  return (input) => {
-    if (!Array.isArray(input)) {
-      return FAIL;
-    }
-    const value = [];
-    for (const element of input) {
-      const result = item(element);
-      if (!result.ok) {
-        return FAIL;
-      }
-      value.push(result.value);
-    }
-    return { ok: true, value };
-  };
-}
-function vOptional(inner) {
-  return (input) => input === void 0 ? { ok: true, value: void 0 } : inner(input);
-}
-function vRecordOf(valueCheck) {
-  return (input) => {
-    if (typeof input !== "object" || input === null || Array.isArray(input)) {
-      return FAIL;
-    }
-    const value = {};
-    for (const [key, raw] of Object.entries(input)) {
-      const result = valueCheck(raw);
-      if (!result.ok) {
-        return FAIL;
-      }
-      value[key] = result.value;
-    }
-    return { ok: true, value };
-  };
-}
-function vObject(shape) {
-  return (input) => {
-    if (typeof input !== "object" || input === null || Array.isArray(input)) {
-      return FAIL;
-    }
-    const record = input;
-    const value = {};
-    for (const [key, check] of Object.entries(shape)) {
-      const result = check(record[key]);
-      if (!result.ok) {
-        return FAIL;
-      }
-      if (result.value !== void 0) {
-        value[key] = result.value;
-      }
-    }
-    return { ok: true, value };
-  };
-}
-var itemTypeOption = vObject({
-  key: vString,
-  values: vArray(vString),
-  required: vOptional(vBoolean),
-  aliases: vOptional(vArray(vString)),
-  description: vOptional(vString)
-});
-var itemTypeCommandOptionPolicy = vObject({
-  command: vLiteral("create", "update"),
-  option: vString,
-  required: vOptional(vBoolean),
-  visible: vOptional(vBoolean),
-  enabled: vOptional(vBoolean)
-});
-var itemTypeDefinition = vObject({
-  name: vString,
-  description: vOptional(vString),
-  // Per-type create-time default status (config-driven); preserved so inline
-  // settings.item_types.definitions behave identically to schema/types.json.
-  default_status: vOptional(vString),
-  folder: vOptional(vString),
-  aliases: vOptional(vArray(vString)),
-  required_create_fields: vOptional(vArray(vString)),
-  required_create_repeatables: vOptional(vArray(vString)),
-  options: vOptional(vArray(itemTypeOption)),
-  command_option_policies: vOptional(vArray(itemTypeCommandOptionPolicy))
-});
-var runtimeStatusDefinition = vObject({
-  id: vString,
-  aliases: vOptional(vArray(vString)),
-  roles: vOptional(vArray(vLiteral(...RUNTIME_STATUS_ROLE_VALUES))),
-  description: vOptional(vString),
-  order: vOptional(vNumber())
-});
-var runtimeFieldDefinition = vObject({
-  key: vString,
-  metadata_key: vOptional(vString),
-  front_matter_key: vOptional(vString),
-  cli_flag: vOptional(vString),
-  cli_aliases: vOptional(vArray(vString)),
-  description: vOptional(vString),
-  type: vOptional(vLiteral(...RUNTIME_FIELD_TYPE_VALUES)),
-  commands: vOptional(vArray(vLiteral(...RUNTIME_FIELD_COMMAND_VALUES))),
-  repeatable: vOptional(vBoolean),
-  required: vOptional(vBoolean),
-  required_on_create: vOptional(vBoolean),
-  required_types: vOptional(vArray(vString)),
-  allow_unset: vOptional(vBoolean)
-});
-var statusTransitionPair = (input) => {
-  if (!Array.isArray(input) || input.length !== 2) {
-    return FAIL;
-  }
-  const [from, to] = input;
-  if (typeof from !== "string" || typeof to !== "string") {
-    return FAIL;
-  }
-  return { ok: true, value: [from, to] };
-};
-var typeWorkflowDefinition = vObject({
-  type: vString,
-  allowed_transitions: vArray(statusTransitionPair)
-});
-var runtimeSchemaSettings = vOptional(vObject({
-  version: vOptional(vNumber({ int: true })),
-  files: vOptional(vObject({
-    types: vOptional(vString),
-    statuses: vOptional(vString),
-    fields: vOptional(vString),
-    workflows: vOptional(vString)
-  })),
-  statuses: vOptional(vArray(runtimeStatusDefinition)),
-  fields: vOptional(vArray(runtimeFieldDefinition)),
-  workflow: vOptional(vObject({
-    draft_status: vOptional(vString),
-    open_status: vOptional(vString),
-    in_progress_status: vOptional(vString),
-    blocked_status: vOptional(vString),
-    close_status: vOptional(vString),
-    canceled_status: vOptional(vString)
-  })),
-  type_workflows: vOptional(vArray(typeWorkflowDefinition)),
-  unknown_field_policy: vOptional(vLiteral(...RUNTIME_UNKNOWN_FIELD_POLICY_VALUES))
-}));
-var governanceSettings = vOptional(vObject({
-  preset: vOptional(vLiteral(...GOVERNANCE_PRESET_VALUES)),
-  ownership_enforcement: vOptional(vLiteral("none", "warn", "strict")),
-  create_mode_default: vOptional(vLiteral("progressive", "strict")),
-  close_validation_default: vOptional(vLiteral("off", "warn", "strict")),
-  require_close_reason: vOptional(vBoolean),
-  parent_reference: vOptional(vLiteral("warn", "strict_error")),
-  metadata_profile: vOptional(vLiteral("core", "strict", "custom")),
-  force_required_for_stale_lock: vOptional(vBoolean),
-  create_default_type: vOptional(vString),
-  workflow_enforcement: vOptional(vLiteral("off", "warn", "strict"))
-}));
-var extensionPolicyOverride = vObject({
-  name: vString,
-  disabled: vOptional(vBoolean),
-  require_trusted: vOptional(vBoolean),
-  require_provenance: vOptional(vBoolean),
-  sandbox_profile: vOptional(vLiteral("none", "restricted", "strict")),
-  allowed_capabilities: vOptional(vArray(vString)),
-  blocked_capabilities: vOptional(vArray(vString)),
-  allowed_surfaces: vOptional(vArray(vString)),
-  blocked_surfaces: vOptional(vArray(vString)),
-  allowed_commands: vOptional(vArray(vString)),
-  blocked_commands: vOptional(vArray(vString)),
-  allowed_actions: vOptional(vArray(vString)),
-  blocked_actions: vOptional(vArray(vString)),
-  allowed_services: vOptional(vArray(vString)),
-  blocked_services: vOptional(vArray(vString))
-});
-var pmMaxVersionExceededModeLiteral = vLiteral("block", "warn");
-var pmMaxVersionExceededMode = (input) => typeof input === "string" ? pmMaxVersionExceededModeLiteral(input) : vObject({
-  global: vOptional(pmMaxVersionExceededModeLiteral),
-  project: vOptional(pmMaxVersionExceededModeLiteral)
-})(input);
-var extensionPolicy = vOptional(vObject({
-  mode: vOptional(vLiteral("off", "warn", "enforce")),
-  trust_mode: vOptional(vLiteral("off", "warn", "enforce")),
-  pm_max_version_exceeded_mode: vOptional(pmMaxVersionExceededMode),
-  require_provenance: vOptional(vBoolean),
-  trusted_extensions: vOptional(vArray(vString)),
-  default_sandbox_profile: vOptional(vLiteral("none", "restricted", "strict")),
-  allowed_extensions: vOptional(vArray(vString)),
-  blocked_extensions: vOptional(vArray(vString)),
-  allowed_capabilities: vOptional(vArray(vString)),
-  blocked_capabilities: vOptional(vArray(vString)),
-  allowed_surfaces: vOptional(vArray(vString)),
-  blocked_surfaces: vOptional(vArray(vString)),
-  allowed_commands: vOptional(vArray(vString)),
-  blocked_commands: vOptional(vArray(vString)),
-  allowed_actions: vOptional(vArray(vString)),
-  blocked_actions: vOptional(vArray(vString)),
-  allowed_services: vOptional(vArray(vString)),
-  blocked_services: vOptional(vArray(vString)),
-  extension_overrides: vOptional(vArray(extensionPolicyOverride))
-}));
-var settingsCheck = vObject({
-  version: vNumber({ int: true }),
-  id_prefix: vString,
-  author_default: vString,
-  item_format: vOptional(vLiteral("toon", "json_markdown")),
-  locks: vObject({ ttl_seconds: vNumber({ int: true }), wait_ms: vOptional(vNumber({ int: true, min: 0 })) }),
-  checkpoints: vOptional(vObject({ retention_days: vOptional(vNumber({ int: true, positive: true })) })),
-  output: vObject({ default_format: vLiteral("toon", "json") }),
-  history: vOptional(vObject({
-    missing_stream: vLiteral("auto_create", "strict_error"),
-    compact_policy: vOptional(vObject({
-      enabled: vOptional(vBoolean),
-      max_entries: vOptional(vNumber({ int: true, positive: true })),
-      trigger: vOptional(vLiteral("health_warn", "auto"))
-    }))
-  })),
-  validation: vOptional(vObject({
-    sprint_release_format: vLiteral("warn", "strict_error"),
-    parent_reference: vOptional(vLiteral("warn", "strict_error")),
-    metadata_profile: vOptional(vLiteral("core", "strict", "custom")),
-    metadata_required_fields: vOptional(vArray(vString)),
-    lifecycle_stale_blocker_reason_patterns: vOptional(vArray(vString)),
-    lifecycle_closure_like_blocked_reason_patterns: vOptional(vArray(vString)),
-    lifecycle_closure_like_resolution_patterns: vOptional(vArray(vString)),
-    lifecycle_closure_like_actual_result_patterns: vOptional(vArray(vString)),
-    estimate_defaults_by_type: vOptional(vRecordOf(vNumber({ int: true, positive: true })))
-  })),
-  governance: governanceSettings,
-  workflow: vOptional(vObject({ definition_of_done: vArray(vString) })),
-  testing: vOptional(vObject({ record_results_to_items: vBoolean })),
-  telemetry: vOptional(vObject({
-    enabled: vBoolean,
-    first_run_prompt_completed: vOptional(vBoolean),
-    capture_level: vOptional(vLiteral("minimal", "redacted", "max")),
-    endpoint: vOptional(vString),
-    installation_id: vOptional(vString),
-    retention_days: vOptional(vNumber({ int: true, positive: true }))
-  })),
-  agent_guidance: vOptional(vObject({
-    prompt_completed: vOptional(vBoolean),
-    declined: vOptional(vBoolean),
-    declined_at: vOptional(vString),
-    template_version: vOptional(vNumber({ int: true, positive: true })),
-    last_checked_files: vOptional(vArray(vString))
-  })),
-  item_types: vOptional(vObject({ definitions: vArray(itemTypeDefinition) })),
-  schema: runtimeSchemaSettings,
-  context: vOptional(vObject({
-    default_depth: vOptional(vLiteral("brief", "standard", "deep")),
-    activity_limit: vOptional(vNumber({ int: true, positive: true })),
-    stale_threshold_days: vOptional(vNumber({ int: true, positive: true })),
-    sections: vOptional(vObject({
-      hierarchy: vOptional(vBoolean),
-      activity: vOptional(vBoolean),
-      progress: vOptional(vBoolean),
-      recently_created: vOptional(vBoolean),
-      unparented: vOptional(vBoolean),
-      blockers: vOptional(vBoolean),
-      files: vOptional(vBoolean),
-      workload: vOptional(vBoolean),
-      staleness: vOptional(vBoolean),
-      tests: vOptional(vBoolean)
-    }))
-  })),
-  extensions: vObject({
-    enabled: vArray(vString),
-    disabled: vArray(vString),
-    policy: extensionPolicy
-  }),
-  search: vObject({
-    score_threshold: vNumber(),
-    hybrid_semantic_weight: vOptional(vNumber()),
-    max_results: vNumber({ int: true }),
-    embedding_model: vString,
-    embedding_corpus_max_characters: vOptional(vNumber()),
-    embedding_batch_size: vNumber({ int: true }),
-    embedding_timeout_ms: vOptional(vNumber({ int: true })),
-    scanner_max_batch_retries: vNumber({ int: true }),
-    provider: vOptional(vString),
-    corpus_fields: vOptional(vArray(vString)),
-    mutation_refresh_policy: vOptional(vLiteral("cache_only", "semantic_configured", "semantic_auto")),
-    query_expansion: vOptional(vObject({
-      enabled: vOptional(vBoolean),
-      provider: vOptional(vString)
-    })),
-    rerank: vOptional(vObject({
-      enabled: vOptional(vBoolean),
-      model: vOptional(vString),
-      top_k: vOptional(vNumber({ int: true, positive: true }))
-    })),
-    // pm-75k9: offline BM25 tuning. Unlike `search.tuning` (intentionally
-    // stripped for legacy zod parity), bm25 is validated so it persists across
-    // writeSettings round-trips — these knobs must survive to take effect.
-    bm25: vOptional(vObject({
-      k1: vOptional(vNumber()),
-      b: vOptional(vNumber())
-    }))
-  }),
-  providers: vObject({
-    openai: vObject({ base_url: vString, api_key: vString, model: vString }),
-    ollama: vObject({ base_url: vString, model: vString })
-  }),
-  vector_store: vObject({
-    adapter: vOptional(vString),
-    collection_name: vOptional(vString),
-    qdrant: vObject({ url: vString, api_key: vString }),
-    lancedb: vObject({ path: vString })
-  })
-});
-function validateSettings(raw) {
-  const result = settingsCheck(raw);
-  if (!result.ok) {
-    return { success: false };
-  }
-  return { success: true, data: result.value };
-}
-
-// dist/core/validate/estimate-defaults.js
-var DEFAULT_ESTIMATE_MINUTES_BY_TYPE = {
-  Epic: 2880,
-  Feature: 480,
-  Story: 480,
-  Milestone: 2880,
-  Task: 120,
-  Issue: 60,
-  Bug: 60,
-  Chore: 30,
-  Decision: 15,
-  Plan: 120
-};
-var FALLBACK_ESTIMATE_MINUTES = 120;
-function isHonoredMinutes(value) {
-  return typeof value === "number" && Number.isFinite(value) && value > 0;
-}
-function toLowercasedLookup(source) {
-  const lookup = /* @__PURE__ */ new Map();
-  for (const [key, value] of Object.entries(source)) {
-    lookup.set(key.toLowerCase(), value);
-  }
-  return lookup;
-}
-var BUILTIN_LOWERCASED_LOOKUP = toLowercasedLookup(DEFAULT_ESTIMATE_MINUTES_BY_TYPE);
-var OVERRIDE_LOOKUP_CACHE = /* @__PURE__ */ new WeakMap();
-function lowercasedOverrideLookup(overrides) {
-  const cached = OVERRIDE_LOOKUP_CACHE.get(overrides);
-  if (cached) {
-    return cached;
-  }
-  const lookup = toLowercasedLookup(overrides);
-  OVERRIDE_LOOKUP_CACHE.set(overrides, lookup);
-  return lookup;
-}
-function resolveEstimateDefaultMinutes(type, overrides) {
-  const key = (type ?? "").trim().toLowerCase();
-  if (key.length === 0) {
-    return FALLBACK_ESTIMATE_MINUTES;
-  }
-  if (overrides) {
-    const overrideValue = lowercasedOverrideLookup(overrides).get(key);
-    if (isHonoredMinutes(overrideValue)) {
-      return Math.floor(overrideValue);
-    }
-  }
-  const builtinValue = BUILTIN_LOWERCASED_LOOKUP.get(key);
-  if (isHonoredMinutes(builtinValue)) {
-    return Math.floor(builtinValue);
-  }
-  return FALLBACK_ESTIMATE_MINUTES;
-}
-function normalizeEstimateDefaultOverrides(raw) {
-  const normalized = {};
-  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    return normalized;
-  }
-  for (const [rawKey, rawValue] of Object.entries(raw)) {
-    const key = rawKey.trim();
-    if (key.length === 0 || !isHonoredMinutes(rawValue)) {
-      continue;
-    }
-    normalized[key] = Math.floor(rawValue);
-  }
-  return normalized;
-}
-
-// dist/core/store/settings-read-cache.js
-import { stat } from "node:fs/promises";
-var settingsReadCacheByRoot = /* @__PURE__ */ new Map();
-function normalizeTrackedPaths(paths) {
-  return [...new Set(paths.map((pathValue) => pathValue.trim()).filter((pathValue) => pathValue.length > 0))].sort((left, right) => left.localeCompare(right));
-}
-async function readPathSignature(targetPath) {
-  try {
-    const targetStats = await stat(targetPath);
-    return {
-      path: targetPath,
-      mtime_ms: targetStats.mtimeMs,
-      size: targetStats.size
-    };
-  } catch {
-    return {
-      path: targetPath,
-      mtime_ms: null,
-      size: null
-    };
-  }
-}
-async function collectSettingsReadCacheSignatures(paths) {
-  const normalizedPaths = normalizeTrackedPaths(paths);
-  const signatures = await Promise.all(normalizedPaths.map((targetPath) => readPathSignature(targetPath)));
-  signatures.sort((left, right) => left.path.localeCompare(right.path));
-  return signatures;
-}
-function settingsReadCacheSignaturesEqual(left, right) {
-  if (left.length !== right.length) {
-    return false;
-  }
-  for (let index = 0; index < left.length; index += 1) {
-    const leftEntry = left[index];
-    const rightEntry = right[index];
-    if (leftEntry.path !== rightEntry.path || leftEntry.mtime_ms !== rightEntry.mtime_ms || leftEntry.size !== rightEntry.size) {
-      return false;
-    }
-  }
-  return true;
-}
-function getSettingsReadCacheEntry(pmRoot) {
-  return settingsReadCacheByRoot.get(pmRoot);
-}
-function setSettingsReadCacheEntry(pmRoot, entry) {
-  const normalizedTrackedPaths = normalizeTrackedPaths(entry.tracked_paths);
-  const normalizedSignatures = [...entry.signatures].map((signature) => ({
-    path: signature.path,
-    mtime_ms: signature.mtime_ms,
-    size: signature.size
-  })).sort((left, right) => left.path.localeCompare(right.path));
-  settingsReadCacheByRoot.set(pmRoot, {
-    tracked_paths: normalizedTrackedPaths,
-    signatures: normalizedSignatures,
-    value: entry.value
-  });
-}
-function clearSettingsReadCache(pmRoot) {
-  if (pmRoot) {
-    settingsReadCacheByRoot.delete(pmRoot);
-    return;
-  }
-  settingsReadCacheByRoot.clear();
-}
-
-// dist/core/store/settings.js
-var SETTINGS_WRITE_OP = "settings:write";
-var SETTINGS_PERSIST_SOURCE_SYMBOL = /* @__PURE__ */ Symbol("pm.settings.persist_source");
-var MAX_VECTOR_STORE_COLLECTION_NAME_LENGTH = 128;
-function resolveGovernanceKnobsFromPreset(preset) {
-  return structuredClone(GOVERNANCE_PRESET_DEFAULTS[preset]);
-}
-function normalizeGovernancePreset(value) {
-  if (value === "minimal" || value === "default" || value === "strict" || value === "custom") {
-    return value;
-  }
-  return SETTINGS_DEFAULTS.governance.preset;
-}
-function withGovernanceExtras(base, governance) {
-  const createDefaultType = typeof governance.create_default_type === "string" ? governance.create_default_type.trim() : void 0;
-  if (createDefaultType && createDefaultType.length > 0) {
-    base.create_default_type = createDefaultType;
-  }
-  if (governance.workflow_enforcement === "off" || governance.workflow_enforcement === "warn" || governance.workflow_enforcement === "strict") {
-    base.workflow_enforcement = governance.workflow_enforcement;
-  }
-  if (governance.require_close_reason === false) {
-    base.require_close_reason = false;
-  }
-  return base;
-}
-function normalizeGovernanceForPersist(governance) {
-  if (governance.preset === "custom") {
-    return withGovernanceExtras({
-      preset: "custom",
-      ownership_enforcement: governance.ownership_enforcement,
-      create_mode_default: governance.create_mode_default,
-      close_validation_default: governance.close_validation_default,
-      parent_reference: governance.parent_reference,
-      metadata_profile: governance.metadata_profile,
-      force_required_for_stale_lock: governance.force_required_for_stale_lock
-    }, governance);
-  }
-  return withGovernanceExtras({
-    preset: governance.preset
-  }, governance);
-}
-function resolveGovernanceExtras(rawGovernance) {
-  const createDefaultType = typeof rawGovernance.create_default_type === "string" ? rawGovernance.create_default_type.trim() : void 0;
-  const extras = {};
-  if (createDefaultType && createDefaultType.length > 0) {
-    extras.create_default_type = createDefaultType;
-  }
-  if (rawGovernance.workflow_enforcement === "off" || rawGovernance.workflow_enforcement === "warn" || rawGovernance.workflow_enforcement === "strict") {
-    extras.workflow_enforcement = rawGovernance.workflow_enforcement;
-  }
-  if (typeof rawGovernance.require_close_reason === "boolean") {
-    extras.require_close_reason = rawGovernance.require_close_reason;
-  }
-  return extras;
-}
-function resolveGovernanceKnobs(settings) {
-  const rawGovernance = settings.governance ?? {};
-  const preset = normalizeGovernancePreset(rawGovernance.preset);
-  const extras = resolveGovernanceExtras(rawGovernance);
-  if (preset === "custom") {
-    const baseline2 = resolveGovernanceKnobsFromPreset("default");
-    const requireCloseReason2 = extras.require_close_reason ?? baseline2.require_close_reason;
-    return {
-      preset,
-      ownership_enforcement: rawGovernance.ownership_enforcement ?? baseline2.ownership_enforcement,
-      create_mode_default: rawGovernance.create_mode_default ?? baseline2.create_mode_default,
-      close_validation_default: rawGovernance.close_validation_default ?? baseline2.close_validation_default,
-      parent_reference: rawGovernance.parent_reference ?? baseline2.parent_reference,
-      metadata_profile: rawGovernance.metadata_profile ?? baseline2.metadata_profile,
-      force_required_for_stale_lock: rawGovernance.force_required_for_stale_lock ?? baseline2.force_required_for_stale_lock,
-      ...extras,
-      require_close_reason: requireCloseReason2
-    };
-  }
-  const baseline = resolveGovernanceKnobsFromPreset(preset);
-  const requireCloseReason = extras.require_close_reason ?? baseline.require_close_reason;
-  return {
-    preset,
-    ...baseline,
-    ...extras,
-    require_close_reason: requireCloseReason
-  };
-}
-function cloneDefaults() {
-  return structuredClone(SETTINGS_DEFAULTS);
-}
-function normalizeSearchMutationRefreshPolicy(value) {
-  if (value === "cache_only" || value === "semantic_configured" || value === "semantic_auto") {
-    return value;
-  }
-  return SETTINGS_DEFAULTS.search.mutation_refresh_policy;
-}
-function normalizeSearchQueryExpansionEnabled(value) {
-  if (typeof value === "boolean") {
-    return value;
-  }
-  return SETTINGS_DEFAULTS.search.query_expansion.enabled;
-}
-function normalizeSearchQueryExpansionProvider(value) {
-  if (typeof value !== "string") {
-    return SETTINGS_DEFAULTS.search.query_expansion.provider;
-  }
-  return value.trim();
-}
-function normalizeSearchRerankEnabled(value) {
-  if (typeof value === "boolean") {
-    return value;
-  }
-  return SETTINGS_DEFAULTS.search.rerank.enabled;
-}
-function normalizeSearchRerankModel(value) {
-  if (typeof value !== "string") {
-    return SETTINGS_DEFAULTS.search.rerank.model;
-  }
-  return value.trim();
-}
-function normalizeSearchRerankTopK(value) {
-  if (typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value > 0) {
-    return value;
-  }
-  return SETTINGS_DEFAULTS.search.rerank.top_k;
-}
-function normalizeVectorStoreCollectionName(value) {
-  if (typeof value !== "string") {
-    return SETTINGS_DEFAULTS.vector_store.collection_name;
-  }
-  const sanitized = value.trim().replaceAll(/[^a-zA-Z0-9_-]/g, "_");
-  const truncated = sanitized.slice(0, MAX_VECTOR_STORE_COLLECTION_NAME_LENGTH);
-  return truncated.length > 0 ? truncated : SETTINGS_DEFAULTS.vector_store.collection_name;
-}
-function buildSettingsPersistSourceSnapshot(parsedSettings, runtimeSettings) {
-  const sourceSchema = parsedSettings.schema;
-  const sourceStatuses = Array.isArray(sourceSchema?.statuses) ? sourceSchema?.statuses : void 0;
-  const sourceFields = Array.isArray(sourceSchema?.fields) ? sourceSchema?.fields : void 0;
-  const sourceTypeWorkflows = Array.isArray(sourceSchema?.type_workflows) ? sourceSchema?.type_workflows : void 0;
-  return {
-    has_source_item_type_definitions: Array.isArray(parsedSettings.item_types?.definitions),
-    source_item_type_definitions: normalizeItemTypeDefinitions(parsedSettings.item_types?.definitions),
-    has_source_schema_statuses: sourceStatuses !== void 0,
-    source_schema_statuses: sourceStatuses ? structuredClone(sourceStatuses) : [],
-    has_source_schema_fields: sourceFields !== void 0,
-    source_schema_fields: sourceFields ? structuredClone(sourceFields) : [],
-    has_source_schema_type_workflows: sourceTypeWorkflows !== void 0,
-    source_schema_type_workflows: sourceTypeWorkflows ? structuredClone(sourceTypeWorkflows) : [],
-    runtime_item_type_definitions: normalizeItemTypeDefinitions(runtimeSettings.item_types?.definitions),
-    runtime_schema_statuses: structuredClone(runtimeSettings.schema.statuses),
-    runtime_schema_fields: structuredClone(runtimeSettings.schema.fields),
-    runtime_schema_type_workflows: structuredClone(runtimeSettings.schema.type_workflows ?? [])
-  };
-}
-function attachSettingsPersistSourceSnapshot(settings, source) {
-  Object.defineProperty(settings, SETTINGS_PERSIST_SOURCE_SYMBOL, {
-    value: source,
-    writable: true,
-    configurable: true,
-    enumerable: false
-  });
-}
-function getSettingsPersistSourceSnapshot(settings) {
-  const candidate = settings[SETTINGS_PERSIST_SOURCE_SYMBOL];
-  if (!candidate || typeof candidate !== "object") {
-    return void 0;
-  }
-  return candidate;
-}
-function cloneSettingsReadResult(result) {
-  const clonedSettings = structuredClone(result.settings);
-  const persistSource = getSettingsPersistSourceSnapshot(result.settings);
-  if (persistSource) {
-    attachSettingsPersistSourceSnapshot(clonedSettings, structuredClone(persistSource));
-  }
-  return {
-    settings: clonedSettings,
-    metadata: {
-      has_explicit_item_format: result.metadata.has_explicit_item_format
-    },
-    warnings: [...result.warnings]
-  };
-}
-function resolveSettingsReadTrackedPaths(pmRoot, schema, settingsPath) {
-  const normalizedSchema = normalizeRuntimeSchemaSettings(schema);
-  return [
-    settingsPath,
-    filePathForSchemaSection(pmRoot, normalizedSchema.files.types, DEFAULT_RUNTIME_SCHEMA_FILE_PATHS.types),
-    filePathForSchemaSection(pmRoot, normalizedSchema.files.statuses, DEFAULT_RUNTIME_SCHEMA_FILE_PATHS.statuses),
-    filePathForSchemaSection(pmRoot, normalizedSchema.files.fields, DEFAULT_RUNTIME_SCHEMA_FILE_PATHS.fields),
-    filePathForSchemaSection(pmRoot, normalizedSchema.files.workflows, DEFAULT_RUNTIME_SCHEMA_FILE_PATHS.workflows)
-  ];
-}
-async function cacheSettingsReadResult(pmRoot, trackedPaths, result) {
-  const signatures = await collectSettingsReadCacheSignatures(trackedPaths);
-  setSettingsReadCacheEntry(pmRoot, {
-    tracked_paths: trackedPaths,
-    signatures,
-    value: cloneSettingsReadResult(result)
-  });
-}
-async function cacheSettingsReadResultSafe(pmRoot, trackedPaths, result) {
-  try {
-    await cacheSettingsReadResult(pmRoot, trackedPaths, result);
-  } catch {
-    clearSettingsReadCache(pmRoot);
-  }
-}
-function findSettingsReadCacheSignature(signatures, targetPath) {
-  return signatures.find((signature) => signature.path === targetPath);
-}
-function selectedSettingsReadCacheSignaturesEqual(before, after, targetPaths) {
-  for (const targetPath of targetPaths) {
-    const beforeSignature = findSettingsReadCacheSignature(before, targetPath);
-    const afterSignature = findSettingsReadCacheSignature(after, targetPath);
-    if (!beforeSignature || !afterSignature || !settingsReadCacheSignaturesEqual([beforeSignature], [afterSignature])) {
-      return false;
-    }
-  }
-  return true;
-}
-async function cacheSettingsReadResultIfStable(pmRoot, trackedPaths, result, stableSignatures, stablePaths) {
-  try {
-    const currentSignatures = await collectSettingsReadCacheSignatures(trackedPaths);
-    if (!selectedSettingsReadCacheSignaturesEqual(stableSignatures, currentSignatures, stablePaths)) {
-      clearSettingsReadCache(pmRoot);
-      return;
-    }
-    setSettingsReadCacheEntry(pmRoot, {
-      tracked_paths: trackedPaths,
-      signatures: currentSignatures,
-      value: cloneSettingsReadResult(result)
-    });
-  } catch {
-    clearSettingsReadCache(pmRoot);
-  }
-}
-function resolvePersistedFileBackedSchemaSections(settings, source) {
-  const normalizedSchema = normalizeRuntimeSchemaSettings(settings.schema);
-  const currentItemTypeDefinitions = normalizeItemTypeDefinitions(settings.item_types?.definitions);
-  if (!source) {
-    return {
-      item_type_definitions: currentItemTypeDefinitions,
-      schema_statuses: normalizedSchema.statuses,
-      schema_fields: normalizedSchema.fields,
-      schema_type_workflows: normalizedSchema.type_workflows
-    };
-  }
-  const currentTypeWorkflows = normalizedSchema.type_workflows ?? [];
-  const itemTypeDefinitionsUnchanged = stableValueEquals(currentItemTypeDefinitions, source.runtime_item_type_definitions);
-  const schemaStatusesUnchanged = stableValueEquals(normalizedSchema.statuses, source.runtime_schema_statuses);
-  const schemaFieldsUnchanged = stableValueEquals(normalizedSchema.fields, source.runtime_schema_fields);
-  const schemaTypeWorkflowsUnchanged = stableValueEquals(currentTypeWorkflows, source.runtime_schema_type_workflows);
-  return {
-    item_type_definitions: itemTypeDefinitionsUnchanged ? source.has_source_item_type_definitions ? normalizeItemTypeDefinitions(source.source_item_type_definitions) : [] : currentItemTypeDefinitions,
-    schema_statuses: schemaStatusesUnchanged ? source.has_source_schema_statuses ? structuredClone(source.source_schema_statuses) : [] : normalizedSchema.statuses,
-    schema_fields: schemaFieldsUnchanged ? source.has_source_schema_fields ? structuredClone(source.source_schema_fields) : [] : normalizedSchema.fields,
-    schema_type_workflows: schemaTypeWorkflowsUnchanged ? source.has_source_schema_type_workflows ? structuredClone(source.source_schema_type_workflows) : void 0 : normalizedSchema.type_workflows
-  };
-}
-function buildFallbackSettingsReadResult(warning) {
-  return {
-    settings: cloneDefaults(),
-    metadata: {
-      has_explicit_item_format: false
-    },
-    warnings: warning ? [warning] : []
-  };
-}
-function hasExplicitItemFormat(raw) {
-  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
-    return false;
-  }
-  const itemFormat = raw.item_format;
-  return itemFormat === "toon" || itemFormat === "json_markdown";
-}
-function normalizeStringList(values) {
-  return [...new Set((values ?? []).map((value) => value.trim()).filter((value) => value.length > 0))].sort((left, right) => left.localeCompare(right));
-}
-function normalizeAgentGuidanceSettings(value) {
-  const defaults = SETTINGS_DEFAULTS.agent_guidance;
-  const templateVersion = value?.template_version;
-  return {
-    prompt_completed: value?.prompt_completed === true,
-    declined: value?.declined === true,
-    declined_at: typeof value?.declined_at === "string" ? value.declined_at : defaults.declined_at,
-    template_version: typeof templateVersion === "number" && Number.isInteger(templateVersion) && templateVersion > 0 ? templateVersion : defaults.template_version,
-    last_checked_files: normalizeStringList(value?.last_checked_files ?? defaults.last_checked_files)
-  };
-}
-function normalizeLowerStringList(values) {
-  return [...new Set((values ?? []).map((value) => value.trim().toLowerCase()).filter((value) => value.length > 0))].sort((left, right) => left.localeCompare(right));
-}
-function normalizeExtensionPolicyMode(value) {
-  if (value === "off" || value === "warn" || value === "enforce") {
-    return value;
-  }
-  return SETTINGS_DEFAULTS.extensions.policy.mode;
-}
-function normalizeExtensionTrustMode(value) {
-  if (value === "off" || value === "warn" || value === "enforce") {
-    return value;
-  }
-  return SETTINGS_DEFAULTS.extensions.policy.trust_mode;
-}
-function normalizeExtensionSandboxProfile(value) {
-  if (value === "none" || value === "restricted" || value === "strict") {
-    return value;
-  }
-  return SETTINGS_DEFAULTS.extensions.policy.default_sandbox_profile;
-}
-function normalizeExtensionPolicyOverride(override) {
-  const name = override.name.trim().toLowerCase();
-  if (name.length === 0) {
-    return null;
-  }
-  const normalized = {
-    name
-  };
-  if (override.disabled === true) {
-    normalized.disabled = true;
-  }
-  if (override.require_trusted === true) {
-    normalized.require_trusted = true;
-  }
-  if (override.require_provenance === true) {
-    normalized.require_provenance = true;
-  }
-  if (override.sandbox_profile !== void 0) {
-    normalized.sandbox_profile = normalizeExtensionSandboxProfile(override.sandbox_profile);
-  }
-  const allowedCapabilities = normalizeLowerStringList(override.allowed_capabilities);
-  const blockedCapabilities = normalizeLowerStringList(override.blocked_capabilities);
-  const allowedSurfaces = normalizeLowerStringList(override.allowed_surfaces);
-  const blockedSurfaces = normalizeLowerStringList(override.blocked_surfaces);
-  const allowedCommands = normalizeLowerStringList(override.allowed_commands);
-  const blockedCommands = normalizeLowerStringList(override.blocked_commands);
-  const allowedActions = normalizeLowerStringList(override.allowed_actions);
-  const blockedActions = normalizeLowerStringList(override.blocked_actions);
-  const allowedServices = normalizeLowerStringList(override.allowed_services);
-  const blockedServices = normalizeLowerStringList(override.blocked_services);
-  if (allowedCapabilities.length > 0) {
-    normalized.allowed_capabilities = allowedCapabilities;
-  }
-  if (blockedCapabilities.length > 0) {
-    normalized.blocked_capabilities = blockedCapabilities;
-  }
-  if (allowedSurfaces.length > 0) {
-    normalized.allowed_surfaces = allowedSurfaces;
-  }
-  if (blockedSurfaces.length > 0) {
-    normalized.blocked_surfaces = blockedSurfaces;
-  }
-  if (allowedCommands.length > 0) {
-    normalized.allowed_commands = allowedCommands;
-  }
-  if (blockedCommands.length > 0) {
-    normalized.blocked_commands = blockedCommands;
-  }
-  if (allowedActions.length > 0) {
-    normalized.allowed_actions = allowedActions;
-  }
-  if (blockedActions.length > 0) {
-    normalized.blocked_actions = blockedActions;
-  }
-  if (allowedServices.length > 0) {
-    normalized.allowed_services = allowedServices;
-  }
-  if (blockedServices.length > 0) {
-    normalized.blocked_services = blockedServices;
-  }
-  return normalized;
-}
-function normalizeExtensionPolicyOverrides(overrides) {
-  const dedupedByName = /* @__PURE__ */ new Map();
-  for (const override of overrides ?? []) {
-    const normalized = normalizeExtensionPolicyOverride(override);
-    if (!normalized) {
-      continue;
-    }
-    dedupedByName.set(normalized.name, normalized);
-  }
-  return [...dedupedByName.values()].sort((left, right) => left.name.localeCompare(right.name));
-}
-function normalizePmMaxVersionExceededModeValue(value) {
-  return value === "block" || value === "warn" ? value : void 0;
-}
-function normalizePmMaxVersionExceededModeSetting(value) {
-  if (typeof value === "string") {
-    return normalizePmMaxVersionExceededModeValue(value);
-  }
-  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-    const global = normalizePmMaxVersionExceededModeValue(value.global);
-    const project = normalizePmMaxVersionExceededModeValue(value.project);
-    if (global === void 0 && project === void 0) {
-      return void 0;
-    }
-    return {
-      ...global !== void 0 ? { global } : {},
-      ...project !== void 0 ? { project } : {}
-    };
-  }
-  return void 0;
-}
-function normalizeExtensionPolicyList(policy, key) {
-  return normalizeLowerStringList(policy?.[key] ?? SETTINGS_DEFAULTS.extensions.policy[key]);
-}
-function normalizeExtensionPolicySettings(policy) {
-  const pmMaxVersionExceededMode2 = normalizePmMaxVersionExceededModeSetting(policy?.pm_max_version_exceeded_mode);
-  return {
-    mode: normalizeExtensionPolicyMode(policy?.mode),
-    trust_mode: normalizeExtensionTrustMode(policy?.trust_mode),
-    ...pmMaxVersionExceededMode2 !== void 0 ? { pm_max_version_exceeded_mode: pmMaxVersionExceededMode2 } : {},
-    require_provenance: policy?.require_provenance === true,
-    trusted_extensions: normalizeExtensionPolicyList(policy, "trusted_extensions"),
-    default_sandbox_profile: normalizeExtensionSandboxProfile(policy?.default_sandbox_profile),
-    allowed_extensions: normalizeExtensionPolicyList(policy, "allowed_extensions"),
-    blocked_extensions: normalizeExtensionPolicyList(policy, "blocked_extensions"),
-    allowed_capabilities: normalizeExtensionPolicyList(policy, "allowed_capabilities"),
-    blocked_capabilities: normalizeExtensionPolicyList(policy, "blocked_capabilities"),
-    allowed_surfaces: normalizeExtensionPolicyList(policy, "allowed_surfaces"),
-    blocked_surfaces: normalizeExtensionPolicyList(policy, "blocked_surfaces"),
-    allowed_commands: normalizeExtensionPolicyList(policy, "allowed_commands"),
-    blocked_commands: normalizeExtensionPolicyList(policy, "blocked_commands"),
-    allowed_actions: normalizeExtensionPolicyList(policy, "allowed_actions"),
-    blocked_actions: normalizeExtensionPolicyList(policy, "blocked_actions"),
-    allowed_services: normalizeExtensionPolicyList(policy, "allowed_services"),
-    blocked_services: normalizeExtensionPolicyList(policy, "blocked_services"),
-    extension_overrides: normalizeExtensionPolicyOverrides(policy?.extension_overrides ?? SETTINGS_DEFAULTS.extensions.policy.extension_overrides)
-  };
-}
-function normalizeValidationMetadataRequiredFields(values) {
-  const normalized = [...new Set((values ?? []).map((value) => value.trim().toLowerCase().replaceAll("-", "_")))].filter((value) => value.length > 0).sort((left, right) => left.localeCompare(right));
-  return normalized.filter((value) => [
-    "author",
-    "acceptance_criteria",
-    "estimated_minutes",
-    "close_reason",
-    "reviewer",
-    "risk",
-    "confidence",
-    "sprint",
-    "release"
-  ].includes(value));
-}
-function normalizeValidationPatternList(values) {
-  return [...new Set((values ?? []).map((value) => value.trim().toLowerCase()).filter((value) => value.length > 0))].sort((left, right) => left.localeCompare(right));
-}
-function valueOrDefault(value, fallback) {
-  return value === void 0 ? fallback : value;
-}
-function recordOrEmpty(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
-}
-function arrayOrEmpty(value) {
-  return Array.isArray(value) ? value : [];
-}
-function buildValidationSettings(settings, defaults, governance) {
-  return {
-    ...defaults.validation,
-    ...settings.validation,
-    parent_reference: governance.parent_reference,
-    metadata_profile: governance.metadata_profile,
-    metadata_required_fields: normalizeValidationMetadataRequiredFields(settings.validation?.metadata_required_fields),
-    lifecycle_stale_blocker_reason_patterns: normalizeValidationPatternList(settings.validation?.lifecycle_stale_blocker_reason_patterns ?? defaults.validation.lifecycle_stale_blocker_reason_patterns),
-    lifecycle_closure_like_blocked_reason_patterns: normalizeValidationPatternList(settings.validation?.lifecycle_closure_like_blocked_reason_patterns ?? defaults.validation.lifecycle_closure_like_blocked_reason_patterns),
-    lifecycle_closure_like_resolution_patterns: normalizeValidationPatternList(settings.validation?.lifecycle_closure_like_resolution_patterns ?? defaults.validation.lifecycle_closure_like_resolution_patterns),
-    lifecycle_closure_like_actual_result_patterns: normalizeValidationPatternList(settings.validation?.lifecycle_closure_like_actual_result_patterns ?? defaults.validation.lifecycle_closure_like_actual_result_patterns),
-    estimate_defaults_by_type: normalizeEstimateDefaultOverrides(settings.validation?.estimate_defaults_by_type)
-  };
-}
-function buildTelemetrySettings(settings, defaults) {
-  return {
-    enabled: settings.telemetry?.enabled ?? defaults.telemetry.enabled,
-    first_run_prompt_completed: settings.telemetry?.first_run_prompt_completed ?? defaults.telemetry.first_run_prompt_completed,
-    capture_level: settings.telemetry?.capture_level ?? defaults.telemetry.capture_level,
-    endpoint: settings.telemetry?.endpoint ?? defaults.telemetry.endpoint,
-    installation_id: settings.telemetry?.installation_id ?? defaults.telemetry.installation_id,
-    retention_days: settings.telemetry?.retention_days ?? defaults.telemetry.retention_days
-  };
-}
-function buildSearchSettings(settings, defaults) {
-  return {
-    ...defaults.search,
-    ...settings.search,
-    mutation_refresh_policy: normalizeSearchMutationRefreshPolicy(settings.search?.mutation_refresh_policy),
-    query_expansion: {
-      ...defaults.search.query_expansion,
-      ...settings.search?.query_expansion,
-      enabled: normalizeSearchQueryExpansionEnabled(settings.search?.query_expansion?.enabled),
-      provider: normalizeSearchQueryExpansionProvider(settings.search?.query_expansion?.provider)
-    },
-    rerank: {
-      ...defaults.search.rerank,
-      ...settings.search?.rerank,
-      enabled: normalizeSearchRerankEnabled(settings.search?.rerank?.enabled),
-      model: normalizeSearchRerankModel(settings.search?.rerank?.model),
-      top_k: normalizeSearchRerankTopK(settings.search?.rerank?.top_k)
-    }
-  };
-}
-function buildVectorStoreSettings(settings, defaults) {
-  return {
-    adapter: settings.vector_store.adapter ?? defaults.vector_store.adapter,
-    collection_name: normalizeVectorStoreCollectionName(settings.vector_store.collection_name),
-    qdrant: { ...defaults.vector_store.qdrant, ...settings.vector_store.qdrant },
-    lancedb: { ...defaults.vector_store.lancedb, ...settings.vector_store.lancedb }
-  };
-}
-function normalizeSettingsItemFormat(settings, defaults) {
-  if (settings.item_format === "json_markdown") {
-    return "toon";
-  }
-  return settings.item_format ?? defaults.item_format;
-}
-function buildContextSettings(settings, defaults) {
-  return {
-    default_depth: settings.context?.default_depth ?? defaults.context.default_depth,
-    activity_limit: settings.context?.activity_limit ?? defaults.context.activity_limit,
-    stale_threshold_days: settings.context?.stale_threshold_days ?? defaults.context.stale_threshold_days,
-    sections: {
-      ...defaults.context.sections,
-      ...settings.context?.sections
-    }
-  };
-}
-function buildProviderSettings(settings, defaults) {
-  return {
-    openai: { ...defaults.providers.openai, ...settings.providers.openai },
-    ollama: { ...defaults.providers.ollama, ...settings.providers.ollama }
-  };
-}
-function normalizeItemTypeDefinitions(definitions) {
-  const normalized = (definitions ?? []).map((definition) => normalizeItemTypeDefinition(definition)).filter((definition) => definition !== null);
-  const dedupedByName = /* @__PURE__ */ new Map();
-  for (const definition of normalized) {
-    dedupedByName.set(definition.name.toLowerCase(), definition);
-  }
-  return [...dedupedByName.values()].sort((left, right) => left.name.localeCompare(right.name));
-}
-function mergeSettings(settings) {
-  const defaults = cloneDefaults();
-  const governance = resolveGovernanceKnobs({
-    governance: settings.governance ?? { preset: "default" }
-  });
-  return {
-    ...defaults,
-    ...settings,
-    item_format: normalizeSettingsItemFormat(settings, defaults),
-    locks: { ...defaults.locks, ...settings.locks },
-    checkpoints: { ...defaults.checkpoints, ...settings.checkpoints },
-    output: { ...defaults.output, ...settings.output },
-    history: {
-      ...defaults.history,
-      ...settings.history,
-      compact_policy: {
-        ...defaults.history.compact_policy,
-        ...settings.history?.compact_policy
-      }
-    },
-    validation: buildValidationSettings(settings, defaults, governance),
-    governance,
-    workflow: {
-      definition_of_done: [...settings.workflow?.definition_of_done ?? defaults.workflow.definition_of_done]
-    },
-    testing: {
-      record_results_to_items: settings.testing?.record_results_to_items ?? defaults.testing.record_results_to_items
-    },
-    telemetry: buildTelemetrySettings(settings, defaults),
-    agent_guidance: normalizeAgentGuidanceSettings(settings.agent_guidance ?? defaults.agent_guidance),
-    item_types: {
-      definitions: normalizeItemTypeDefinitions(settings.item_types?.definitions)
-    },
-    schema: normalizeRuntimeSchemaSettings(settings.schema ?? defaults.schema),
-    context: buildContextSettings(settings, defaults),
-    extensions: {
-      enabled: [...settings.extensions.enabled],
-      disabled: [...settings.extensions.disabled],
-      policy: normalizeExtensionPolicySettings(settings.extensions.policy ?? defaults.extensions.policy)
-    },
-    search: buildSearchSettings(settings, defaults),
-    providers: buildProviderSettings(settings, defaults),
-    vector_store: buildVectorStoreSettings(settings, defaults)
-  };
-}
-function orderSerializedSettingsSections(ordered) {
-  ordered.locks = orderObject(ordered.locks, ["ttl_seconds", "wait_ms"]);
-  ordered.checkpoints = orderObject(ordered.checkpoints, ["retention_days"]);
-  ordered.output = orderObject(ordered.output, ["default_format"]);
-  ordered.history = orderObject(ordered.history, ["missing_stream", "compact_policy"]);
-  ordered.validation = orderObject(ordered.validation, [
-    "sprint_release_format",
-    "parent_reference",
-    "metadata_profile",
-    "metadata_required_fields",
-    "lifecycle_stale_blocker_reason_patterns",
-    "lifecycle_closure_like_blocked_reason_patterns",
-    "lifecycle_closure_like_resolution_patterns",
-    "lifecycle_closure_like_actual_result_patterns",
-    "estimate_defaults_by_type"
-  ]);
-  ordered.governance = orderObject(ordered.governance, [
-    "preset",
-    "ownership_enforcement",
-    "create_mode_default",
-    "close_validation_default",
-    "require_close_reason",
-    "parent_reference",
-    "metadata_profile",
-    "force_required_for_stale_lock",
-    "create_default_type",
-    "workflow_enforcement"
-  ]);
-  ordered.workflow = orderObject(ordered.workflow, ["definition_of_done"]);
-  ordered.testing = orderObject(ordered.testing, ["record_results_to_items"]);
-  ordered.telemetry = orderObject(ordered.telemetry, [
-    "enabled",
-    "first_run_prompt_completed",
-    "capture_level",
-    "endpoint",
-    "installation_id",
-    "retention_days"
-  ]);
-  ordered.agent_guidance = orderObject(ordered.agent_guidance, [
-    "prompt_completed",
-    "declined",
-    "declined_at",
-    "template_version",
-    "last_checked_files"
-  ]);
-  ordered.item_types = orderObject(ordered.item_types, ["definitions"]);
-  ordered.schema = orderObject(ordered.schema, [
-    "version",
-    "files",
-    "statuses",
-    "fields",
-    "workflow",
-    "type_workflows",
-    "unknown_field_policy"
-  ]);
-  ordered.schema.files = orderObject(recordOrEmpty(ordered.schema.files), ["types", "statuses", "fields", "workflows"]);
-  ordered.schema.workflow = orderObject(recordOrEmpty(ordered.schema.workflow), ["draft_status", "open_status", "in_progress_status", "blocked_status", "close_status", "canceled_status"]);
-  ordered.context = orderObject(ordered.context, [
-    "default_depth",
-    "activity_limit",
-    "stale_threshold_days",
-    "sections"
-  ]);
-  ordered.context.sections = orderObject(recordOrEmpty(ordered.context.sections), ["hierarchy", "activity", "progress", "blockers", "files", "workload", "staleness", "tests"]);
-  ordered.extensions = orderObject(ordered.extensions, ["enabled", "disabled", "policy"]);
-  ordered.extensions.policy = orderObject(recordOrEmpty(ordered.extensions.policy), [
-    "mode",
-    "trust_mode",
-    "pm_max_version_exceeded_mode",
-    "require_provenance",
-    "trusted_extensions",
-    "default_sandbox_profile",
-    "allowed_extensions",
-    "blocked_extensions",
-    "allowed_capabilities",
-    "blocked_capabilities",
-    "allowed_surfaces",
-    "blocked_surfaces",
-    "allowed_commands",
-    "blocked_commands",
-    "allowed_actions",
-    "blocked_actions",
-    "allowed_services",
-    "blocked_services",
-    "extension_overrides"
-  ]);
-  ordered.extensions.policy.extension_overrides = arrayOrEmpty(ordered.extensions.policy.extension_overrides).map((entry) => orderObject(recordOrEmpty(entry), [
-    "name",
-    "disabled",
-    "require_trusted",
-    "require_provenance",
-    "sandbox_profile",
-    "allowed_capabilities",
-    "blocked_capabilities",
-    "allowed_surfaces",
-    "blocked_surfaces",
-    "allowed_commands",
-    "blocked_commands",
-    "allowed_actions",
-    "blocked_actions",
-    "allowed_services",
-    "blocked_services"
-  ]));
-  ordered.search = orderObject(ordered.search, [
-    "score_threshold",
-    "hybrid_semantic_weight",
-    "max_results",
-    "embedding_model",
-    "embedding_corpus_max_characters",
-    "embedding_batch_size",
-    "embedding_timeout_ms",
-    "scanner_max_batch_retries",
-    "provider",
-    "mutation_refresh_policy",
-    "query_expansion",
-    "rerank"
-  ]);
-  ordered.search.query_expansion = orderObject(recordOrEmpty(ordered.search.query_expansion), ["enabled", "provider"]);
-  ordered.search.rerank = orderObject(recordOrEmpty(ordered.search.rerank), ["enabled", "model", "top_k"]);
-  ordered.providers = orderObject(ordered.providers, ["openai", "ollama"]);
-  ordered.providers.openai = orderObject(recordOrEmpty(ordered.providers.openai), ["base_url", "api_key", "model"]);
-  ordered.providers.ollama = orderObject(recordOrEmpty(ordered.providers.ollama), ["base_url", "model"]);
-  ordered.vector_store = orderObject(ordered.vector_store, [
-    "adapter",
-    "collection_name",
-    "qdrant",
-    "lancedb"
-  ]);
-  ordered.vector_store.qdrant = orderObject(recordOrEmpty(ordered.vector_store.qdrant), ["url", "api_key"]);
-  ordered.vector_store.lancedb = orderObject(recordOrEmpty(ordered.vector_store.lancedb), ["path"]);
-}
-function buildSerializeBaseSettings(settings) {
-  return {
-    ...settings,
-    locks: valueOrDefault(settings.locks, SETTINGS_DEFAULTS.locks),
-    checkpoints: valueOrDefault(settings.checkpoints, SETTINGS_DEFAULTS.checkpoints),
-    output: valueOrDefault(settings.output, SETTINGS_DEFAULTS.output),
-    history: valueOrDefault(settings.history, SETTINGS_DEFAULTS.history),
-    validation: valueOrDefault(settings.validation, SETTINGS_DEFAULTS.validation),
-    workflow: valueOrDefault(settings.workflow, SETTINGS_DEFAULTS.workflow),
-    testing: valueOrDefault(settings.testing, SETTINGS_DEFAULTS.testing),
-    telemetry: valueOrDefault(settings.telemetry, SETTINGS_DEFAULTS.telemetry),
-    agent_guidance: valueOrDefault(settings.agent_guidance, SETTINGS_DEFAULTS.agent_guidance),
-    item_types: valueOrDefault(settings.item_types, SETTINGS_DEFAULTS.item_types),
-    schema: valueOrDefault(settings.schema, SETTINGS_DEFAULTS.schema),
-    context: valueOrDefault(settings.context, SETTINGS_DEFAULTS.context),
-    extensions: valueOrDefault(settings.extensions, SETTINGS_DEFAULTS.extensions),
-    search: valueOrDefault(settings.search, SETTINGS_DEFAULTS.search),
-    providers: valueOrDefault(settings.providers, SETTINGS_DEFAULTS.providers),
-    vector_store: valueOrDefault(settings.vector_store, SETTINGS_DEFAULTS.vector_store)
-  };
-}
-function buildSerializedValidationSettings(baseSettings, governance) {
-  return {
-    ...baseSettings.validation,
-    parent_reference: governance.parent_reference,
-    metadata_profile: governance.metadata_profile,
-    metadata_required_fields: normalizeValidationMetadataRequiredFields(baseSettings.validation?.metadata_required_fields),
-    lifecycle_stale_blocker_reason_patterns: normalizeValidationPatternList(baseSettings.validation?.lifecycle_stale_blocker_reason_patterns ?? SETTINGS_DEFAULTS.validation.lifecycle_stale_blocker_reason_patterns),
-    lifecycle_closure_like_blocked_reason_patterns: normalizeValidationPatternList(baseSettings.validation?.lifecycle_closure_like_blocked_reason_patterns ?? SETTINGS_DEFAULTS.validation.lifecycle_closure_like_blocked_reason_patterns),
-    lifecycle_closure_like_resolution_patterns: normalizeValidationPatternList(baseSettings.validation?.lifecycle_closure_like_resolution_patterns ?? SETTINGS_DEFAULTS.validation.lifecycle_closure_like_resolution_patterns),
-    lifecycle_closure_like_actual_result_patterns: normalizeValidationPatternList(baseSettings.validation?.lifecycle_closure_like_actual_result_patterns ?? SETTINGS_DEFAULTS.validation.lifecycle_closure_like_actual_result_patterns),
-    estimate_defaults_by_type: normalizeEstimateDefaultOverrides(baseSettings.validation?.estimate_defaults_by_type)
-  };
-}
-function buildSerializedSearchSettings(baseSettings) {
-  return {
-    ...SETTINGS_DEFAULTS.search,
-    ...baseSettings.search,
-    mutation_refresh_policy: normalizeSearchMutationRefreshPolicy(baseSettings.search?.mutation_refresh_policy),
-    query_expansion: {
-      ...SETTINGS_DEFAULTS.search.query_expansion,
-      ...baseSettings.search?.query_expansion,
-      enabled: normalizeSearchQueryExpansionEnabled(baseSettings.search?.query_expansion?.enabled),
-      provider: normalizeSearchQueryExpansionProvider(baseSettings.search?.query_expansion?.provider)
-    },
-    rerank: {
-      ...SETTINGS_DEFAULTS.search.rerank,
-      ...baseSettings.search?.rerank,
-      enabled: normalizeSearchRerankEnabled(baseSettings.search?.rerank?.enabled),
-      model: normalizeSearchRerankModel(baseSettings.search?.rerank?.model),
-      top_k: normalizeSearchRerankTopK(baseSettings.search?.rerank?.top_k)
-    }
-  };
-}
-function buildSerializedContextSettings(baseSettings) {
-  return {
-    default_depth: baseSettings.context?.default_depth ?? SETTINGS_DEFAULTS.context.default_depth,
-    activity_limit: baseSettings.context?.activity_limit ?? SETTINGS_DEFAULTS.context.activity_limit,
-    stale_threshold_days: baseSettings.context?.stale_threshold_days ?? SETTINGS_DEFAULTS.context.stale_threshold_days,
-    sections: {
-      ...SETTINGS_DEFAULTS.context.sections,
-      ...baseSettings.context?.sections
-    }
-  };
-}
-function buildSerializedVectorStoreSettings(baseSettings) {
-  return {
-    ...baseSettings.vector_store,
-    adapter: baseSettings.vector_store?.adapter ?? SETTINGS_DEFAULTS.vector_store.adapter,
-    collection_name: normalizeVectorStoreCollectionName(baseSettings.vector_store?.collection_name),
-    qdrant: { ...baseSettings.vector_store?.qdrant },
-    lancedb: { ...baseSettings.vector_store?.lancedb }
-  };
-}
-function buildNormalizedSettingsForSerialization(baseSettings, governance, normalizedSchema, persistedFileBackedSections) {
-  return {
-    ...baseSettings,
-    item_format: "toon",
-    validation: buildSerializedValidationSettings(baseSettings, governance),
-    governance,
-    agent_guidance: normalizeAgentGuidanceSettings(baseSettings.agent_guidance),
-    item_types: {
-      definitions: persistedFileBackedSections.item_type_definitions
-    },
-    schema: {
-      ...normalizedSchema,
-      statuses: persistedFileBackedSections.schema_statuses,
-      fields: persistedFileBackedSections.schema_fields,
-      type_workflows: persistedFileBackedSections.schema_type_workflows
-    },
-    search: buildSerializedSearchSettings(baseSettings),
-    context: buildSerializedContextSettings(baseSettings),
-    extensions: {
-      enabled: normalizeStringList(baseSettings.extensions?.enabled),
-      disabled: normalizeStringList(baseSettings.extensions?.disabled),
-      policy: normalizeExtensionPolicySettings(baseSettings.extensions?.policy)
-    },
-    vector_store: buildSerializedVectorStoreSettings(baseSettings)
-  };
-}
-function serializeSettings(settings, options = {}) {
-  const baseSettings = buildSerializeBaseSettings(settings);
-  const governance = resolveGovernanceKnobs(baseSettings);
-  const normalizedSchema = normalizeRuntimeSchemaSettings(baseSettings.schema);
-  const persistedFileBackedSections = resolvePersistedFileBackedSchemaSections(baseSettings, options.persist_source);
-  const normalizedSettings = buildNormalizedSettingsForSerialization(baseSettings, governance, normalizedSchema, persistedFileBackedSections);
-  const ordered = orderObject({
-    ...normalizedSettings,
-    governance: normalizeGovernanceForPersist(governance)
-  }, [
-    "version",
-    "id_prefix",
-    "author_default",
-    "item_format",
-    "locks",
-    "checkpoints",
-    "output",
-    "history",
-    "validation",
-    "governance",
-    "workflow",
-    "testing",
-    "telemetry",
-    "agent_guidance",
-    "item_types",
-    "schema",
-    "context",
-    "extensions",
-    "search",
-    "providers",
-    "vector_store"
-  ]);
-  orderSerializedSettingsSections(ordered);
-  return `${JSON.stringify(ordered, null, 2)}
-`;
-}
-async function readSettingsWithMetadata(pmRoot) {
-  const settingsPath = getSettingsPath(pmRoot);
-  let trackedPathsForFailure = [settingsPath];
-  await runActiveOnReadHooks({
-    path: settingsPath,
-    scope: "project"
-  });
-  const cachedResult = getSettingsReadCacheEntry(pmRoot);
-  if (cachedResult) {
-    const currentSignatures = await collectSettingsReadCacheSignatures(cachedResult.tracked_paths);
-    if (settingsReadCacheSignaturesEqual(currentSignatures, cachedResult.signatures)) {
-      return cloneSettingsReadResult(cachedResult.value);
-    }
-  }
-  const settingsOnlySignatures = await collectSettingsReadCacheSignatures([settingsPath]);
-  const raw = await readFileIfExists(settingsPath);
-  if (raw === null) {
-    const fallback = buildFallbackSettingsReadResult();
-    await cacheSettingsReadResultIfStable(pmRoot, [settingsPath], fallback, settingsOnlySignatures, [settingsPath]);
-    return fallback;
-  }
-  const settingsSignaturesAfterRead = await collectSettingsReadCacheSignatures([settingsPath]);
-  if (!settingsReadCacheSignaturesEqual(settingsOnlySignatures, settingsSignaturesAfterRead)) {
-    clearSettingsReadCache(pmRoot);
-    return readSettingsWithMetadata(pmRoot);
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    const fallback = buildFallbackSettingsReadResult("settings_read_invalid_json");
-    await cacheSettingsReadResultIfStable(pmRoot, [settingsPath], fallback, settingsSignaturesAfterRead, [settingsPath]);
-    return fallback;
-  }
-  const validated = validateSettings(parsed);
-  if (!validated.success) {
-    const fallback = buildFallbackSettingsReadResult("settings_read_invalid_schema");
-    await cacheSettingsReadResultIfStable(pmRoot, [settingsPath], fallback, settingsSignaturesAfterRead, [settingsPath]);
-    return fallback;
-  }
-  try {
-    const mergedSettings = mergeSettings(validated.data);
-    const trackedPaths = resolveSettingsReadTrackedPaths(pmRoot, mergedSettings.schema, settingsPath);
-    trackedPathsForFailure = trackedPaths;
-    const signaturesBeforeSchemaLoad = await collectSettingsReadCacheSignatures(trackedPaths);
-    const schemaScaffold = await ensureRuntimeSchemaFileScaffold(pmRoot, mergedSettings.schema);
-    const loadedSchemaSections = await loadRuntimeSchemaFromOptionalFiles(pmRoot, mergedSettings.schema);
-    const signaturesAfterSchemaLoad = await collectSettingsReadCacheSignatures(trackedPaths);
-    const settings = {
-      ...mergedSettings,
-      item_types: {
-        definitions: normalizeItemTypeDefinitions([
-          ...mergedSettings.item_types.definitions,
-          ...arrayOrEmpty(loadedSchemaSections.type_definitions_from_file)
-        ])
-      },
-      schema: loadedSchemaSections.schema
-    };
-    attachSettingsPersistSourceSnapshot(settings, buildSettingsPersistSourceSnapshot(validated.data, settings));
-    const result = {
-      settings,
-      metadata: {
-        has_explicit_item_format: hasExplicitItemFormat(parsed)
-      },
-      warnings: [
-        ...validated.data.item_format === "json_markdown" ? ["settings_item_format_legacy_json_markdown_coerced_to_toon"] : [],
-        ...schemaScaffold.created_paths.map((createdPath) => `runtime_schema_bootstrap_created:${createdPath}`),
-        ...loadedSchemaSections.warnings
-      ]
-    };
-    if (schemaScaffold.created_paths.length === 0) {
-      if (!settingsReadCacheSignaturesEqual(signaturesBeforeSchemaLoad, signaturesAfterSchemaLoad)) {
-        clearSettingsReadCache(pmRoot);
-      } else {
-        setSettingsReadCacheEntry(pmRoot, {
-          tracked_paths: trackedPaths,
-          signatures: signaturesAfterSchemaLoad,
-          value: cloneSettingsReadResult(result)
-        });
-      }
-    } else {
-      clearSettingsReadCache(pmRoot);
-    }
-    return result;
-  } catch {
-    const fallback = buildFallbackSettingsReadResult("settings_read_merge_failed");
-    await cacheSettingsReadResultSafe(pmRoot, trackedPathsForFailure, fallback);
-    return fallback;
-  }
-}
-async function readSettings(pmRoot) {
-  return (await readSettingsWithMetadata(pmRoot)).settings;
-}
-async function writeSettings(pmRoot, settings, op = SETTINGS_WRITE_OP) {
-  const settingsPath = getSettingsPath(pmRoot);
-  await writeFileAtomic(settingsPath, serializeSettings(settings, {
-    persist_source: getSettingsPersistSourceSnapshot(settings)
-  }));
-  try {
-    await runActiveOnWriteHooks({
-      path: settingsPath,
-      scope: "project",
-      op
-    });
-  } finally {
-    clearSettingsReadCache(pmRoot);
-  }
-}
-
-export {
-  setActiveExtensionHooks,
-  setActiveExtensionCommands,
-  setActiveExtensionParsers,
-  setActiveExtensionPreflight,
-  setActiveExtensionServices,
-  setActiveExtensionRenderers,
-  setActiveExtensionRegistrations,
-  getActiveExtensionRegistrations,
-  setActiveCommandContext,
-  setActiveCommandResult,
-  getActiveCommandResult,
-  recordAfterCommandAffectedItem,
-  projectAfterCommandItemSnapshot,
-  consumeAfterCommandAffectedItems,
-  clearActiveExtensionHooks,
-  runActiveOnWriteHooks,
-  runActiveOnReadHooks,
-  hasActiveOnReadHooks,
-  runActiveOnIndexHooks,
-  runActiveCommandOverride,
-  runActiveCommandHandler,
-  runActiveParserOverride,
-  runActivePreflightOverride,
-  runActiveRendererOverride,
-  runActiveServiceOverride,
-  runActiveServiceOverrideSync,
-  PmCliError,
-  stableStringify,
-  stableValueEquals,
-  sha256Hex,
-  orderObject,
-  resolveEstimateDefaultMinutes,
-  resolveGovernanceKnobs,
-  readSettingsWithMetadata,
-  readSettings,
-  writeSettings
-};
-//# sourceMappingURL=chunk-E3SZTQ4K.js.map
-
-//# debugId=d4ede2fb-7525-501d-a1f0-77276019f794