@unbrained/pm-cli 2026.7.4 → 2026.7.5

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

@@ -0,0 +1,1932 @@
+
+!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-YD5FML7K.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-US3T3W5J.js.map
+
+//# debugId=d4ede2fb-7525-501d-a1f0-77276019f794