@cortexkit/opencode-magic-context 0.45.0 → 0.46.0

package/dist/v2/server-p2en78c8.js

@@ -0,0 +1,3892 @@
+import {
+  DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE,
+  PROTECTED_TOKENS_MIN,
+  PER_HARNESS_MIGRATION_INVENTORY,
+  PER_HARNESS_MODEL_KEYS,
+  ConfigProfilesSchema,
+  MagicContextConfigSchema
+} from "./server-xtp687da.js";
+import {
+  log
+} from "./server-1qbnzc80.js";
+import {
+  setWindowOverlayPath,
+  setOutputReserveConfig
+} from "./server-y8maxeft.js";
+
+// src/config/agent-disable.ts
+var COMPACTION_ENABLED_PATH = `compaction${"."}enabled`;
+function isDreamerRunnable(config) {
+  return !!config.dreamer && config.dreamer.disable !== true;
+}
+function isCompactionEnabled(config) {
+  return config.compaction?.enabled !== false;
+}
+function clonePlainObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return;
+  }
+  return { ...value };
+}
+function migrateLegacyEnabledForAgent(args) {
+  const agent = clonePlainObject(args.patched[args.agentName]);
+  if (!agent || !("enabled" in agent))
+    return;
+  const enabled = agent.enabled;
+  const disable = agent.disable;
+  delete agent.enabled;
+  if (args.agentName === "historian") {
+    args.warnings.push('Removed invalid "historian.enabled" in-memory (run doctor to persist).');
+    args.patched.historian = agent;
+    return;
+  }
+  if (disable !== true && enabled === false) {
+    agent.disable = true;
+    args.warnings.push('Migrated "dreamer.enabled=false" → "dreamer.disable=true" in-memory (run doctor to persist). This now also disables manual /ctx-dream; for manual-only remove disable and set schedule="".');
+  }
+  args.patched.dreamer = agent;
+}
+function migrateLegacyAgentEnabledInMemory(rawConfig, warnings) {
+  const shouldPatch = ["dreamer", "historian"].some((key) => {
+    const agent = rawConfig[key];
+    return typeof agent === "object" && agent !== null && !Array.isArray(agent) && "enabled" in agent;
+  });
+  if (!shouldPatch)
+    return rawConfig;
+  const patched = { ...rawConfig };
+  migrateLegacyEnabledForAgent({ patched, agentName: "dreamer", warnings });
+  migrateLegacyEnabledForAgent({ patched, agentName: "historian", warnings });
+  return patched;
+}
+
+// src/config/project-security.ts
+var HIDDEN_AGENT_KEYS = ["historian", "dreamer"];
+var HARNESS_KEYS = PER_HARNESS_MODEL_KEYS;
+var HISTORIAN_USER_ONLY_FIELDS = [
+  ...PER_HARNESS_MIGRATION_INVENTORY.historian.migrated_execution,
+  "runner",
+  "host_runner"
+];
+var PROMPT_SURFACE_USER_ONLY_FIELDS = ["guidance_override_path", "tool_descriptions"];
+var AGENT_ESCALATION_FIELDS = ["prompt", "permission", "tools"];
+var EMBEDDING_USER_ONLY_FIELDS = [
+  "endpoint",
+  "provider",
+  "fallback_provider",
+  "query_instruction",
+  "document_prefix"
+];
+var PERCENTAGE_THRESHOLD_REASON = "security: a repository may only raise compaction thresholds above the user's effective value; it cannot force earlier historian work or cloned-repo cost escalation.";
+var TOKEN_THRESHOLD_REASON = "security: a repository may only raise execute_threshold_tokens above the user's trusted token threshold; it cannot force earlier historian work or cloned-repo cost escalation.";
+var TOKEN_THRESHOLD_INTRODUCTION_REASON = "security: a repository cannot introduce a new execute_threshold_tokens override when the user has no trusted token threshold for that key; that could force earlier historian work or cloned-repo cost escalation.";
+var PROTECTED_TOKENS_REASON = "security: a repository may only raise protected_tokens above the resolved user-or-derived floor; it cannot lower protection.";
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function resolveProtectedTokensScalar(value) {
+  if (typeof value === "number" && Number.isInteger(value) && value >= 4000 && value <= 1e6) {
+    return value;
+  }
+  return;
+}
+var PROTECTED_TOKENS_TIER_OVERRIDES = Symbol.for("@cortexkit/magic-context/protected-tokens-tier-overrides");
+function attachProtectedTokensTierOverrides(config, args) {
+  const user = resolveProtectedTokensScalar(args.trustedUser);
+  const rawProject = resolveProtectedTokensScalar(args.project);
+  const project = rawProject !== undefined && (user === undefined || rawProject >= user) ? rawProject : undefined;
+  if (user === undefined && project === undefined)
+    return config;
+  Object.defineProperty(config, PROTECTED_TOKENS_TIER_OVERRIDES, {
+    value: {
+      ...user !== undefined ? { user } : {},
+      ...project !== undefined ? { project } : {}
+    },
+    configurable: false,
+    enumerable: false,
+    writable: false
+  });
+  return config;
+}
+function getProtectedTokensTierOverrides(config) {
+  return config[PROTECTED_TOKENS_TIER_OVERRIDES];
+}
+function stripListedFields(target, fields, path, removed) {
+  for (const field of fields) {
+    if (field in target) {
+      delete target[field];
+      removed.push(path.length > 0 ? `${path}.${field}` : field);
+    }
+  }
+}
+function stripEscalationAtExecutableSite(block, path, removed) {
+  stripListedFields(block, AGENT_ESCALATION_FIELDS, path, removed);
+  if (isPlainObject(block.model)) {
+    stripListedFields(block.model, AGENT_ESCALATION_FIELDS, `${path}.model`, removed);
+  }
+  if (Array.isArray(block.fallback_models)) {
+    for (let index = 0;index < block.fallback_models.length; index++) {
+      const entry = block.fallback_models[index];
+      if (isPlainObject(entry)) {
+        stripListedFields(entry, AGENT_ESCALATION_FIELDS, `${path}.fallback_models.${index}`, removed);
+      }
+    }
+  }
+}
+function stripNestedMuralModels(node, path, removed) {
+  for (const [key, value] of Object.entries(node)) {
+    if (key === "mural" && isPlainObject(value) && "model" in value) {
+      delete value.model;
+      removed.push(`${path}.${key}.model`);
+    } else if (isPlainObject(value)) {
+      stripNestedMuralModels(value, `${path}.${key}`, removed);
+    }
+  }
+}
+function isValidPercentageThreshold(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 20 && value <= 90;
+}
+function isValidTokenThreshold(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 5000 && value <= 2000000;
+}
+function normalizeTrustedPercentageThresholds(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return { defaultValue: value, overrides: new Map };
+  }
+  if (isPlainObject(value) && typeof value.default === "number" && Number.isFinite(value.default)) {
+    const overrides = new Map;
+    for (const [key, child] of Object.entries(value)) {
+      if (key === "default")
+        continue;
+      if (typeof child === "number" && Number.isFinite(child)) {
+        overrides.set(key, child);
+      }
+    }
+    return { defaultValue: value.default, overrides };
+  }
+  return { defaultValue: DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE, overrides: new Map };
+}
+function normalizeTrustedTokenThresholds(value) {
+  if (!isPlainObject(value)) {
+    return { defaultValue: undefined, overrides: new Map };
+  }
+  const overrides = new Map;
+  for (const [key, child] of Object.entries(value)) {
+    if (key === "default")
+      continue;
+    if (typeof child === "number" && Number.isFinite(child)) {
+      overrides.set(key, child);
+    }
+  }
+  return {
+    defaultValue: typeof value.default === "number" && Number.isFinite(value.default) ? value.default : undefined,
+    overrides
+  };
+}
+function clonePercentageThresholds(value) {
+  return {
+    defaultValue: value.defaultValue,
+    overrides: new Map(value.overrides)
+  };
+}
+function cloneTokenThresholds(value) {
+  return {
+    defaultValue: value.defaultValue,
+    overrides: new Map(value.overrides)
+  };
+}
+function percentageThresholdsEqual(left, right) {
+  if (left.defaultValue !== right.defaultValue)
+    return false;
+  if (left.overrides.size !== right.overrides.size)
+    return false;
+  for (const [key, value] of left.overrides) {
+    if (right.overrides.get(key) !== value)
+      return false;
+  }
+  return true;
+}
+function setMergedPercentageThreshold(mergedRaw, value) {
+  if (value.overrides.size === 0) {
+    mergedRaw.execute_threshold_percentage = value.defaultValue;
+    return;
+  }
+  const serialized = { default: value.defaultValue };
+  for (const [key, threshold] of value.overrides) {
+    serialized[key] = threshold;
+  }
+  mergedRaw.execute_threshold_percentage = serialized;
+}
+function setMergedTokenThreshold(mergedRaw, value) {
+  if (value.defaultValue === undefined && value.overrides.size === 0) {
+    delete mergedRaw.execute_threshold_tokens;
+    return;
+  }
+  const serialized = {};
+  if (value.defaultValue !== undefined) {
+    serialized.default = value.defaultValue;
+  }
+  for (const [key, threshold] of value.overrides) {
+    serialized[key] = threshold;
+  }
+  mergedRaw.execute_threshold_tokens = serialized;
+}
+function makeProjectThresholdWarning(field, reason) {
+  return `Ignoring ${field} from project config (${reason})`;
+}
+function stripUnsafeProjectConfigFields(projectRaw) {
+  const warnings = [];
+  if ("profiles" in projectRaw) {
+    delete projectRaw.profiles;
+    warnings.push("Ignoring profiles from project config (security: profile definitions are user-level only; a repository may select a named user profile with profile).");
+  }
+  if ("auto_update" in projectRaw) {
+    delete projectRaw.auto_update;
+    warnings.push("Ignoring auto_update from project config (security: this setting only honors user-level config).");
+  }
+  if ("fail_closed_blocking" in projectRaw) {
+    delete projectRaw.fail_closed_blocking;
+    warnings.push("Ignoring fail_closed_blocking from project config (security: only user-level config may disable or force the loud inoperability gate).");
+  }
+  if ("debug_rpc" in projectRaw) {
+    delete projectRaw.debug_rpc;
+    warnings.push("Ignoring debug_rpc from project config (security: only user-level config may enable process heap diagnostics).");
+  }
+  if ("allow_home_project" in projectRaw) {
+    delete projectRaw.allow_home_project;
+    warnings.push("Ignoring allow_home_project from project config (security: only user-level config may opt the user's home directory into Magic Context).");
+  }
+  const compaction = projectRaw.compaction;
+  if (isPlainObject(compaction) && "enabled" in compaction) {
+    delete compaction.enabled;
+    warnings.push("Ignoring compaction.enabled from project config (security: only user-level config may disable Magic Context's context-window management; a cloned repo cannot change how the user's window is owned).");
+  }
+  if ("output_reserve" in projectRaw) {
+    delete projectRaw.output_reserve;
+    warnings.push("Ignoring output_reserve from project config (security: output-token reservation only honors user-level config).");
+  }
+  const models = projectRaw.models;
+  if (isPlainObject(models) && "window_overlay_path" in models) {
+    delete models.window_overlay_path;
+    warnings.push("Ignoring models.window_overlay_path from project config (security: only user-level config may select model geometry metadata).");
+  }
+  if ("language" in projectRaw) {
+    delete projectRaw.language;
+    warnings.push("Ignoring language from project config (security: output language is a user-level setting).");
+  }
+  if ("sqlite" in projectRaw) {
+    delete projectRaw.sqlite;
+    warnings.push("Ignoring sqlite.* from project config (security: SQLite cache/mmap PRAGMAs apply to the " + "process-global shared database handle; only user-level config may set them).");
+  }
+  const storage = projectRaw.storage;
+  if (isPlainObject(storage) && "enforce_private_permissions" in storage) {
+    delete storage.enforce_private_permissions;
+    warnings.push("Ignoring storage.enforce_private_permissions from project config (security: only user-level config may opt into externally managed shared storage permissions).");
+  }
+  const promptSurface = projectRaw.prompt_surface;
+  if (isPlainObject(promptSurface)) {
+    const removed = [];
+    for (const field of PROMPT_SURFACE_USER_ONLY_FIELDS) {
+      if (field in promptSurface) {
+        delete promptSurface[field];
+        removed.push(field);
+      }
+    }
+    if (removed.length > 0) {
+      warnings.push(`Ignoring prompt_surface.${removed.join("/")} from project config (security: repositories may select prompt presets but only user config may provide guidance or tool-description text).`);
+    }
+  }
+  const pi = projectRaw.pi;
+  if (isPlainObject(pi) && "subagent_extensions" in pi) {
+    delete pi.subagent_extensions;
+    warnings.push("Ignoring pi.subagent_extensions from project config (security: only user-level config may choose extensions loaded by Pi subagent children).");
+  }
+  for (const field of ["subc", "shadow_embedding"]) {
+    if (field in projectRaw) {
+      delete projectRaw[field];
+      warnings.push(`Ignoring ${field} from project config (security: daemon routing and developer-only embedding traffic are user-level settings).`);
+    }
+  }
+  const embedding = projectRaw.embedding;
+  if (isPlainObject(embedding)) {
+    const removed = [];
+    for (const field of EMBEDDING_USER_ONLY_FIELDS) {
+      if (field in embedding) {
+        delete embedding[field];
+        removed.push(field);
+      }
+    }
+    if (removed.length > 0) {
+      warnings.push(`Ignoring embedding.${removed.join("/")} from project config ` + "(security: a repository cannot choose where or how private text is embedded).");
+    }
+  }
+  for (const agentKey of HIDDEN_AGENT_KEYS) {
+    const block = projectRaw[agentKey];
+    if (!isPlainObject(block))
+      continue;
+    const removed = [];
+    stripEscalationAtExecutableSite(block, agentKey, removed);
+    for (const harness of HARNESS_KEYS) {
+      const harnessBlock = block[harness];
+      if (!isPlainObject(harnessBlock))
+        continue;
+      stripEscalationAtExecutableSite(harnessBlock, `${agentKey}.${harness}`, removed);
+      const tasks = harnessBlock.tasks;
+      if (isPlainObject(tasks)) {
+        for (const [taskName, taskBlock] of Object.entries(tasks)) {
+          if (isPlainObject(taskBlock)) {
+            stripEscalationAtExecutableSite(taskBlock, `${agentKey}.${harness}.tasks.${taskName}`, removed);
+          }
+        }
+      }
+    }
+    const schedulingTasks = block.tasks;
+    if (isPlainObject(schedulingTasks)) {
+      for (const [taskName, taskBlock] of Object.entries(schedulingTasks)) {
+        if (isPlainObject(taskBlock)) {
+          stripListedFields(taskBlock, AGENT_ESCALATION_FIELDS, `${agentKey}.tasks.${taskName}`, removed);
+        }
+      }
+    }
+    if (removed.length > 0) {
+      warnings.push(`Ignoring ${removed.join(", ")} from project config ` + "(security: a repository cannot reprogram or re-permission hidden agents).");
+    }
+  }
+  const historian = projectRaw.historian;
+  if (isPlainObject(historian)) {
+    const removed = [];
+    for (const field of HISTORIAN_USER_ONLY_FIELDS) {
+      if (field in historian) {
+        delete historian[field];
+        removed.push(field);
+      }
+    }
+    for (const harness of HARNESS_KEYS) {
+      const harnessBlock = historian[harness];
+      if (!isPlainObject(harnessBlock))
+        continue;
+      for (const field of HISTORIAN_USER_ONLY_FIELDS) {
+        if (field in harnessBlock) {
+          delete harnessBlock[field];
+          removed.push(`${harness}.${field}`);
+        }
+      }
+    }
+    if (removed.length > 0) {
+      warnings.push(`Ignoring ${removed.map((path) => `historian.${path}`).join(", ")} from project config ` + "(security: historian model selection is user-level only; a repository cannot force extra compaction cost).");
+    }
+  }
+  const dreamer = projectRaw.dreamer;
+  if (isPlainObject(dreamer) && "runner" in dreamer) {
+    delete dreamer.runner;
+    warnings.push("Ignoring dreamer.runner from project config (security: which process and provider account run dreamer completions is a user-level setting).");
+  }
+  const mural = projectRaw.mural;
+  if (isPlainObject(mural) && "model" in mural) {
+    delete mural.model;
+    warnings.push("Ignoring mural.model from project config (security: the mural cue-compressor model is a user-level setting; a repository cannot choose where project memory is sent).");
+  }
+  const experimental = projectRaw.experimental;
+  const legacyMural = isPlainObject(experimental) ? experimental.mural : undefined;
+  if (isPlainObject(legacyMural) && "model" in legacyMural) {
+    delete legacyMural.model;
+    warnings.push("Ignoring experimental.mural.model from project config (security: the mural cue-compressor model is a user-level setting; use user-level mural.model).");
+  }
+  const nestedMuralRemoved = [];
+  for (const agentKey of HIDDEN_AGENT_KEYS) {
+    const block = projectRaw[agentKey];
+    if (!isPlainObject(block))
+      continue;
+    stripNestedMuralModels(block, agentKey, nestedMuralRemoved);
+  }
+  if (nestedMuralRemoved.length > 0) {
+    warnings.push(`Ignoring ${nestedMuralRemoved.join(", ")} from project config (security: the mural cue-compressor model is a user-level setting; a repository cannot choose where project memory is sent).`);
+  }
+  return warnings;
+}
+function constrainProjectThresholdOverrides(args) {
+  const warnings = [];
+  const basePercentage = normalizeTrustedPercentageThresholds(args.trustedBaseConfig.execute_threshold_percentage);
+  const baseTokens = normalizeTrustedTokenThresholds(args.trustedBaseConfig.execute_threshold_tokens);
+  if ("execute_threshold_percentage" in args.projectRaw) {
+    const projectValue = args.projectRaw.execute_threshold_percentage;
+    if (isValidPercentageThreshold(projectValue)) {
+      const constrained = clonePercentageThresholds(basePercentage);
+      constrained.defaultValue = Math.max(basePercentage.defaultValue, projectValue);
+      for (const [modelKey, threshold] of basePercentage.overrides) {
+        const raisedThreshold = Math.max(threshold, projectValue);
+        if (raisedThreshold === constrained.defaultValue) {
+          constrained.overrides.delete(modelKey);
+        } else {
+          constrained.overrides.set(modelKey, raisedThreshold);
+        }
+      }
+      setMergedPercentageThreshold(args.mergedRaw, constrained);
+      if (percentageThresholdsEqual(constrained, basePercentage)) {
+        warnings.push(makeProjectThresholdWarning("execute_threshold_percentage", PERCENTAGE_THRESHOLD_REASON));
+      }
+    } else if (isPlainObject(projectValue)) {
+      const constrained = clonePercentageThresholds(basePercentage);
+      let touchedValidEntry = false;
+      if (isValidPercentageThreshold(projectValue.default)) {
+        touchedValidEntry = true;
+        if (projectValue.default > basePercentage.defaultValue) {
+          constrained.defaultValue = projectValue.default;
+        } else {
+          warnings.push(makeProjectThresholdWarning("execute_threshold_percentage.default", PERCENTAGE_THRESHOLD_REASON));
+        }
+      }
+      for (const [modelKey, rawValue] of Object.entries(projectValue)) {
+        if (modelKey === "default")
+          continue;
+        if (!isValidPercentageThreshold(rawValue))
+          continue;
+        touchedValidEntry = true;
+        const baseValue = basePercentage.overrides.get(modelKey) ?? basePercentage.defaultValue;
+        if (rawValue > baseValue) {
+          if (rawValue === constrained.defaultValue) {
+            constrained.overrides.delete(modelKey);
+          } else {
+            constrained.overrides.set(modelKey, rawValue);
+          }
+        } else {
+          warnings.push(makeProjectThresholdWarning(`execute_threshold_percentage.${modelKey}`, PERCENTAGE_THRESHOLD_REASON));
+        }
+      }
+      if (touchedValidEntry) {
+        setMergedPercentageThreshold(args.mergedRaw, constrained);
+      }
+    }
+  }
+  if ("execute_threshold_tokens" in args.projectRaw && isPlainObject(args.projectRaw.execute_threshold_tokens)) {
+    const projectValue = args.projectRaw.execute_threshold_tokens;
+    const constrained = cloneTokenThresholds(baseTokens);
+    let touchedValidEntry = false;
+    if (isValidTokenThreshold(projectValue.default)) {
+      touchedValidEntry = true;
+      if (baseTokens.defaultValue === undefined) {
+        warnings.push(makeProjectThresholdWarning("execute_threshold_tokens.default", TOKEN_THRESHOLD_INTRODUCTION_REASON));
+      } else if (projectValue.default > baseTokens.defaultValue) {
+        constrained.defaultValue = projectValue.default;
+      } else {
+        warnings.push(makeProjectThresholdWarning("execute_threshold_tokens.default", TOKEN_THRESHOLD_REASON));
+      }
+    }
+    for (const [modelKey, rawValue] of Object.entries(projectValue)) {
+      if (modelKey === "default")
+        continue;
+      if (!isValidTokenThreshold(rawValue))
+        continue;
+      touchedValidEntry = true;
+      const baseValue = baseTokens.overrides.get(modelKey) ?? baseTokens.defaultValue;
+      if (baseValue === undefined) {
+        warnings.push(makeProjectThresholdWarning(`execute_threshold_tokens.${modelKey}`, TOKEN_THRESHOLD_INTRODUCTION_REASON));
+        continue;
+      }
+      if (rawValue > baseValue) {
+        if (rawValue === constrained.defaultValue) {
+          constrained.overrides.delete(modelKey);
+        } else {
+          constrained.overrides.set(modelKey, rawValue);
+        }
+      } else {
+        warnings.push(makeProjectThresholdWarning(`execute_threshold_tokens.${modelKey}`, TOKEN_THRESHOLD_REASON));
+      }
+    }
+    if (touchedValidEntry) {
+      setMergedTokenThreshold(args.mergedRaw, constrained);
+    }
+  }
+  if ("protected_tokens" in args.projectRaw) {
+    const rawProject = args.projectRaw.protected_tokens;
+    const projectVal = resolveProtectedTokensScalar(rawProject);
+    const trustedUserVal = resolveProtectedTokensScalar(args.trustedBaseConfig.protected_tokens);
+    if (projectVal !== undefined) {
+      if (trustedUserVal !== undefined) {
+        if (projectVal >= trustedUserVal) {
+          args.mergedRaw.protected_tokens = projectVal;
+        } else {
+          args.mergedRaw.protected_tokens = trustedUserVal;
+          warnings.push(makeProjectThresholdWarning("protected_tokens", PROTECTED_TOKENS_REASON));
+        }
+      } else {
+        args.mergedRaw.protected_tokens = projectVal;
+      }
+    } else {
+      if (trustedUserVal !== undefined) {
+        args.mergedRaw.protected_tokens = trustedUserVal;
+      } else {
+        delete args.mergedRaw.protected_tokens;
+      }
+      warnings.push(makeProjectThresholdWarning("protected_tokens", PROTECTED_TOKENS_REASON));
+    }
+  }
+  return warnings;
+}
+function normalizeEndpoint(value) {
+  if (typeof value !== "string")
+    return;
+  const trimmed = value.trim().replace(/\/+$/, "");
+  return trimmed.length > 0 ? trimmed.toLowerCase() : undefined;
+}
+function dropInheritedEmbeddingKeyOnRedirect(projectRaw, mergedRaw, userRaw) {
+  const projectEmbedding = projectRaw.embedding;
+  if (!isPlainObject(projectEmbedding))
+    return [];
+  const redirectsEndpoint = "endpoint" in projectEmbedding;
+  if (!redirectsEndpoint)
+    return [];
+  const userEmbedding = userRaw?.embedding;
+  if (isPlainObject(userEmbedding)) {
+    const projectEndpoint = normalizeEndpoint(projectEmbedding.endpoint);
+    const userEndpoint = normalizeEndpoint(userEmbedding.endpoint);
+    if (projectEndpoint !== undefined && projectEndpoint === userEndpoint) {
+      return [];
+    }
+  }
+  const providesOwnKey = typeof projectEmbedding.api_key === "string" && projectEmbedding.api_key.length > 0;
+  if (providesOwnKey)
+    return [];
+  const mergedEmbedding = mergedRaw.embedding;
+  if (!isPlainObject(mergedEmbedding))
+    return [];
+  if (!("api_key" in mergedEmbedding))
+    return [];
+  delete mergedEmbedding.api_key;
+  return [
+    "Dropped inherited user embedding api_key because project config redirected " + "embedding.endpoint without supplying its own key (security: prevents key " + "exfiltration to a repository-chosen endpoint)."
+  ];
+}
+function projectContributionPath(projectRaw, issuePath) {
+  let node = projectRaw;
+  for (let index = 0;index < issuePath.length; index++) {
+    const segment = String(issuePath[index]);
+    if (!isPlainObject(node) || !Object.hasOwn(node, segment))
+      return;
+    node = node[segment];
+    if (index === issuePath.length - 1 || !isPlainObject(node)) {
+      return issuePath.slice(0, index + 1);
+    }
+  }
+  return;
+}
+function displacedTrustedValue(trustedRaw, contribution) {
+  let node = trustedRaw;
+  for (let index = 0;index < contribution.length; index++) {
+    const segment = String(contribution[index]);
+    if (!isPlainObject(node) || !Object.hasOwn(node, segment))
+      return;
+    node = node[segment];
+    if (index === contribution.length - 1 || !isPlainObject(node)) {
+      return { path: contribution.slice(0, index + 1), value: node };
+    }
+  }
+  return;
+}
+function defineOwnValue(target, key, value) {
+  Object.defineProperty(target, key, {
+    value,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  });
+}
+function writeOwnPath(root, path, value) {
+  let node = root;
+  for (let index = 0;index < path.length - 1; index++) {
+    const segment = String(path[index]);
+    const child = node[segment];
+    if (!isPlainObject(child))
+      return;
+    const copy = { ...child };
+    defineOwnValue(node, segment, copy);
+    node = copy;
+  }
+  defineOwnValue(node, String(path[path.length - 1]), value);
+}
+var MAX_PROJECT_RESTORE_ROUNDS = 16;
+function restoreTrustedValuesOverInvalidProjectValues(args) {
+  const warnings = [];
+  const restoredTopLevelKeys = new Set;
+  const restored = new Set;
+  for (let round = 0;round < MAX_PROJECT_RESTORE_ROUNDS; round++) {
+    let changed = false;
+    for (const issuePath of args.collectIssuePaths(args.mergedRaw)) {
+      const contribution = projectContributionPath(args.projectRaw, issuePath);
+      if (contribution === undefined || contribution.length === 0)
+        continue;
+      const trusted = displacedTrustedValue(args.trustedRaw, contribution);
+      if (trusted === undefined)
+        continue;
+      const key = trusted.path.map(String).join(".");
+      if (restored.has(key))
+        continue;
+      writeOwnPath(args.mergedRaw, trusted.path, trusted.value);
+      restored.add(key);
+      restoredTopLevelKeys.add(String(trusted.path[0]));
+      changed = true;
+      warnings.push(`Ignoring invalid ${key} from project config and keeping the user-level value (security: a repository cannot reset user settings by supplying an invalid value).`);
+    }
+    if (!changed)
+      break;
+  }
+  return { warnings, restoredTopLevelKeys: [...restoredTopLevelKeys] };
+}
+var PROJECT_COMMAND_STRING_FIELDS = ["description", "agent", "model"];
+function wellFormedCommand(value) {
+  if (!isPlainObject(value))
+    return;
+  if (typeof value.template !== "string" || value.template.trim().length === 0)
+    return;
+  const command = { template: value.template };
+  for (const field of PROJECT_COMMAND_STRING_FIELDS) {
+    if (value[field] === undefined)
+      continue;
+    if (typeof value[field] !== "string")
+      return;
+    command[field] = value[field];
+  }
+  if (value.subtask !== undefined) {
+    if (typeof value.subtask !== "boolean")
+      return;
+    command.subtask = value.subtask;
+  }
+  return command;
+}
+function constrainProjectCommands(args) {
+  if (!("command" in args.projectRaw))
+    return [];
+  const warnings = [];
+  const trustedCommands = isPlainObject(args.trustedRaw.command) ? args.trustedRaw.command : undefined;
+  const merged = { ...trustedCommands ?? {} };
+  const projectCommands = args.projectRaw.command;
+  if (!isPlainObject(projectCommands)) {
+    warnings.push("Ignoring command from project config (it must be an object of named commands).");
+  } else {
+    for (const [name, value] of Object.entries(projectCommands)) {
+      if (trustedCommands && Object.hasOwn(trustedCommands, name)) {
+        warnings.push(`Ignoring command.${name} from project config (security: a repository cannot replace a command defined in user config).`);
+        continue;
+      }
+      if (args.reservedNames.includes(name)) {
+        warnings.push(`Ignoring command.${name} from project config (security: a repository cannot replace a built-in Magic Context command).`);
+        continue;
+      }
+      const command = wellFormedCommand(value);
+      if (!command) {
+        warnings.push(`Ignoring command.${name} from project config (it needs a non-empty string template; description, agent and model must be strings and subtask a boolean).`);
+        continue;
+      }
+      Object.defineProperty(merged, name, {
+        value: command,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    }
+  }
+  if (Object.keys(merged).length === 0)
+    delete args.mergedRaw.command;
+  else
+    args.mergedRaw.command = merged;
+  return warnings;
+}
+
+// src/config/index.ts
+import { existsSync as existsSync4 } from "node:fs";
+
+// src/shared/builtin-commands.ts
+var COMPACTION_ENABLED_PATH2 = `compaction${".enabled"}`;
+function getMagicContextBuiltinCommands(compactionEnabled = true) {
+  const unavailableInCompactionOff = (command) => `Unavailable when ${COMPACTION_ENABLED_PATH2} is false: /${command} manages compacted history.`;
+  return {
+    "ctx-status": {
+      template: "ctx-status",
+      description: "Show magic context status, pending queue, cache TTL, and debug info"
+    },
+    "ctx-recomp": {
+      template: "ctx-recomp",
+      description: compactionEnabled ? "Rebuild compressed history from raw history (full or <start>-<end> range); memories are not changed" : unavailableInCompactionOff("ctx-recomp")
+    },
+    "ctx-wrapup": {
+      template: "ctx-wrapup",
+      description: compactionEnabled ? "Compact older live history while keeping the newest messages raw" : unavailableInCompactionOff("ctx-wrapup")
+    },
+    "ctx-flush": {
+      template: "ctx-flush",
+      description: compactionEnabled ? "Force-process all pending magic context operations immediately" : unavailableInCompactionOff("ctx-flush")
+    },
+    "ctx-dream": {
+      template: "ctx-dream",
+      description: "Run the hidden dreamer maintenance pass for this project now"
+    },
+    "ctx-embed": {
+      template: "ctx-embed",
+      description: "Embedding status, or start/pause history compartment embedding (start | pause)"
+    }
+  };
+}
+
+// src/shared/config-diagnostics.ts
+var CONFIG_WARNING_CLASS = {
+  FILE_PARSE: "file-parse",
+  FILE_IO: "file-io",
+  INVALID_LEAF: "invalid-leaf"
+};
+var claimedFailures = new Set;
+
+// src/shared/jsonc-parser.ts
+import { existsSync, readFileSync } from "node:fs";
+
+// ../../node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/scanner.js
+function createScanner(text, ignoreTrivia = false) {
+  const len = text.length;
+  let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
+  function scanHexDigits(count, exact) {
+    let digits = 0;
+    let value = 0;
+    while (digits < count || !exact) {
+      let ch = text.charCodeAt(pos);
+      if (ch >= 48 && ch <= 57) {
+        value = value * 16 + ch - 48;
+      } else if (ch >= 65 && ch <= 70) {
+        value = value * 16 + ch - 65 + 10;
+      } else if (ch >= 97 && ch <= 102) {
+        value = value * 16 + ch - 97 + 10;
+      } else {
+        break;
+      }
+      pos++;
+      digits++;
+    }
+    if (digits < count) {
+      value = -1;
+    }
+    return value;
+  }
+  function setPosition(newPosition) {
+    pos = newPosition;
+    value = "";
+    tokenOffset = 0;
+    token = 16;
+    scanError = 0;
+  }
+  function scanNumber() {
+    let start = pos;
+    if (text.charCodeAt(pos) === 48) {
+      pos++;
+    } else {
+      pos++;
+      while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+      }
+    }
+    if (pos < text.length && text.charCodeAt(pos) === 46) {
+      pos++;
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+      } else {
+        scanError = 3;
+        return text.substring(start, pos);
+      }
+    }
+    let end = pos;
+    if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
+      pos++;
+      if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) {
+        pos++;
+      }
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+        end = pos;
+      } else {
+        scanError = 3;
+      }
+    }
+    return text.substring(start, end);
+  }
+  function scanString() {
+    let result = "", start = pos;
+    while (true) {
+      if (pos >= len) {
+        result += text.substring(start, pos);
+        scanError = 2;
+        break;
+      }
+      const ch = text.charCodeAt(pos);
+      if (ch === 34) {
+        result += text.substring(start, pos);
+        pos++;
+        break;
+      }
+      if (ch === 92) {
+        result += text.substring(start, pos);
+        pos++;
+        if (pos >= len) {
+          scanError = 2;
+          break;
+        }
+        const ch2 = text.charCodeAt(pos++);
+        switch (ch2) {
+          case 34:
+            result += '"';
+            break;
+          case 92:
+            result += "\\";
+            break;
+          case 47:
+            result += "/";
+            break;
+          case 98:
+            result += "\b";
+            break;
+          case 102:
+            result += "\f";
+            break;
+          case 110:
+            result += `
+`;
+            break;
+          case 114:
+            result += "\r";
+            break;
+          case 116:
+            result += "\t";
+            break;
+          case 117:
+            const ch3 = scanHexDigits(4, true);
+            if (ch3 >= 0) {
+              result += String.fromCharCode(ch3);
+            } else {
+              scanError = 4;
+            }
+            break;
+          default:
+            scanError = 5;
+        }
+        start = pos;
+        continue;
+      }
+      if (ch >= 0 && ch <= 31) {
+        if (isLineBreak(ch)) {
+          result += text.substring(start, pos);
+          scanError = 2;
+          break;
+        } else {
+          scanError = 6;
+        }
+      }
+      pos++;
+    }
+    return result;
+  }
+  function scanNext() {
+    value = "";
+    scanError = 0;
+    tokenOffset = pos;
+    lineStartOffset = lineNumber;
+    prevTokenLineStartOffset = tokenLineStartOffset;
+    if (pos >= len) {
+      tokenOffset = len;
+      return token = 17;
+    }
+    let code = text.charCodeAt(pos);
+    if (isWhiteSpace(code)) {
+      do {
+        pos++;
+        value += String.fromCharCode(code);
+        code = text.charCodeAt(pos);
+      } while (isWhiteSpace(code));
+      return token = 15;
+    }
+    if (isLineBreak(code)) {
+      pos++;
+      value += String.fromCharCode(code);
+      if (code === 13 && text.charCodeAt(pos) === 10) {
+        pos++;
+        value += `
+`;
+      }
+      lineNumber++;
+      tokenLineStartOffset = pos;
+      return token = 14;
+    }
+    switch (code) {
+      case 123:
+        pos++;
+        return token = 1;
+      case 125:
+        pos++;
+        return token = 2;
+      case 91:
+        pos++;
+        return token = 3;
+      case 93:
+        pos++;
+        return token = 4;
+      case 58:
+        pos++;
+        return token = 6;
+      case 44:
+        pos++;
+        return token = 5;
+      case 34:
+        pos++;
+        value = scanString();
+        return token = 10;
+      case 47:
+        const start = pos - 1;
+        if (text.charCodeAt(pos + 1) === 47) {
+          pos += 2;
+          while (pos < len) {
+            if (isLineBreak(text.charCodeAt(pos))) {
+              break;
+            }
+            pos++;
+          }
+          value = text.substring(start, pos);
+          return token = 12;
+        }
+        if (text.charCodeAt(pos + 1) === 42) {
+          pos += 2;
+          const safeLength = len - 1;
+          let commentClosed = false;
+          while (pos < safeLength) {
+            const ch = text.charCodeAt(pos);
+            if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
+              pos += 2;
+              commentClosed = true;
+              break;
+            }
+            pos++;
+            if (isLineBreak(ch)) {
+              if (ch === 13 && text.charCodeAt(pos) === 10) {
+                pos++;
+              }
+              lineNumber++;
+              tokenLineStartOffset = pos;
+            }
+          }
+          if (!commentClosed) {
+            pos++;
+            scanError = 1;
+          }
+          value = text.substring(start, pos);
+          return token = 13;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+      case 45:
+        value += String.fromCharCode(code);
+        pos++;
+        if (pos === len || !isDigit(text.charCodeAt(pos))) {
+          return token = 16;
+        }
+      case 48:
+      case 49:
+      case 50:
+      case 51:
+      case 52:
+      case 53:
+      case 54:
+      case 55:
+      case 56:
+      case 57:
+        value += scanNumber();
+        return token = 11;
+      default:
+        while (pos < len && isUnknownContentCharacter(code)) {
+          pos++;
+          code = text.charCodeAt(pos);
+        }
+        if (tokenOffset !== pos) {
+          value = text.substring(tokenOffset, pos);
+          switch (value) {
+            case "true":
+              return token = 8;
+            case "false":
+              return token = 9;
+            case "null":
+              return token = 7;
+          }
+          return token = 16;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+    }
+  }
+  function isUnknownContentCharacter(code) {
+    if (isWhiteSpace(code) || isLineBreak(code)) {
+      return false;
+    }
+    switch (code) {
+      case 125:
+      case 93:
+      case 123:
+      case 91:
+      case 34:
+      case 58:
+      case 44:
+      case 47:
+        return false;
+    }
+    return true;
+  }
+  function scanNextNonTrivia() {
+    let result;
+    do {
+      result = scanNext();
+    } while (result >= 12 && result <= 15);
+    return result;
+  }
+  return {
+    setPosition,
+    getPosition: () => pos,
+    scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+    getToken: () => token,
+    getTokenValue: () => value,
+    getTokenOffset: () => tokenOffset,
+    getTokenLength: () => pos - tokenOffset,
+    getTokenStartLine: () => lineStartOffset,
+    getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
+    getTokenError: () => scanError
+  };
+}
+function isWhiteSpace(ch) {
+  return ch === 32 || ch === 9;
+}
+function isLineBreak(ch) {
+  return ch === 10 || ch === 13;
+}
+function isDigit(ch) {
+  return ch >= 48 && ch <= 57;
+}
+var CharacterCodes;
+(function(CharacterCodes) {
+  CharacterCodes[CharacterCodes["lineFeed"] = 10] = "lineFeed";
+  CharacterCodes[CharacterCodes["carriageReturn"] = 13] = "carriageReturn";
+  CharacterCodes[CharacterCodes["space"] = 32] = "space";
+  CharacterCodes[CharacterCodes["_0"] = 48] = "_0";
+  CharacterCodes[CharacterCodes["_1"] = 49] = "_1";
+  CharacterCodes[CharacterCodes["_2"] = 50] = "_2";
+  CharacterCodes[CharacterCodes["_3"] = 51] = "_3";
+  CharacterCodes[CharacterCodes["_4"] = 52] = "_4";
+  CharacterCodes[CharacterCodes["_5"] = 53] = "_5";
+  CharacterCodes[CharacterCodes["_6"] = 54] = "_6";
+  CharacterCodes[CharacterCodes["_7"] = 55] = "_7";
+  CharacterCodes[CharacterCodes["_8"] = 56] = "_8";
+  CharacterCodes[CharacterCodes["_9"] = 57] = "_9";
+  CharacterCodes[CharacterCodes["a"] = 97] = "a";
+  CharacterCodes[CharacterCodes["b"] = 98] = "b";
+  CharacterCodes[CharacterCodes["c"] = 99] = "c";
+  CharacterCodes[CharacterCodes["d"] = 100] = "d";
+  CharacterCodes[CharacterCodes["e"] = 101] = "e";
+  CharacterCodes[CharacterCodes["f"] = 102] = "f";
+  CharacterCodes[CharacterCodes["g"] = 103] = "g";
+  CharacterCodes[CharacterCodes["h"] = 104] = "h";
+  CharacterCodes[CharacterCodes["i"] = 105] = "i";
+  CharacterCodes[CharacterCodes["j"] = 106] = "j";
+  CharacterCodes[CharacterCodes["k"] = 107] = "k";
+  CharacterCodes[CharacterCodes["l"] = 108] = "l";
+  CharacterCodes[CharacterCodes["m"] = 109] = "m";
+  CharacterCodes[CharacterCodes["n"] = 110] = "n";
+  CharacterCodes[CharacterCodes["o"] = 111] = "o";
+  CharacterCodes[CharacterCodes["p"] = 112] = "p";
+  CharacterCodes[CharacterCodes["q"] = 113] = "q";
+  CharacterCodes[CharacterCodes["r"] = 114] = "r";
+  CharacterCodes[CharacterCodes["s"] = 115] = "s";
+  CharacterCodes[CharacterCodes["t"] = 116] = "t";
+  CharacterCodes[CharacterCodes["u"] = 117] = "u";
+  CharacterCodes[CharacterCodes["v"] = 118] = "v";
+  CharacterCodes[CharacterCodes["w"] = 119] = "w";
+  CharacterCodes[CharacterCodes["x"] = 120] = "x";
+  CharacterCodes[CharacterCodes["y"] = 121] = "y";
+  CharacterCodes[CharacterCodes["z"] = 122] = "z";
+  CharacterCodes[CharacterCodes["A"] = 65] = "A";
+  CharacterCodes[CharacterCodes["B"] = 66] = "B";
+  CharacterCodes[CharacterCodes["C"] = 67] = "C";
+  CharacterCodes[CharacterCodes["D"] = 68] = "D";
+  CharacterCodes[CharacterCodes["E"] = 69] = "E";
+  CharacterCodes[CharacterCodes["F"] = 70] = "F";
+  CharacterCodes[CharacterCodes["G"] = 71] = "G";
+  CharacterCodes[CharacterCodes["H"] = 72] = "H";
+  CharacterCodes[CharacterCodes["I"] = 73] = "I";
+  CharacterCodes[CharacterCodes["J"] = 74] = "J";
+  CharacterCodes[CharacterCodes["K"] = 75] = "K";
+  CharacterCodes[CharacterCodes["L"] = 76] = "L";
+  CharacterCodes[CharacterCodes["M"] = 77] = "M";
+  CharacterCodes[CharacterCodes["N"] = 78] = "N";
+  CharacterCodes[CharacterCodes["O"] = 79] = "O";
+  CharacterCodes[CharacterCodes["P"] = 80] = "P";
+  CharacterCodes[CharacterCodes["Q"] = 81] = "Q";
+  CharacterCodes[CharacterCodes["R"] = 82] = "R";
+  CharacterCodes[CharacterCodes["S"] = 83] = "S";
+  CharacterCodes[CharacterCodes["T"] = 84] = "T";
+  CharacterCodes[CharacterCodes["U"] = 85] = "U";
+  CharacterCodes[CharacterCodes["V"] = 86] = "V";
+  CharacterCodes[CharacterCodes["W"] = 87] = "W";
+  CharacterCodes[CharacterCodes["X"] = 88] = "X";
+  CharacterCodes[CharacterCodes["Y"] = 89] = "Y";
+  CharacterCodes[CharacterCodes["Z"] = 90] = "Z";
+  CharacterCodes[CharacterCodes["asterisk"] = 42] = "asterisk";
+  CharacterCodes[CharacterCodes["backslash"] = 92] = "backslash";
+  CharacterCodes[CharacterCodes["closeBrace"] = 125] = "closeBrace";
+  CharacterCodes[CharacterCodes["closeBracket"] = 93] = "closeBracket";
+  CharacterCodes[CharacterCodes["colon"] = 58] = "colon";
+  CharacterCodes[CharacterCodes["comma"] = 44] = "comma";
+  CharacterCodes[CharacterCodes["dot"] = 46] = "dot";
+  CharacterCodes[CharacterCodes["doubleQuote"] = 34] = "doubleQuote";
+  CharacterCodes[CharacterCodes["minus"] = 45] = "minus";
+  CharacterCodes[CharacterCodes["openBrace"] = 123] = "openBrace";
+  CharacterCodes[CharacterCodes["openBracket"] = 91] = "openBracket";
+  CharacterCodes[CharacterCodes["plus"] = 43] = "plus";
+  CharacterCodes[CharacterCodes["slash"] = 47] = "slash";
+  CharacterCodes[CharacterCodes["formFeed"] = 12] = "formFeed";
+  CharacterCodes[CharacterCodes["tab"] = 9] = "tab";
+})(CharacterCodes || (CharacterCodes = {}));
+
+// ../../node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/string-intern.js
+var cachedSpaces = new Array(20).fill(0).map((_, index) => {
+  return " ".repeat(index);
+});
+var maxCachedValues = 200;
+var cachedBreakLinesWithSpaces = {
+  " ": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `
+` + " ".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + " ".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `\r
+` + " ".repeat(index);
+    })
+  },
+  "\t": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `
+` + "\t".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + "\t".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `\r
+` + "\t".repeat(index);
+    })
+  }
+};
+var supportedEols = [`
+`, "\r", `\r
+`];
+
+// ../../node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/format.js
+function format(documentText, range, options) {
+  let initialIndentLevel;
+  let formatText;
+  let formatTextStart;
+  let rangeStart;
+  let rangeEnd;
+  if (range) {
+    rangeStart = range.offset;
+    rangeEnd = rangeStart + range.length;
+    formatTextStart = rangeStart;
+    while (formatTextStart > 0 && !isEOL(documentText, formatTextStart - 1)) {
+      formatTextStart--;
+    }
+    let endOffset = rangeEnd;
+    while (endOffset < documentText.length && !isEOL(documentText, endOffset)) {
+      endOffset++;
+    }
+    formatText = documentText.substring(formatTextStart, endOffset);
+    initialIndentLevel = computeIndentLevel(formatText, options);
+  } else {
+    formatText = documentText;
+    initialIndentLevel = 0;
+    formatTextStart = 0;
+    rangeStart = 0;
+    rangeEnd = documentText.length;
+  }
+  const eol = getEOL(options, documentText);
+  const eolFastPathSupported = supportedEols.includes(eol);
+  let numberLineBreaks = 0;
+  let indentLevel = 0;
+  let indentValue;
+  if (options.insertSpaces) {
+    indentValue = cachedSpaces[options.tabSize || 4] ?? repeat(cachedSpaces[1], options.tabSize || 4);
+  } else {
+    indentValue = "\t";
+  }
+  const indentType = indentValue === "\t" ? "\t" : " ";
+  let scanner = createScanner(formatText, false);
+  let hasError = false;
+  function newLinesAndIndent() {
+    if (numberLineBreaks > 1) {
+      return repeat(eol, numberLineBreaks) + repeat(indentValue, initialIndentLevel + indentLevel);
+    }
+    const amountOfSpaces = indentValue.length * (initialIndentLevel + indentLevel);
+    if (!eolFastPathSupported || amountOfSpaces > cachedBreakLinesWithSpaces[indentType][eol].length) {
+      return eol + repeat(indentValue, initialIndentLevel + indentLevel);
+    }
+    if (amountOfSpaces <= 0) {
+      return eol;
+    }
+    return cachedBreakLinesWithSpaces[indentType][eol][amountOfSpaces];
+  }
+  function scanNext() {
+    let token = scanner.scan();
+    numberLineBreaks = 0;
+    while (token === 15 || token === 14) {
+      if (token === 14 && options.keepLines) {
+        numberLineBreaks += 1;
+      } else if (token === 14) {
+        numberLineBreaks = 1;
+      }
+      token = scanner.scan();
+    }
+    hasError = token === 16 || scanner.getTokenError() !== 0;
+    return token;
+  }
+  const editOperations = [];
+  function addEdit(text, startOffset, endOffset) {
+    if (!hasError && (!range || startOffset < rangeEnd && endOffset > rangeStart) && documentText.substring(startOffset, endOffset) !== text) {
+      editOperations.push({ offset: startOffset, length: endOffset - startOffset, content: text });
+    }
+  }
+  let firstToken = scanNext();
+  if (options.keepLines && numberLineBreaks > 0) {
+    addEdit(repeat(eol, numberLineBreaks), 0, 0);
+  }
+  if (firstToken !== 17) {
+    let firstTokenStart = scanner.getTokenOffset() + formatTextStart;
+    let initialIndent = indentValue.length * initialIndentLevel < 20 && options.insertSpaces ? cachedSpaces[indentValue.length * initialIndentLevel] : repeat(indentValue, initialIndentLevel);
+    addEdit(initialIndent, formatTextStart, firstTokenStart);
+  }
+  while (firstToken !== 17) {
+    let firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+    let secondToken = scanNext();
+    let replaceContent = "";
+    let needsLineBreak = false;
+    while (numberLineBreaks === 0 && (secondToken === 12 || secondToken === 13)) {
+      let commentTokenStart = scanner.getTokenOffset() + formatTextStart;
+      addEdit(cachedSpaces[1], firstTokenEnd, commentTokenStart);
+      firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+      needsLineBreak = secondToken === 12;
+      replaceContent = needsLineBreak ? newLinesAndIndent() : "";
+      secondToken = scanNext();
+    }
+    if (secondToken === 2) {
+      if (firstToken !== 1) {
+        indentLevel--;
+      }
+      if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && firstToken !== 1) {
+        replaceContent = newLinesAndIndent();
+      } else if (options.keepLines) {
+        replaceContent = cachedSpaces[1];
+      }
+    } else if (secondToken === 4) {
+      if (firstToken !== 3) {
+        indentLevel--;
+      }
+      if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && firstToken !== 3) {
+        replaceContent = newLinesAndIndent();
+      } else if (options.keepLines) {
+        replaceContent = cachedSpaces[1];
+      }
+    } else {
+      switch (firstToken) {
+        case 3:
+        case 1:
+          indentLevel++;
+          if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) {
+            replaceContent = newLinesAndIndent();
+          } else {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 5:
+          if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) {
+            replaceContent = newLinesAndIndent();
+          } else {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 12:
+          replaceContent = newLinesAndIndent();
+          break;
+        case 13:
+          if (numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else if (!needsLineBreak) {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 6:
+          if (options.keepLines && numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else if (!needsLineBreak) {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 10:
+          if (options.keepLines && numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else if (secondToken === 6 && !needsLineBreak) {
+            replaceContent = "";
+          }
+          break;
+        case 7:
+        case 8:
+        case 9:
+        case 11:
+        case 2:
+        case 4:
+          if (options.keepLines && numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else {
+            if ((secondToken === 12 || secondToken === 13) && !needsLineBreak) {
+              replaceContent = cachedSpaces[1];
+            } else if (secondToken !== 5 && secondToken !== 17) {
+              hasError = true;
+            }
+          }
+          break;
+        case 16:
+          hasError = true;
+          break;
+      }
+      if (numberLineBreaks > 0 && (secondToken === 12 || secondToken === 13)) {
+        replaceContent = newLinesAndIndent();
+      }
+    }
+    if (secondToken === 17) {
+      if (options.keepLines && numberLineBreaks > 0) {
+        replaceContent = newLinesAndIndent();
+      } else {
+        replaceContent = options.insertFinalNewline ? eol : "";
+      }
+    }
+    const secondTokenStart = scanner.getTokenOffset() + formatTextStart;
+    addEdit(replaceContent, firstTokenEnd, secondTokenStart);
+    firstToken = secondToken;
+  }
+  return editOperations;
+}
+function repeat(s, count) {
+  let result = "";
+  for (let i = 0;i < count; i++) {
+    result += s;
+  }
+  return result;
+}
+function computeIndentLevel(content, options) {
+  let i = 0;
+  let nChars = 0;
+  const tabSize = options.tabSize || 4;
+  while (i < content.length) {
+    let ch = content.charAt(i);
+    if (ch === cachedSpaces[1]) {
+      nChars++;
+    } else if (ch === "\t") {
+      nChars += tabSize;
+    } else {
+      break;
+    }
+    i++;
+  }
+  return Math.floor(nChars / tabSize);
+}
+function getEOL(options, text) {
+  for (let i = 0;i < text.length; i++) {
+    const ch = text.charAt(i);
+    if (ch === "\r") {
+      if (i + 1 < text.length && text.charAt(i + 1) === `
+`) {
+        return `\r
+`;
+      }
+      return "\r";
+    } else if (ch === `
+`) {
+      return `
+`;
+    }
+  }
+  return options && options.eol || `
+`;
+}
+function isEOL(text, offset) {
+  return `\r
+`.indexOf(text.charAt(offset)) !== -1;
+}
+
+// ../../node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/parser.js
+var ParseOptions;
+(function(ParseOptions) {
+  ParseOptions.DEFAULT = {
+    allowTrailingComma: false
+  };
+})(ParseOptions || (ParseOptions = {}));
+function parse(text, errors = [], options = ParseOptions.DEFAULT) {
+  let currentProperty = null;
+  let currentParent = [];
+  const previousParents = [];
+  function onValue(value) {
+    if (Array.isArray(currentParent)) {
+      currentParent.push(value);
+    } else if (currentProperty !== null) {
+      currentParent[currentProperty] = value;
+    }
+  }
+  const visitor = {
+    onObjectBegin: () => {
+      const object = {};
+      onValue(object);
+      previousParents.push(currentParent);
+      currentParent = object;
+      currentProperty = null;
+    },
+    onObjectProperty: (name) => {
+      currentProperty = name;
+    },
+    onObjectEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onArrayBegin: () => {
+      const array = [];
+      onValue(array);
+      previousParents.push(currentParent);
+      currentParent = array;
+      currentProperty = null;
+    },
+    onArrayEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onLiteralValue: onValue,
+    onError: (error, offset, length) => {
+      errors.push({ error, offset, length });
+    }
+  };
+  visit(text, visitor, options);
+  return currentParent[0];
+}
+function parseTree(text, errors = [], options = ParseOptions.DEFAULT) {
+  let currentParent = { type: "array", offset: -1, length: -1, children: [], parent: undefined };
+  function ensurePropertyComplete(endOffset) {
+    if (currentParent.type === "property") {
+      currentParent.length = endOffset - currentParent.offset;
+      currentParent = currentParent.parent;
+    }
+  }
+  function onValue(valueNode) {
+    currentParent.children.push(valueNode);
+    return valueNode;
+  }
+  const visitor = {
+    onObjectBegin: (offset) => {
+      currentParent = onValue({ type: "object", offset, length: -1, parent: currentParent, children: [] });
+    },
+    onObjectProperty: (name, offset, length) => {
+      currentParent = onValue({ type: "property", offset, length: -1, parent: currentParent, children: [] });
+      currentParent.children.push({ type: "string", value: name, offset, length, parent: currentParent });
+    },
+    onObjectEnd: (offset, length) => {
+      ensurePropertyComplete(offset + length);
+      currentParent.length = offset + length - currentParent.offset;
+      currentParent = currentParent.parent;
+      ensurePropertyComplete(offset + length);
+    },
+    onArrayBegin: (offset, length) => {
+      currentParent = onValue({ type: "array", offset, length: -1, parent: currentParent, children: [] });
+    },
+    onArrayEnd: (offset, length) => {
+      currentParent.length = offset + length - currentParent.offset;
+      currentParent = currentParent.parent;
+      ensurePropertyComplete(offset + length);
+    },
+    onLiteralValue: (value, offset, length) => {
+      onValue({ type: getNodeType(value), offset, length, parent: currentParent, value });
+      ensurePropertyComplete(offset + length);
+    },
+    onSeparator: (sep, offset, length) => {
+      if (currentParent.type === "property") {
+        if (sep === ":") {
+          currentParent.colonOffset = offset;
+        } else if (sep === ",") {
+          ensurePropertyComplete(offset);
+        }
+      }
+    },
+    onError: (error, offset, length) => {
+      errors.push({ error, offset, length });
+    }
+  };
+  visit(text, visitor, options);
+  const result = currentParent.children[0];
+  if (result) {
+    delete result.parent;
+  }
+  return result;
+}
+function findNodeAtLocation(root, path) {
+  if (!root) {
+    return;
+  }
+  let node = root;
+  for (let segment of path) {
+    if (typeof segment === "string") {
+      if (node.type !== "object" || !Array.isArray(node.children)) {
+        return;
+      }
+      let found = false;
+      for (const propertyNode of node.children) {
+        if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment && propertyNode.children.length === 2) {
+          node = propertyNode.children[1];
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        return;
+      }
+    } else {
+      const index = segment;
+      if (node.type !== "array" || index < 0 || !Array.isArray(node.children) || index >= node.children.length) {
+        return;
+      }
+      node = node.children[index];
+    }
+  }
+  return node;
+}
+function getNodeValue(node) {
+  switch (node.type) {
+    case "array":
+      return node.children.map(getNodeValue);
+    case "object":
+      const obj = Object.create(null);
+      for (let prop of node.children) {
+        const valueNode = prop.children[1];
+        if (valueNode) {
+          obj[prop.children[0].value] = getNodeValue(valueNode);
+        }
+      }
+      return obj;
+    case "null":
+    case "string":
+    case "number":
+    case "boolean":
+      return node.value;
+    default:
+      return;
+  }
+}
+function visit(text, visitor, options = ParseOptions.DEFAULT) {
+  const _scanner = createScanner(text, false);
+  const _jsonPath = [];
+  let suppressedCallbacks = 0;
+  function toNoArgVisit(visitFunction) {
+    return visitFunction ? () => suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisit(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisitWithPath(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+  }
+  function toBeginVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks++;
+      } else {
+        let cbReturn = visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice());
+        if (cbReturn === false) {
+          suppressedCallbacks = 1;
+        }
+      }
+    } : () => true;
+  }
+  function toEndVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks--;
+      }
+      if (suppressedCallbacks === 0) {
+        visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
+      }
+    } : () => true;
+  }
+  const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
+  const disallowComments = options && options.disallowComments;
+  const allowTrailingComma = options && options.allowTrailingComma;
+  function scanNext() {
+    while (true) {
+      const token = _scanner.scan();
+      switch (_scanner.getTokenError()) {
+        case 4:
+          handleError(14);
+          break;
+        case 5:
+          handleError(15);
+          break;
+        case 3:
+          handleError(13);
+          break;
+        case 1:
+          if (!disallowComments) {
+            handleError(11);
+          }
+          break;
+        case 2:
+          handleError(12);
+          break;
+        case 6:
+          handleError(16);
+          break;
+      }
+      switch (token) {
+        case 12:
+        case 13:
+          if (disallowComments) {
+            handleError(10);
+          } else {
+            onComment();
+          }
+          break;
+        case 16:
+          handleError(1);
+          break;
+        case 15:
+        case 14:
+          break;
+        default:
+          return token;
+      }
+    }
+  }
+  function handleError(error, skipUntilAfter = [], skipUntil = []) {
+    onError(error);
+    if (skipUntilAfter.length + skipUntil.length > 0) {
+      let token = _scanner.getToken();
+      while (token !== 17) {
+        if (skipUntilAfter.indexOf(token) !== -1) {
+          scanNext();
+          break;
+        } else if (skipUntil.indexOf(token) !== -1) {
+          break;
+        }
+        token = scanNext();
+      }
+    }
+  }
+  function parseString(isValue) {
+    const value = _scanner.getTokenValue();
+    if (isValue) {
+      onLiteralValue(value);
+    } else {
+      onObjectProperty(value);
+      _jsonPath.push(value);
+    }
+    scanNext();
+    return true;
+  }
+  function parseLiteral() {
+    switch (_scanner.getToken()) {
+      case 11:
+        const tokenValue = _scanner.getTokenValue();
+        let value = Number(tokenValue);
+        if (isNaN(value)) {
+          handleError(2);
+          value = 0;
+        }
+        onLiteralValue(value);
+        break;
+      case 7:
+        onLiteralValue(null);
+        break;
+      case 8:
+        onLiteralValue(true);
+        break;
+      case 9:
+        onLiteralValue(false);
+        break;
+      default:
+        return false;
+    }
+    scanNext();
+    return true;
+  }
+  function parseProperty() {
+    if (_scanner.getToken() !== 10) {
+      handleError(3, [], [2, 5]);
+      return false;
+    }
+    parseString(false);
+    if (_scanner.getToken() === 6) {
+      onSeparator(":");
+      scanNext();
+      if (!parseValue()) {
+        handleError(4, [], [2, 5]);
+      }
+    } else {
+      handleError(5, [], [2, 5]);
+    }
+    _jsonPath.pop();
+    return true;
+  }
+  function parseObject() {
+    onObjectBegin();
+    scanNext();
+    let needsComma = false;
+    while (_scanner.getToken() !== 2 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 2 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (!parseProperty()) {
+        handleError(4, [], [2, 5]);
+      }
+      needsComma = true;
+    }
+    onObjectEnd();
+    if (_scanner.getToken() !== 2) {
+      handleError(7, [2], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseArray() {
+    onArrayBegin();
+    scanNext();
+    let isFirstElement = true;
+    let needsComma = false;
+    while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 4 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (isFirstElement) {
+        _jsonPath.push(0);
+        isFirstElement = false;
+      } else {
+        _jsonPath[_jsonPath.length - 1]++;
+      }
+      if (!parseValue()) {
+        handleError(4, [], [4, 5]);
+      }
+      needsComma = true;
+    }
+    onArrayEnd();
+    if (!isFirstElement) {
+      _jsonPath.pop();
+    }
+    if (_scanner.getToken() !== 4) {
+      handleError(8, [4], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseValue() {
+    switch (_scanner.getToken()) {
+      case 3:
+        return parseArray();
+      case 1:
+        return parseObject();
+      case 10:
+        return parseString(true);
+      default:
+        return parseLiteral();
+    }
+  }
+  scanNext();
+  if (_scanner.getToken() === 17) {
+    if (options.allowEmptyContent) {
+      return true;
+    }
+    handleError(4, [], []);
+    return false;
+  }
+  if (!parseValue()) {
+    handleError(4, [], []);
+    return false;
+  }
+  if (_scanner.getToken() !== 17) {
+    handleError(9, [], []);
+  }
+  return true;
+}
+function getNodeType(value) {
+  switch (typeof value) {
+    case "boolean":
+      return "boolean";
+    case "number":
+      return "number";
+    case "string":
+      return "string";
+    case "object": {
+      if (!value) {
+        return "null";
+      } else if (Array.isArray(value)) {
+        return "array";
+      }
+      return "object";
+    }
+    default:
+      return "null";
+  }
+}
+
+// ../../node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/edit.js
+function setProperty(text, originalPath, value, options) {
+  const path = originalPath.slice();
+  const errors = [];
+  const root = parseTree(text, errors);
+  let parent = undefined;
+  let lastSegment = undefined;
+  while (path.length > 0) {
+    lastSegment = path.pop();
+    parent = findNodeAtLocation(root, path);
+    if (parent === undefined && value !== undefined) {
+      if (typeof lastSegment === "string") {
+        value = { [lastSegment]: value };
+      } else {
+        value = [value];
+      }
+    } else {
+      break;
+    }
+  }
+  if (!parent) {
+    if (value === undefined) {
+      throw new Error("Can not delete in empty document");
+    }
+    return withFormatting(text, { offset: root ? root.offset : 0, length: root ? root.length : 0, content: JSON.stringify(value) }, options);
+  } else if (parent.type === "object" && typeof lastSegment === "string" && Array.isArray(parent.children)) {
+    const existing = findNodeAtLocation(parent, [lastSegment]);
+    if (existing !== undefined) {
+      if (value === undefined) {
+        if (!existing.parent) {
+          throw new Error("Malformed AST");
+        }
+        const propertyIndex = parent.children.indexOf(existing.parent);
+        let removeBegin;
+        let removeEnd = existing.parent.offset + existing.parent.length;
+        if (propertyIndex > 0) {
+          let previous = parent.children[propertyIndex - 1];
+          removeBegin = previous.offset + previous.length;
+        } else {
+          removeBegin = parent.offset + 1;
+          if (parent.children.length > 1) {
+            let next = parent.children[1];
+            removeEnd = next.offset;
+          }
+        }
+        return withFormatting(text, { offset: removeBegin, length: removeEnd - removeBegin, content: "" }, options);
+      } else {
+        return withFormatting(text, { offset: existing.offset, length: existing.length, content: JSON.stringify(value) }, options);
+      }
+    } else {
+      if (value === undefined) {
+        return [];
+      }
+      const newProperty = `${JSON.stringify(lastSegment)}: ${JSON.stringify(value)}`;
+      const index = options.getInsertionIndex ? options.getInsertionIndex(parent.children.map((p) => p.children[0].value)) : parent.children.length;
+      let edit;
+      if (index > 0) {
+        let previous = parent.children[index - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      } else if (parent.children.length === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty };
+      } else {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty + "," };
+      }
+      return withFormatting(text, edit, options);
+    }
+  } else if (parent.type === "array" && typeof lastSegment === "number" && Array.isArray(parent.children)) {
+    const insertIndex = lastSegment;
+    if (insertIndex === -1) {
+      const newProperty = `${JSON.stringify(value)}`;
+      let edit;
+      if (parent.children.length === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty };
+      } else {
+        const previous = parent.children[parent.children.length - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      }
+      return withFormatting(text, edit, options);
+    } else if (value === undefined && parent.children.length >= 0) {
+      const removalIndex = lastSegment;
+      const toRemove = parent.children[removalIndex];
+      let edit;
+      if (parent.children.length === 1) {
+        edit = { offset: parent.offset + 1, length: parent.length - 2, content: "" };
+      } else if (parent.children.length - 1 === removalIndex) {
+        let previous = parent.children[removalIndex - 1];
+        let offset = previous.offset + previous.length;
+        let parentEndOffset = parent.offset + parent.length;
+        edit = { offset, length: parentEndOffset - 2 - offset, content: "" };
+      } else {
+        edit = { offset: toRemove.offset, length: parent.children[removalIndex + 1].offset - toRemove.offset, content: "" };
+      }
+      return withFormatting(text, edit, options);
+    } else if (value !== undefined) {
+      let edit;
+      const newProperty = `${JSON.stringify(value)}`;
+      if (!options.isArrayInsertion && parent.children.length > lastSegment) {
+        const toModify = parent.children[lastSegment];
+        edit = { offset: toModify.offset, length: toModify.length, content: newProperty };
+      } else if (parent.children.length === 0 || lastSegment === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: parent.children.length === 0 ? newProperty : newProperty + "," };
+      } else {
+        const index = lastSegment > parent.children.length ? parent.children.length : lastSegment;
+        const previous = parent.children[index - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      }
+      return withFormatting(text, edit, options);
+    } else {
+      throw new Error(`Can not ${value === undefined ? "remove" : options.isArrayInsertion ? "insert" : "modify"} Array index ${insertIndex} as length is not sufficient`);
+    }
+  } else {
+    throw new Error(`Can not add ${typeof lastSegment !== "number" ? "index" : "property"} to parent of type ${parent.type}`);
+  }
+}
+function withFormatting(text, edit, options) {
+  if (!options.formattingOptions) {
+    return [edit];
+  }
+  let newText = applyEdit(text, edit);
+  let begin = edit.offset;
+  let end = edit.offset + edit.content.length;
+  if (edit.length === 0 || edit.content.length === 0) {
+    while (begin > 0 && !isEOL(newText, begin - 1)) {
+      begin--;
+    }
+    while (end < newText.length && !isEOL(newText, end)) {
+      end++;
+    }
+  }
+  const edits = format(newText, { offset: begin, length: end - begin }, { ...options.formattingOptions, keepLines: false });
+  for (let i = edits.length - 1;i >= 0; i--) {
+    const edit = edits[i];
+    newText = applyEdit(newText, edit);
+    begin = Math.min(begin, edit.offset);
+    end = Math.max(end, edit.offset + edit.length);
+    end += edit.content.length - edit.length;
+  }
+  const editLength = text.length - (newText.length - end) - begin;
+  return [{ offset: begin, length: editLength, content: newText.substring(begin, end) }];
+}
+function applyEdit(text, edit) {
+  return text.substring(0, edit.offset) + edit.content + text.substring(edit.offset + edit.length);
+}
+
+// ../../node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/main.js
+var createScanner2 = createScanner;
+var ScanError;
+(function(ScanError) {
+  ScanError[ScanError["None"] = 0] = "None";
+  ScanError[ScanError["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+  ScanError[ScanError["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+  ScanError[ScanError["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+  ScanError[ScanError["InvalidUnicode"] = 4] = "InvalidUnicode";
+  ScanError[ScanError["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+  ScanError[ScanError["InvalidCharacter"] = 6] = "InvalidCharacter";
+})(ScanError || (ScanError = {}));
+var SyntaxKind;
+(function(SyntaxKind) {
+  SyntaxKind[SyntaxKind["OpenBraceToken"] = 1] = "OpenBraceToken";
+  SyntaxKind[SyntaxKind["CloseBraceToken"] = 2] = "CloseBraceToken";
+  SyntaxKind[SyntaxKind["OpenBracketToken"] = 3] = "OpenBracketToken";
+  SyntaxKind[SyntaxKind["CloseBracketToken"] = 4] = "CloseBracketToken";
+  SyntaxKind[SyntaxKind["CommaToken"] = 5] = "CommaToken";
+  SyntaxKind[SyntaxKind["ColonToken"] = 6] = "ColonToken";
+  SyntaxKind[SyntaxKind["NullKeyword"] = 7] = "NullKeyword";
+  SyntaxKind[SyntaxKind["TrueKeyword"] = 8] = "TrueKeyword";
+  SyntaxKind[SyntaxKind["FalseKeyword"] = 9] = "FalseKeyword";
+  SyntaxKind[SyntaxKind["StringLiteral"] = 10] = "StringLiteral";
+  SyntaxKind[SyntaxKind["NumericLiteral"] = 11] = "NumericLiteral";
+  SyntaxKind[SyntaxKind["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+  SyntaxKind[SyntaxKind["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+  SyntaxKind[SyntaxKind["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+  SyntaxKind[SyntaxKind["Trivia"] = 15] = "Trivia";
+  SyntaxKind[SyntaxKind["Unknown"] = 16] = "Unknown";
+  SyntaxKind[SyntaxKind["EOF"] = 17] = "EOF";
+})(SyntaxKind || (SyntaxKind = {}));
+var parse2 = parse;
+var parseTree2 = parseTree;
+var findNodeAtLocation2 = findNodeAtLocation;
+var getNodeValue2 = getNodeValue;
+var ParseErrorCode;
+(function(ParseErrorCode) {
+  ParseErrorCode[ParseErrorCode["InvalidSymbol"] = 1] = "InvalidSymbol";
+  ParseErrorCode[ParseErrorCode["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+  ParseErrorCode[ParseErrorCode["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+  ParseErrorCode[ParseErrorCode["ValueExpected"] = 4] = "ValueExpected";
+  ParseErrorCode[ParseErrorCode["ColonExpected"] = 5] = "ColonExpected";
+  ParseErrorCode[ParseErrorCode["CommaExpected"] = 6] = "CommaExpected";
+  ParseErrorCode[ParseErrorCode["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+  ParseErrorCode[ParseErrorCode["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+  ParseErrorCode[ParseErrorCode["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+  ParseErrorCode[ParseErrorCode["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+  ParseErrorCode[ParseErrorCode["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+  ParseErrorCode[ParseErrorCode["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+  ParseErrorCode[ParseErrorCode["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+  ParseErrorCode[ParseErrorCode["InvalidUnicode"] = 14] = "InvalidUnicode";
+  ParseErrorCode[ParseErrorCode["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+  ParseErrorCode[ParseErrorCode["InvalidCharacter"] = 16] = "InvalidCharacter";
+})(ParseErrorCode || (ParseErrorCode = {}));
+function printParseErrorCode(code) {
+  switch (code) {
+    case 1:
+      return "InvalidSymbol";
+    case 2:
+      return "InvalidNumberFormat";
+    case 3:
+      return "PropertyNameExpected";
+    case 4:
+      return "ValueExpected";
+    case 5:
+      return "ColonExpected";
+    case 6:
+      return "CommaExpected";
+    case 7:
+      return "CloseBraceExpected";
+    case 8:
+      return "CloseBracketExpected";
+    case 9:
+      return "EndOfFileExpected";
+    case 10:
+      return "InvalidCommentToken";
+    case 11:
+      return "UnexpectedEndOfComment";
+    case 12:
+      return "UnexpectedEndOfString";
+    case 13:
+      return "UnexpectedEndOfNumber";
+    case 14:
+      return "InvalidUnicode";
+    case 15:
+      return "InvalidEscapeCharacter";
+    case 16:
+      return "InvalidCharacter";
+  }
+  return "<unknown ParseErrorCode>";
+}
+function modify(text, path, value, options) {
+  return setProperty(text, path, value, options);
+}
+function applyEdits(text, edits) {
+  let sortedEdits = edits.slice(0).sort((a, b) => {
+    const diff = a.offset - b.offset;
+    if (diff === 0) {
+      return a.length - b.length;
+    }
+    return diff;
+  });
+  let lastModifiedOffset = text.length;
+  for (let i = sortedEdits.length - 1;i >= 0; i--) {
+    let e = sortedEdits[i];
+    if (e.offset + e.length <= lastModifiedOffset) {
+      text = applyEdit(text, e);
+    } else {
+      throw new Error("Overlapping edit");
+    }
+    lastModifiedOffset = e.offset;
+  }
+  return text;
+}
+
+// src/shared/jsonc-parser.ts
+function stripJsonComments(content) {
+  let result = "";
+  let inString = false;
+  let escaped = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  for (let index = 0;index < content.length; index += 1) {
+    const char = content[index];
+    const next = content[index + 1];
+    if (inLineComment) {
+      if (char === `
+`) {
+        inLineComment = false;
+        result += char;
+      }
+      continue;
+    }
+    if (inBlockComment) {
+      if (char === "*" && next === "/") {
+        inBlockComment = false;
+        index += 1;
+      }
+      continue;
+    }
+    if (inString) {
+      result += char;
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      result += char;
+      continue;
+    }
+    if (char === "/" && next === "/") {
+      inLineComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      inBlockComment = true;
+      index += 1;
+      continue;
+    }
+    result += char;
+  }
+  return result;
+}
+function stripTrailingCommas(content) {
+  let result = "";
+  let inString = false;
+  let escaped = false;
+  for (let index = 0;index < content.length; index += 1) {
+    const char = content[index];
+    if (inString) {
+      result += char;
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      result += char;
+      continue;
+    }
+    if (char === ",") {
+      let lookahead = index + 1;
+      while (lookahead < content.length && /\s/.test(content[lookahead] ?? "")) {
+        lookahead += 1;
+      }
+      const next = content[lookahead];
+      if (next === "}" || next === "]") {
+        continue;
+      }
+    }
+    result += char;
+  }
+  return result;
+}
+var PROTOTYPE_POLLUTION_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+function isPrototypePollutionKey(key) {
+  return PROTOTYPE_POLLUTION_KEYS.has(key);
+}
+function sanitizeParsedJson(value, options = {}, path = []) {
+  if (Array.isArray(value)) {
+    return value.map((entry, index) => sanitizeParsedJson(entry, options, [...path, index]));
+  }
+  if (value === null || typeof value !== "object")
+    return value;
+  const source = value;
+  const sourcePrototype = Object.getPrototypeOf(source);
+  if (sourcePrototype !== null && sourcePrototype !== Object.prototype) {
+    options.onRejectedKey?.([...path, "__proto__"]);
+  }
+  const sanitized = {};
+  for (const key of Object.keys(source)) {
+    if (isPrototypePollutionKey(key)) {
+      options.onRejectedKey?.([...path, key]);
+      continue;
+    }
+    Object.defineProperty(sanitized, key, {
+      value: sanitizeParsedJson(source[key], options, [...path, key]),
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  }
+  return sanitized;
+}
+function lineAndColumnAt(content, offset) {
+  const before = content.slice(0, Math.max(0, offset));
+  const lines = before.split(/\r?\n/);
+  return { line: lines.length, column: (lines.at(-1)?.length ?? 0) + 1 };
+}
+function parseIssue(content, error) {
+  const location = lineAndColumnAt(content, error.offset);
+  const code = printParseErrorCode(error.error);
+  const message = code.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase();
+  return {
+    ...location,
+    offset: error.offset,
+    length: error.length,
+    message
+  };
+}
+function normalizeJsoncParserObjects(value, options, path = []) {
+  if (Array.isArray(value)) {
+    return value.map((entry, index) => normalizeJsoncParserObjects(entry, options, [...path, String(index)]));
+  }
+  if (value === null || typeof value !== "object")
+    return value;
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) {
+    options.onRejectedKey?.([...path, "__proto__"]);
+  }
+  const normalized = {};
+  for (const [key, entry] of Object.entries(value)) {
+    Object.defineProperty(normalized, key, {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value: normalizeJsoncParserObjects(entry, options, [...path, key])
+    });
+  }
+  return normalized;
+}
+function parseJsoncRecovering(content, options = {}) {
+  const errors = [];
+  const parsed = parse2(content, errors, {
+    allowTrailingComma: true,
+    disallowComments: false,
+    allowEmptyContent: false
+  });
+  return {
+    value: sanitizeParsedJson(normalizeJsoncParserObjects(parsed, options), options),
+    issues: errors.map((error) => parseIssue(content, error))
+  };
+}
+function parseJsonc(content, options = {}) {
+  const normalized = stripTrailingCommas(stripJsonComments(content));
+  return sanitizeParsedJson(JSON.parse(normalized), options);
+}
+function readJsoncFile(filePath) {
+  try {
+    return parseJsonc(readFileSync(filePath, "utf-8"));
+  } catch (_error) {
+    return null;
+  }
+}
+function detectConfigFile(basePath) {
+  const jsoncPath = `${basePath}.jsonc`;
+  const jsonPath = `${basePath}.json`;
+  if (existsSync(jsoncPath)) {
+    return { format: "jsonc", path: jsoncPath };
+  }
+  if (existsSync(jsonPath)) {
+    return { format: "json", path: jsonPath };
+  }
+  return { format: "none", path: jsoncPath };
+}
+
+// src/config/migrate-config-location.ts
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join } from "node:path";
+
+// src/shared/jsonc-edit.ts
+var TOKEN_COMMA = 5;
+var TOKEN_EOF = 17;
+function parseDocument(text) {
+  const errors = [];
+  const root = parseTree2(text, errors, { allowTrailingComma: true });
+  if (!root || errors.length > 0) {
+    throw new Error("Cannot edit invalid JSONC");
+  }
+  return root;
+}
+function findNode(text, path) {
+  return findNodeAtLocation2(parseDocument(text), path);
+}
+function findComma(text, start, end) {
+  const scanner = createScanner2(text, false);
+  scanner.setPosition(start);
+  for (;; ) {
+    const kind = scanner.scan();
+    const offset = scanner.getTokenOffset();
+    if (kind === TOKEN_EOF || offset >= end)
+      return;
+    if (kind === TOKEN_COMMA) {
+      return {
+        offset,
+        length: scanner.getTokenLength(),
+        line: scanner.getTokenStartLine()
+      };
+    }
+  }
+}
+function setJsoncValue(text, path, value) {
+  const node = findNode(text, path);
+  if (node) {
+    if (Object.is(getNodeValue2(node), value))
+      return text;
+    const serialized = JSON.stringify(value);
+    return text.slice(0, node.offset) + serialized + text.slice(node.offset + node.length);
+  }
+  return applyEdits(text, modify(text, path, value, { formattingOptions: documentFormatting(text) }));
+}
+function documentFormatting(text) {
+  const eol = text.includes(`\r
+`) ? `\r
+` : `
+`;
+  const indent = /\n([ \t]+)\S/.exec(text)?.[1];
+  if (indent?.startsWith("\t"))
+    return { eol, insertSpaces: false, tabSize: 1 };
+  return { eol, insertSpaces: true, tabSize: indent ? indent.length : 2 };
+}
+function removeObjectProperty(text, object, key) {
+  const properties = object.children ?? [];
+  const index = properties.findIndex((property) => {
+    const propertyKey = property.children?.[0];
+    return propertyKey !== undefined && getNodeValue2(propertyKey) === key;
+  });
+  if (index === -1)
+    return text;
+  const property = properties[index];
+  if (!property)
+    return text;
+  const closingBrace = object.offset + object.length - 1;
+  const next = properties[index + 1];
+  if (next) {
+    const followingComma = findComma(text, property.offset + property.length, next.offset);
+    if (!followingComma)
+      return text;
+    return text.slice(0, property.offset) + text.slice(followingComma.offset + followingComma.length);
+  }
+  const previous = properties[index - 1];
+  const trailingComma = findComma(text, property.offset + property.length, closingBrace);
+  if (!previous) {
+    const afterProperty = property.offset + property.length;
+    if (!trailingComma)
+      return text.slice(0, property.offset) + text.slice(afterProperty);
+    return text.slice(0, property.offset) + text.slice(afterProperty, trailingComma.offset) + text.slice(trailingComma.offset + trailingComma.length);
+  }
+  const precedingComma = findComma(text, previous.offset + previous.length, property.offset);
+  if (!precedingComma)
+    return text;
+  const afterProperty = property.offset + property.length;
+  const withoutProperty = text.slice(0, precedingComma.offset) + text.slice(precedingComma.offset + precedingComma.length, property.offset) + text.slice(afterProperty);
+  if (!trailingComma)
+    return withoutProperty;
+  const shiftedTrailingComma = trailingComma.offset - 1;
+  return withoutProperty.slice(0, shiftedTrailingComma) + withoutProperty.slice(shiftedTrailingComma + trailingComma.length);
+}
+function removeJsoncValue(text, path) {
+  const key = path.at(-1);
+  if (typeof key !== "string")
+    return text;
+  const parent = findNode(text, path.slice(0, -1));
+  if (parent?.type !== "object")
+    return text;
+  return removeObjectProperty(text, parent, key);
+}
+
+// src/config/migrate-config-location.ts
+var CONFIG_FILE_BASENAME = "magic-context";
+function homeDir() {
+  if (process.platform === "win32") {
+    return process.env.USERPROFILE || process.env.HOME || homedir();
+  }
+  return process.env.HOME || homedir();
+}
+function configHome() {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  if (xdg && isAbsolute(xdg))
+    return xdg;
+  return join(homeDir(), ".config");
+}
+function cortexKitUserConfigBasePath() {
+  return join(configHome(), "cortexkit", CONFIG_FILE_BASENAME);
+}
+function cortexKitProjectConfigBasePath(directory) {
+  return join(directory, ".cortexkit", CONFIG_FILE_BASENAME);
+}
+function legacySourcesForBase(basePath, label) {
+  return [
+    { path: `${basePath}.jsonc`, label: `${label} magic-context.jsonc` },
+    { path: `${basePath}.json`, label: `${label} magic-context.json` }
+  ];
+}
+function userScopeConfigPaths() {
+  return new Set([
+    `${cortexKitUserConfigBasePath()}.jsonc`,
+    `${cortexKitUserConfigBasePath()}.json`,
+    join(configHome(), "opencode", `${CONFIG_FILE_BASENAME}.jsonc`),
+    join(configHome(), "opencode", `${CONFIG_FILE_BASENAME}.json`),
+    join(homeDir(), ".pi", "agent", `${CONFIG_FILE_BASENAME}.jsonc`),
+    join(homeDir(), ".pi", "agent", `${CONFIG_FILE_BASENAME}.json`)
+  ]);
+}
+function resolveLegacyConfigSources(directory) {
+  const userPaths = userScopeConfigPaths();
+  return {
+    user: [
+      ...legacySourcesForBase(join(configHome(), "opencode", CONFIG_FILE_BASENAME), "OpenCode user"),
+      ...legacySourcesForBase(join(homeDir(), ".pi", "agent", CONFIG_FILE_BASENAME), "Pi user")
+    ],
+    project: [
+      ...legacySourcesForBase(join(directory, CONFIG_FILE_BASENAME), "project root"),
+      ...legacySourcesForBase(join(directory, ".opencode", CONFIG_FILE_BASENAME), "OpenCode project"),
+      ...legacySourcesForBase(join(directory, ".pi", CONFIG_FILE_BASENAME), "Pi project")
+    ].filter((source) => !userPaths.has(source.path))
+  };
+}
+function resolveLegacyConfigSourcesForHarness(directory, harness) {
+  if (harness === "pi") {
+    return {
+      user: legacySourcesForBase(join(homeDir(), ".pi", "agent", CONFIG_FILE_BASENAME), "Pi user"),
+      project: legacySourcesForBase(join(directory, ".pi", CONFIG_FILE_BASENAME), "Pi project")
+    };
+  }
+  return {
+    user: legacySourcesForBase(join(configHome(), "opencode", CONFIG_FILE_BASENAME), "OpenCode user"),
+    project: [
+      ...legacySourcesForBase(join(directory, CONFIG_FILE_BASENAME), "project root"),
+      ...legacySourcesForBase(join(directory, ".opencode", CONFIG_FILE_BASENAME), "OpenCode project")
+    ]
+  };
+}
+
+// src/config/migrate-dreamer-v2.ts
+var OLD_VERIFY_TASK = "verify";
+var OLD_CURATE_TASKS = ["consolidate", "archive-stale", "improve"];
+var RETIRED_OBJECT_MEMORY_TASKS = ["maintain-memory", ...OLD_CURATE_TASKS];
+var CANONICAL = [
+  "map-memories",
+  "verify",
+  "verify-broad",
+  "curate",
+  "classify-memories",
+  "retrospective",
+  "maintain-docs",
+  "evaluate-smart-notes",
+  "review-user-memories",
+  "promote-primers",
+  "refresh-primers"
+];
+var DEFAULT_BASE_CRON = "0 2 * * *";
+var DEFAULT_CLASSIFY_CRON = "0 6 * * *";
+var DEFAULT_RETROSPECTIVE_CRON = "0 5 * * *";
+var DEFAULT_VERIFY_BROAD_CRON = "0 4 * * 0";
+function windowToCron(schedule) {
+  if (typeof schedule !== "string")
+    return DEFAULT_BASE_CRON;
+  const m = /^(\d{1,2}):(\d{2})\s*-/.exec(schedule.trim());
+  if (!m)
+    return DEFAULT_BASE_CRON;
+  const hour = Number(m[1]);
+  const minute = Number(m[2]);
+  if (hour >= 24 || minute >= 60)
+    return DEFAULT_BASE_CRON;
+  return `${minute} ${hour} * * *`;
+}
+function asObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+}
+function cronIntervalScore(schedule) {
+  const parts = schedule.trim().split(/\s+/);
+  if (parts.length !== 5)
+    return Number.POSITIVE_INFINITY;
+  const [minute, hour, dayOfMonth, month, dayOfWeek] = parts;
+  if (month !== "*")
+    return 366 * 24 * 60;
+  if (dayOfMonth !== "*")
+    return 31 * 24 * 60;
+  if (dayOfWeek !== "*")
+    return 7 * 24 * 60;
+  const everyHour = /^\*\/(\d+)$/.exec(hour ?? "");
+  if (everyHour)
+    return Math.max(1, Number(everyHour[1])) * 60;
+  if (hour === "*") {
+    const everyMinute = /^\*\/(\d+)$/.exec(minute ?? "");
+    return everyMinute ? Math.max(1, Number(everyMinute[1])) : 60;
+  }
+  return 24 * 60;
+}
+function mostFrequentSchedule(schedules) {
+  const enabled = schedules.map((s) => s.trim()).filter(Boolean);
+  if (enabled.length === 0)
+    return "";
+  return enabled.sort((a, b) => cronIntervalScore(a) - cronIntervalScore(b))[0] ?? "";
+}
+function withoutBroadInterval(entry) {
+  const { broad_interval_days: _broad, ...rest } = entry;
+  return rest;
+}
+function reconcileV2TasksObject(rawConfig, dreamer, tasksObject) {
+  const hasVerifyBroad = "verify-broad" in tasksObject;
+  const hasBroadIntervalAnywhere = Object.values(tasksObject).some((v) => asObject(v) && ("broad_interval_days" in v));
+  const hasStaleKeyFiles = "key-files" in tasksObject;
+  if (hasVerifyBroad && !hasBroadIntervalAnywhere && !hasStaleKeyFiles)
+    return rawConfig;
+  const nextTasks = {};
+  for (const [key, value] of Object.entries(tasksObject)) {
+    if (key === "key-files")
+      continue;
+    const obj = asObject(value);
+    nextTasks[key] = obj ? withoutBroadInterval(obj) : value;
+  }
+  if (!hasVerifyBroad) {
+    const verify = asObject(tasksObject.verify);
+    const verifyEnabled = typeof verify?.schedule === "string" && verify.schedule.trim() !== "";
+    nextTasks["verify-broad"] = {
+      schedule: verifyEnabled ? DEFAULT_VERIFY_BROAD_CRON : ""
+    };
+  }
+  return { ...rawConfig, dreamer: { ...dreamer, tasks: nextTasks } };
+}
+function migrateDreamerV2(rawConfig, warnings) {
+  const dreamer = asObject(rawConfig.dreamer);
+  if (!dreamer)
+    return rawConfig;
+  const tasksObject = asObject(dreamer.tasks);
+  const hasRetiredObjectTasks = tasksObject ? RETIRED_OBJECT_MEMORY_TASKS.some((task) => (task in tasksObject)) : false;
+  if (tasksObject && !hasRetiredObjectTasks) {
+    const hasLegacyOutsideTasks = "schedule" in dreamer || "user_memories" in dreamer || "pin_key_files" in dreamer || "task_timeout_minutes" in dreamer || "max_runtime_minutes" in dreamer;
+    if (!hasLegacyOutsideTasks) {
+      return reconcileV2TasksObject(rawConfig, dreamer, tasksObject);
+    }
+  }
+  const hasLegacy = "schedule" in dreamer || Array.isArray(dreamer.tasks) || hasRetiredObjectTasks || "user_memories" in dreamer || "pin_key_files" in dreamer || "task_timeout_minutes" in dreamer || "max_runtime_minutes" in dreamer;
+  if (!hasLegacy)
+    return rawConfig;
+  const baseCron = windowToCron(dreamer.schedule);
+  const timeout = typeof dreamer.task_timeout_minutes === "number" ? dreamer.task_timeout_minutes : undefined;
+  const withTimeout = (entry) => timeout !== undefined ? { ...entry, timeout_minutes: timeout } : entry;
+  const classifySchedule = dreamer.disable === true ? "" : DEFAULT_CLASSIFY_CRON;
+  const retrospectiveSchedule = dreamer.disable === true ? "" : DEFAULT_RETROSPECTIVE_CRON;
+  const tasks = {};
+  if (tasksObject) {
+    for (const [key, value] of Object.entries(tasksObject)) {
+      if (RETIRED_OBJECT_MEMORY_TASKS.includes(key))
+        continue;
+      if (asObject(value))
+        tasks[key] = { ...value };
+    }
+    const maintainMemoryEntry = asObject(tasksObject["maintain-memory"]);
+    if (maintainMemoryEntry) {
+      const schedule = typeof maintainMemoryEntry.schedule === "string" ? maintainMemoryEntry.schedule : baseCron;
+      tasks.verify = withTimeout({
+        ...withoutBroadInterval(maintainMemoryEntry),
+        ...tasks.verify ?? {},
+        schedule: tasks.verify?.schedule ?? schedule
+      });
+      tasks.curate = withTimeout({
+        ...withoutBroadInterval(maintainMemoryEntry),
+        ...tasks.curate ?? {},
+        schedule: tasks.curate?.schedule ?? schedule
+      });
+    }
+    const oldVerifyEntry = asObject(tasksObject[OLD_VERIFY_TASK]);
+    if (oldVerifyEntry) {
+      tasks.verify = withTimeout({
+        ...withoutBroadInterval(oldVerifyEntry),
+        ...tasks.verify ?? {},
+        schedule: tasks.verify?.schedule ?? (typeof oldVerifyEntry.schedule === "string" ? oldVerifyEntry.schedule : baseCron)
+      });
+    }
+    if (!tasks["verify-broad"]) {
+      const verifyEnabled = typeof tasks.verify?.schedule === "string" && tasks.verify.schedule.trim() !== "";
+      tasks["verify-broad"] = withTimeout({
+        schedule: verifyEnabled ? DEFAULT_VERIFY_BROAD_CRON : ""
+      });
+    }
+    const oldCurateEntries = OLD_CURATE_TASKS.map((task) => asObject(tasksObject[task])).filter((entry) => Boolean(entry));
+    if (oldCurateEntries.length > 0) {
+      const oldSchedules = oldCurateEntries.map((entry) => typeof entry.schedule === "string" ? entry.schedule : baseCron);
+      tasks.curate = withTimeout({
+        ...tasks.curate ?? {},
+        schedule: mostFrequentSchedule(oldSchedules)
+      });
+    }
+    for (const task of CANONICAL) {
+      if (!tasks[task]) {
+        const schedule = task === "verify" || task === "curate" || task === "verify-broad" ? "" : task === "classify-memories" ? classifySchedule : task === "retrospective" ? retrospectiveSchedule : task === "maintain-docs" ? "" : baseCron;
+        tasks[task] = withTimeout({ schedule });
+      }
+    }
+  } else {
+    const legacyArray = Array.isArray(dreamer.tasks) ? dreamer.tasks.filter((t) => typeof t === "string") : null;
+    const verifySelected = legacyArray ? legacyArray.includes(OLD_VERIFY_TASK) : true;
+    const curateSelected = legacyArray ? legacyArray.some((task) => OLD_CURATE_TASKS.includes(task)) : true;
+    tasks.verify = withTimeout({
+      schedule: verifySelected ? baseCron : ""
+    });
+    tasks["verify-broad"] = withTimeout({
+      schedule: verifySelected ? DEFAULT_VERIFY_BROAD_CRON : ""
+    });
+    tasks.curate = withTimeout({
+      schedule: curateSelected ? baseCron : ""
+    });
+    tasks["classify-memories"] = withTimeout({
+      schedule: classifySchedule
+    });
+    tasks.retrospective = withTimeout({
+      schedule: retrospectiveSchedule
+    });
+    tasks["maintain-docs"] = withTimeout({
+      schedule: legacyArray?.includes("maintain-docs") ? baseCron : ""
+    });
+  }
+  tasks["map-memories"] ??= withTimeout({ schedule: baseCron });
+  tasks["evaluate-smart-notes"] ??= withTimeout({ schedule: baseCron });
+  const um = asObject(dreamer.user_memories);
+  const umEnabled = um ? um.enabled !== false : true;
+  if (um || !tasks["review-user-memories"]) {
+    tasks["review-user-memories"] = withTimeout({
+      ...tasks["review-user-memories"] ?? {},
+      schedule: umEnabled ? baseCron : "",
+      ...um && typeof um.promotion_threshold === "number" ? { promotion_threshold: um.promotion_threshold } : {}
+    });
+  }
+  const {
+    schedule: _schedule,
+    tasks: _tasks,
+    task_timeout_minutes: _tto,
+    max_runtime_minutes: _max,
+    user_memories: _um,
+    pin_key_files: _pkf,
+    ...rest
+  } = dreamer;
+  warnings.push('Migrated legacy dreamer scheduling (schedule window / tasks array / user_memories / pin_key_files) → per-task "dreamer.tasks" in-memory (run `doctor` to persist).');
+  return { ...rawConfig, dreamer: { ...rest, tasks } };
+}
+
+// src/config/migrate-experimental.ts
+function migrateLegacyExperimental(rawConfig, warnings) {
+  const experimental = rawConfig.experimental;
+  if (typeof experimental !== "object" || experimental === null) {
+    return rawConfig;
+  }
+  const exp = experimental;
+  const hasUM = "user_memories" in exp;
+  const hasPKF = "pin_key_files" in exp;
+  const hasMural = "mural" in exp;
+  const TOP_LEVEL_GRADUATED = ["temporal_awareness", "caveman_text_compression"];
+  const MEMORY_GRADUATED = ["auto_search", "git_commit_indexing"];
+  const hasGraduated = TOP_LEVEL_GRADUATED.some((k) => (k in exp)) || MEMORY_GRADUATED.some((k) => (k in exp)) || hasMural;
+  if (!hasUM && !hasPKF && !hasGraduated) {
+    return rawConfig;
+  }
+  const patched = { ...rawConfig };
+  const dreamer = typeof patched.dreamer === "object" && patched.dreamer !== null ? { ...patched.dreamer } : {};
+  const memory = typeof patched.memory === "object" && patched.memory !== null ? { ...patched.memory } : {};
+  const newExperimental = { ...exp };
+  const coerceToObject = (value) => {
+    if (typeof value === "boolean") {
+      return { enabled: value };
+    }
+    if (typeof value === "object" && value !== null) {
+      return { ...value };
+    }
+    return;
+  };
+  const relocate = (key, dest, destLabel) => {
+    if (!(key in exp))
+      return;
+    const oldValue = exp[key];
+    const existing = dest[key];
+    if (existing === undefined) {
+      dest[key] = oldValue;
+      warnings.push(`Migrated "experimental.${key}" → "${destLabel}${key}" in-memory (run \`doctor\` to persist).`);
+    } else if (typeof oldValue === "object" && oldValue !== null && typeof existing === "object" && existing !== null) {
+      dest[key] = {
+        ...oldValue,
+        ...existing
+      };
+    }
+    delete newExperimental[key];
+  };
+  for (const key of TOP_LEVEL_GRADUATED)
+    relocate(key, patched, "");
+  for (const key of MEMORY_GRADUATED)
+    relocate(key, memory, "memory.");
+  if (hasMural) {
+    const oldMural = coerceToObject(exp.mural);
+    const existingMural = patched.mural;
+    if (existingMural === undefined) {
+      patched.mural = oldMural ?? exp.mural;
+      warnings.push('Deprecated "experimental.mural"; use top-level "mural" instead (migrated in memory; run `doctor` to persist).');
+    } else if (oldMural !== undefined && typeof existingMural === "object" && existingMural !== null && !Array.isArray(existingMural)) {
+      patched.mural = {
+        ...oldMural,
+        ...existingMural
+      };
+    }
+    delete newExperimental.mural;
+  }
+  if (hasUM) {
+    const oldUM = coerceToObject(exp.user_memories);
+    if (oldUM !== undefined) {
+      if (dreamer.user_memories === undefined) {
+        dreamer.user_memories = oldUM;
+        warnings.push('Migrated "experimental.user_memories" → "dreamer.user_memories" in-memory (run `doctor` to persist).');
+      } else if (typeof dreamer.user_memories === "object" && dreamer.user_memories !== null) {
+        dreamer.user_memories = {
+          ...oldUM,
+          ...dreamer.user_memories
+        };
+      }
+    }
+    delete newExperimental.user_memories;
+  }
+  if (hasPKF) {
+    const oldPKF = coerceToObject(exp.pin_key_files);
+    if (oldPKF !== undefined) {
+      if (dreamer.pin_key_files === undefined) {
+        dreamer.pin_key_files = oldPKF;
+        warnings.push('Migrated "experimental.pin_key_files" → "dreamer.pin_key_files" in-memory (run `doctor` to persist).');
+      } else if (typeof dreamer.pin_key_files === "object" && dreamer.pin_key_files !== null) {
+        dreamer.pin_key_files = {
+          ...oldPKF,
+          ...dreamer.pin_key_files
+        };
+      } else if (typeof dreamer.pin_key_files === "boolean") {
+        dreamer.pin_key_files = { ...oldPKF, enabled: dreamer.pin_key_files };
+      }
+    }
+    delete newExperimental.pin_key_files;
+  }
+  patched.experimental = newExperimental;
+  patched.dreamer = dreamer;
+  if (Object.keys(memory).length > 0) {
+    patched.memory = memory;
+  }
+  return patched;
+}
+
+// src/config/profiles.ts
+function withoutProfileFields(raw) {
+  const copy = { ...raw };
+  delete copy.profile;
+  delete copy.profiles;
+  return copy;
+}
+function readProfileSelection(raw) {
+  if (!Object.hasOwn(raw, "profile"))
+    return { declared: false };
+  const value = raw.profile;
+  if (typeof value !== "string")
+    return { declared: true };
+  const name = value.trim();
+  return name.length > 0 ? { declared: true, name } : { declared: true };
+}
+function resolveConfigProfile(args) {
+  const warnings = [];
+  const userSelection = readProfileSelection(args.userRaw);
+  const projectSelection = readProfileSelection(args.projectRaw);
+  const selection = projectSelection.name ? { name: projectSelection.name, source: "project" } : userSelection.name ? { name: userSelection.name, source: "user" } : undefined;
+  if (projectSelection.declared && !projectSelection.name) {
+    warnings.push("Ignoring invalid profile selection from project config; expected a non-empty string.");
+  }
+  if (!projectSelection.declared && userSelection.declared && !userSelection.name) {
+    warnings.push("Ignoring invalid profile selection from user config; expected a non-empty string.");
+  }
+  let profiles = {};
+  if (Object.hasOwn(args.userRaw, "profiles")) {
+    const parsed = ConfigProfilesSchema.safeParse(args.userRaw.profiles);
+    if (parsed.success) {
+      profiles = parsed.data;
+    } else {
+      warnings.push("Ignoring profiles from user config: invalid profile configuration; profiles may contain only historian/dreamer harness model blocks.");
+    }
+  }
+  if (!selection) {
+    return {
+      userBase: withoutProfileFields(args.userRaw),
+      projectBase: withoutProfileFields(args.projectRaw),
+      overlay: {},
+      warnings
+    };
+  }
+  if (!Object.hasOwn(profiles, selection.name)) {
+    warnings.push(`Unknown profile "${selection.name}" selected by ${selection.source} config; using base config without a profile.`);
+    return {
+      userBase: withoutProfileFields(args.userRaw),
+      projectBase: withoutProfileFields(args.projectRaw),
+      overlay: {},
+      warnings
+    };
+  }
+  const overlay = profiles[selection.name];
+  return {
+    userBase: withoutProfileFields(args.userRaw),
+    projectBase: withoutProfileFields(args.projectRaw),
+    overlay,
+    activeProfile: selection.name,
+    warnings
+  };
+}
+
+// src/config/prune-config-leaf.ts
+function isPlainObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function pruneNestedConfigLeaf(block, relativePath) {
+  if (relativePath.length === 0)
+    return null;
+  const result = { ...block };
+  let cursor = result;
+  for (let i = 0;i < relativePath.length - 1; i++) {
+    const seg = String(relativePath[i]);
+    const child = cursor[seg];
+    if (!isPlainObject2(child)) {
+      if (!(seg in cursor))
+        return null;
+      delete cursor[seg];
+      return {
+        block: result,
+        removed: relativePath.slice(0, i + 1).map(String).join(".")
+      };
+    }
+    const clonedChild = { ...child };
+    cursor[seg] = clonedChild;
+    cursor = clonedChild;
+  }
+  const leaf = String(relativePath[relativePath.length - 1]);
+  if (!(leaf in cursor))
+    return null;
+  delete cursor[leaf];
+  return { block: result, removed: relativePath.map(String).join(".") };
+}
+
+// src/config/raw-loader.ts
+import {
+  closeSync,
+  existsSync as existsSync2,
+  linkSync,
+  openSync,
+  readFileSync as readFileSync2,
+  realpathSync,
+  renameSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
+import { basename as basename2, dirname as dirname2, join as join2 } from "node:path";
+var MODEL_FIELDS = ["model", "fallback_models"];
+var QUALIFIER_FIELDS = ["variant", "thinking_level"];
+var TASK_MODEL_FIELDS = [...MODEL_FIELDS, ...QUALIFIER_FIELDS, "timeout_minutes"];
+var PRE_PER_HARNESS_BACKUP_SUFFIX = ".pre-per-harness.bak";
+var temporaryFileSequence = 0;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asDocument(text) {
+  try {
+    const document = parseJsonc(text.startsWith("\uFEFF") ? text.slice(1) : text);
+    return isRecord(document) ? document : null;
+  } catch {
+    return null;
+  }
+}
+function getAtPath(document, path) {
+  let current = document;
+  for (const part of path) {
+    if (!isRecord(current) || !Object.hasOwn(current, part))
+      return;
+    current = current[part];
+  }
+  return current;
+}
+function stableJson(value) {
+  if (Array.isArray(value))
+    return `[${value.map(stableJson).join(",")}]`;
+  if (!isRecord(value))
+    return JSON.stringify(value);
+  return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(",")}}`;
+}
+function valuesMatch(left, right) {
+  return stableJson(left) === stableJson(right);
+}
+function valueForDiagnostic(value) {
+  return stableJson(value);
+}
+function migrateEntryForHarness(value, harness) {
+  if (Array.isArray(value))
+    return value.map((entry) => migrateEntryForHarness(entry, harness));
+  if (!isRecord(value) || !Object.hasOwn(value, "model"))
+    return value;
+  const entry = { model: value.model };
+  if (harness === "opencode" && Object.hasOwn(value, "variant")) {
+    entry.variant = value.variant;
+  }
+  if (harness === "pi" && Object.hasOwn(value, "thinking_level")) {
+    entry.thinking_level = value.thinking_level;
+  }
+  return entry;
+}
+function migrateFallbackForHarness(value, harness) {
+  if (typeof value === "string")
+    return [value];
+  return migrateEntryForHarness(value, harness);
+}
+function canCreateAtPath(document, path) {
+  let current = document;
+  for (const part of path) {
+    if (current === undefined)
+      return true;
+    if (!isRecord(current))
+      return false;
+    current = current[part];
+  }
+  return current === undefined || isRecord(current);
+}
+function flatFieldPath(parts) {
+  return parts.join(".");
+}
+function updateDocumentForFlatFields(text) {
+  const hasBom = text.startsWith("\uFEFF");
+  const editableText = hasBom ? text.slice(1) : text;
+  const document = asDocument(text);
+  if (!document) {
+    return { text, hasFlatKeys: false, diagnostics: [], flatPaths: [] };
+  }
+  let nextText = editableText;
+  let hasFlatKeys = false;
+  const diagnostics = [];
+  const flatPaths = [];
+  const sourcePathsToRemove = [];
+  const addDestination = (sourcePath, destinationPath, destinationValue) => {
+    const sourceLabel = flatFieldPath(sourcePath);
+    const destinationLabel = flatFieldPath(destinationPath);
+    if (!canCreateAtPath(document, destinationPath.slice(0, -1))) {
+      diagnostics.push({
+        path: sourceLabel,
+        message: `Flat config field "${sourceLabel}" (${valueForDiagnostic(destinationValue)}) conflicts with non-object destination "${destinationLabel}" (${valueForDiagnostic(getAtPath(document, destinationPath.slice(0, -1)))}); kept the destination and ignored the flat field.`
+      });
+      return;
+    }
+    const existing = getAtPath(document, destinationPath);
+    if (existing !== undefined) {
+      if (!valuesMatch(existing, destinationValue)) {
+        diagnostics.push({
+          path: sourceLabel,
+          message: `Flat config field "${sourceLabel}" (${valueForDiagnostic(destinationValue)}) conflicts with "${destinationLabel}" (${valueForDiagnostic(existing)}); kept "${destinationLabel}" and ignored the flat field.`
+        });
+      }
+      return;
+    }
+    nextText = setJsoncValue(nextText, destinationPath, destinationValue);
+  };
+  const migrateAgentFields = (agentName) => {
+    const agent = document[agentName];
+    if (!isRecord(agent))
+      return;
+    for (const field of MODEL_FIELDS) {
+      if (!Object.hasOwn(agent, field))
+        continue;
+      const sourcePath = [agentName, field];
+      hasFlatKeys = true;
+      flatPaths.push(flatFieldPath(sourcePath));
+      sourcePathsToRemove.push(sourcePath);
+      const migrateValue = field === "fallback_models" ? migrateFallbackForHarness : migrateEntryForHarness;
+      addDestination(sourcePath, [agentName, "opencode", field], migrateValue(agent[field], "opencode"));
+      addDestination(sourcePath, [agentName, "pi", field], migrateValue(agent[field], "pi"));
+    }
+    if (Object.hasOwn(agent, "variant")) {
+      const sourcePath = [agentName, "variant"];
+      hasFlatKeys = true;
+      flatPaths.push(flatFieldPath(sourcePath));
+      sourcePathsToRemove.push(sourcePath);
+      addDestination(sourcePath, [agentName, "opencode", "variant"], agent.variant);
+    }
+    if (Object.hasOwn(agent, "thinking_level")) {
+      const sourcePath = [agentName, "thinking_level"];
+      hasFlatKeys = true;
+      flatPaths.push(flatFieldPath(sourcePath));
+      sourcePathsToRemove.push(sourcePath);
+      addDestination(sourcePath, [agentName, "pi", "thinking_level"], agent.thinking_level);
+    }
+  };
+  migrateAgentFields("historian");
+  migrateAgentFields("dreamer");
+  const dreamer = document.dreamer;
+  const tasks = isRecord(dreamer) ? dreamer.tasks : undefined;
+  if (isRecord(tasks)) {
+    for (const taskName of Object.keys(tasks).sort()) {
+      const task = tasks[taskName];
+      if (!isRecord(task))
+        continue;
+      for (const field of TASK_MODEL_FIELDS) {
+        if (!Object.hasOwn(task, field))
+          continue;
+        const sourcePath = ["dreamer", "tasks", taskName, field];
+        hasFlatKeys = true;
+        flatPaths.push(flatFieldPath(sourcePath));
+        sourcePathsToRemove.push(sourcePath);
+        if (field === "model" || field === "fallback_models") {
+          addDestination(sourcePath, ["dreamer", "opencode", "tasks", taskName, field], field === "fallback_models" ? migrateFallbackForHarness(task[field], "opencode") : migrateEntryForHarness(task[field], "opencode"));
+          addDestination(sourcePath, ["dreamer", "pi", "tasks", taskName, field], field === "fallback_models" ? migrateFallbackForHarness(task[field], "pi") : migrateEntryForHarness(task[field], "pi"));
+        } else if (field === "variant") {
+          addDestination(sourcePath, ["dreamer", "opencode", "tasks", taskName, field], task[field]);
+        } else if (field === "thinking_level") {
+          addDestination(sourcePath, ["dreamer", "pi", "tasks", taskName, field], task[field]);
+        } else {
+          addDestination(sourcePath, ["dreamer", "opencode", "tasks", taskName, field], task[field]);
+          addDestination(sourcePath, ["dreamer", "pi", "tasks", taskName, field], task[field]);
+        }
+      }
+    }
+  }
+  for (const sourcePath of sourcePathsToRemove) {
+    nextText = removeJsoncValue(nextText, sourcePath);
+  }
+  return {
+    text: hasBom ? `\uFEFF${nextText}` : nextText,
+    hasFlatKeys,
+    diagnostics,
+    flatPaths
+  };
+}
+function hasFlatKeys(input) {
+  const text = typeof input === "string" ? input : input.toString("utf-8");
+  return updateDocumentForFlatFields(text).hasFlatKeys;
+}
+function migrateFlatDetailed(input) {
+  const bytes = typeof input === "string" ? Buffer.from(input, "utf-8") : input;
+  const result = updateDocumentForFlatFields(bytes.toString("utf-8"));
+  return {
+    bytes: Buffer.from(result.text, "utf-8"),
+    hasFlatKeys: result.hasFlatKeys,
+    diagnostics: result.diagnostics
+  };
+}
+function writeExclusiveBackup(backupPath, bytes, mode) {
+  const temporaryPath = writeTemporaryCandidate(backupPath, bytes, mode);
+  try {
+    try {
+      linkSync(temporaryPath, backupPath);
+      return;
+    } catch (error) {
+      if (error.code !== "EEXIST")
+        throw error;
+    }
+    const existingBytes = readFileSync2(backupPath);
+    if (existingBytes.equals(bytes))
+      return;
+    if (bytes.subarray(0, existingBytes.length).equals(existingBytes)) {
+      renameSync(temporaryPath, backupPath);
+      return;
+    }
+  } finally {
+    try {
+      unlinkSync(temporaryPath);
+    } catch {}
+  }
+}
+function writeTemporaryCandidate(configPath, bytes, mode) {
+  const directory = dirname2(configPath);
+  const stem = basename2(configPath);
+  for (let attempt = 0;attempt < 32; attempt++) {
+    temporaryFileSequence += 1;
+    const path = join2(directory, `.${stem}.per-harness-${process.pid}-${temporaryFileSequence}.tmp`);
+    let descriptor;
+    try {
+      descriptor = openSync(path, "wx", mode);
+      writeFileSync(descriptor, bytes);
+      closeSync(descriptor);
+      return path;
+    } catch (error) {
+      if (descriptor !== undefined) {
+        try {
+          closeSync(descriptor);
+        } catch {}
+      }
+      try {
+        unlinkSync(path);
+      } catch {}
+      if (error.code !== "EEXIST")
+        throw error;
+    }
+  }
+  throw new Error(`Could not allocate a temporary config file beside ${configPath}`);
+}
+function migrationWarning(diagnostic) {
+  return diagnostic.message;
+}
+function loadRawConfigFile(options) {
+  if (!existsSync2(options.configPath))
+    return null;
+  let observedBytes;
+  try {
+    observedBytes = readFileSync2(options.configPath);
+  } catch (error) {
+    throw new Error(`failed to read config: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const initialMigration = migrateFlatDetailed(observedBytes);
+  if (!initialMigration.hasFlatKeys) {
+    return {
+      configPath: options.configPath,
+      bytes: observedBytes,
+      text: observedBytes.toString("utf-8"),
+      warnings: [],
+      migrated: false
+    };
+  }
+  if (options.tier === "project") {
+    return {
+      configPath: options.configPath,
+      bytes: initialMigration.bytes,
+      text: initialMigration.bytes.toString("utf-8"),
+      warnings: [
+        "Adapted flat model config in memory; use historian.opencode/historian.pi and dreamer.opencode/dreamer.pi instead. Project config files are never rewritten.",
+        ...initialMigration.diagnostics.map(migrationWarning)
+      ],
+      migrated: false
+    };
+  }
+  const backupPath = `${options.configPath}${PRE_PER_HARNESS_BACKUP_SUFFIX}`;
+  for (;; ) {
+    const migration = migrateFlatDetailed(observedBytes);
+    if (!migration.hasFlatKeys) {
+      return {
+        configPath: options.configPath,
+        bytes: observedBytes,
+        text: observedBytes.toString("utf-8"),
+        warnings: [],
+        migrated: false
+      };
+    }
+    let temporaryPath;
+    try {
+      const writePath = realpathSync(options.configPath);
+      const mode = options.tier === "user" ? 384 : statSync(writePath).mode & 511;
+      writeExclusiveBackup(backupPath, observedBytes, mode);
+      temporaryPath = writeTemporaryCandidate(writePath, migration.bytes, mode);
+      options.afterTemporaryWrite?.();
+      const currentBytes = readFileSync2(options.configPath);
+      if (!hasFlatKeys(currentBytes)) {
+        unlinkSync(temporaryPath);
+        return {
+          configPath: options.configPath,
+          bytes: currentBytes,
+          text: currentBytes.toString("utf-8"),
+          warnings: [],
+          migrated: false
+        };
+      }
+      if (!currentBytes.equals(observedBytes)) {
+        unlinkSync(temporaryPath);
+        observedBytes = currentBytes;
+        continue;
+      }
+      renameSync(temporaryPath, writePath);
+      return {
+        configPath: options.configPath,
+        bytes: migration.bytes,
+        text: migration.bytes.toString("utf-8"),
+        warnings: [
+          "Migrated flat historian/dreamer model config to per-harness blocks.",
+          ...migration.diagnostics.map(migrationWarning)
+        ],
+        migrated: true
+      };
+    } catch (error) {
+      if (temporaryPath) {
+        try {
+          unlinkSync(temporaryPath);
+        } catch {}
+      }
+      return {
+        configPath: options.configPath,
+        bytes: observedBytes,
+        text: observedBytes.toString("utf-8"),
+        warnings: [
+          `Could not migrate flat model config: ${error instanceof Error ? error.message : String(error)}. Flat fields were not applied.`,
+          ...migration.diagnostics.map(migrationWarning)
+        ],
+        migrated: false
+      };
+    }
+  }
+}
+
+// src/config/removed-agent-config.ts
+var REMOVED_AGENT_CONFIG_KEY = "sidekick";
+var REMOVED_AGENT_CONFIG_WARNING = `The "${REMOVED_AGENT_CONFIG_KEY}" configuration was removed and is ignored.`;
+function isPlainObject3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stripRemovedAgentConfig(rawConfig, warnings) {
+  let removed = false;
+  const patched = { ...rawConfig };
+  if (Object.hasOwn(patched, REMOVED_AGENT_CONFIG_KEY)) {
+    delete patched[REMOVED_AGENT_CONFIG_KEY];
+    removed = true;
+  }
+  if (isPlainObject3(patched.profiles)) {
+    const profiles = { ...patched.profiles };
+    let profilesChanged = false;
+    for (const [name, value] of Object.entries(profiles)) {
+      if (!isPlainObject3(value) || !Object.hasOwn(value, REMOVED_AGENT_CONFIG_KEY))
+        continue;
+      const profile = { ...value };
+      delete profile[REMOVED_AGENT_CONFIG_KEY];
+      profiles[name] = profile;
+      profilesChanged = true;
+      removed = true;
+    }
+    if (profilesChanged)
+      patched.profiles = profiles;
+  }
+  if (removed && !warnings.includes(REMOVED_AGENT_CONFIG_WARNING)) {
+    warnings.push(REMOVED_AGENT_CONFIG_WARNING);
+  }
+  return removed ? patched : rawConfig;
+}
+
+// src/config/transform-mode.ts
+var RUST_COMPACTION_OFF_WARNING = "compaction-off mode does not support rust transform mode; using the TypeScript transform.";
+var RUST_REQUIRES_USER_SUBC_WARNING = "rust mode requires user-level subc configuration; running ts.";
+function resolveTransformMode(args) {
+  if (args.configured === "rust" && !args.compactionEnabled) {
+    return {
+      mode: "ts",
+      warnings: [RUST_COMPACTION_OFF_WARNING]
+    };
+  }
+  if (args.configured === "rust" && !args.userTierHasSubc) {
+    return {
+      mode: "ts",
+      warnings: [RUST_REQUIRES_USER_SUBC_WARNING]
+    };
+  }
+  return { mode: args.configured, warnings: [] };
+}
+
+// src/config/variable.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname3, isAbsolute as isAbsolute2, resolve } from "node:path";
+var ENV_PATTERN = /\{env:([^}]+)\}/g;
+var FILE_PATTERN = /\{file:([^}]+)\}/g;
+function sensitiveFilePathReason(resolvedPath) {
+  const home = homedir2();
+  const sensitiveDirs = [
+    { dir: resolve(home, ".ssh"), label: "SSH keys" },
+    { dir: resolve(home, ".aws"), label: "AWS credentials" },
+    { dir: resolve(home, ".gnupg"), label: "GnuPG keyring" },
+    { dir: resolve(home, ".config", "gh"), label: "GitHub CLI auth" }
+  ];
+  for (const { dir, label } of sensitiveDirs) {
+    if (resolvedPath === dir || resolvedPath.startsWith(`${dir}/`)) {
+      return label;
+    }
+  }
+  return null;
+}
+function substituteConfigVariables(input) {
+  const warnings = [];
+  let text = input.text;
+  if (input.isProjectConfig) {
+    const hasEnvTokens = ENV_PATTERN.test(text);
+    const hasFileTokens = FILE_PATTERN.test(text);
+    ENV_PATTERN.lastIndex = 0;
+    FILE_PATTERN.lastIndex = 0;
+    if (hasEnvTokens || hasFileTokens) {
+      const tokenTypes = [
+        hasEnvTokens ? "{env:}" : undefined,
+        hasFileTokens ? "{file:}" : undefined
+      ].filter(Boolean).join(" and ");
+      warnings.push(`Project-level config no longer supports ${tokenTypes} tokens for security reasons; leaving tokens literal. Move secret expansion to user-level config.`);
+    }
+    return { text, warnings };
+  }
+  text = stripJsonComments(text);
+  text = text.replace(ENV_PATTERN, (_, rawName) => {
+    const varName = rawName.trim();
+    const value = varName ? process.env[varName] : undefined;
+    if (value === undefined || value === "") {
+      warnings.push(`Environment variable ${varName} is not set (referenced via {env:${varName}}); using empty string`);
+      return "";
+    }
+    return JSON.stringify(value).slice(1, -1);
+  });
+  const fileMatches = Array.from(text.matchAll(FILE_PATTERN));
+  if (fileMatches.length === 0) {
+    return { text, warnings };
+  }
+  const configDir = input.configPath ? dirname3(input.configPath) : process.cwd();
+  let output = "";
+  let cursor = 0;
+  for (const match of fileMatches) {
+    const token = match[0];
+    const rawPath = match[1] ?? "";
+    const index = match.index ?? 0;
+    output += text.slice(cursor, index);
+    cursor = index + token.length;
+    const lineStart = text.lastIndexOf(`
+`, index - 1) + 1;
+    const prefix = text.slice(lineStart, index).trimStart();
+    if (prefix.startsWith("//")) {
+      output += token;
+      continue;
+    }
+    let filePath = rawPath.trim();
+    if (filePath.startsWith("~/")) {
+      filePath = resolve(homedir2(), filePath.slice(2));
+    } else if (!isAbsolute2(filePath)) {
+      filePath = resolve(configDir, filePath);
+    }
+    const sensitiveReason = sensitiveFilePathReason(filePath);
+    if (sensitiveReason) {
+      warnings.push(`${token} resolves to a sensitive path (${sensitiveReason}: ${filePath}); ` + "inlining its contents into config — make sure this is intentional.");
+    }
+    if (!existsSync3(filePath)) {
+      warnings.push(`File not found for ${token} (resolved to ${filePath}); using empty string`);
+      continue;
+    }
+    let contents;
+    try {
+      contents = readFileSync3(filePath, "utf-8").trim();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      warnings.push(`Failed to read file for ${token} (${filePath}): ${message}; using empty string`);
+      continue;
+    }
+    output += JSON.stringify(contents).slice(1, -1);
+  }
+  output += text.slice(cursor);
+  return { text: output, warnings };
+}
+
+// src/config/index.ts
+function getUserConfigBasePath() {
+  return cortexKitUserConfigBasePath();
+}
+function getProjectConfigBasePath(directory) {
+  return cortexKitProjectConfigBasePath(directory);
+}
+function resolveLegacyReadFallback(sources) {
+  return { source: sources.find((s) => existsSync4(s.path)) ?? null };
+}
+function loadConfigFileDetailed(configPath, source) {
+  if (!existsSync4(configPath)) {
+    return null;
+  }
+  let rawText;
+  let rawWarnings;
+  try {
+    const raw = loadRawConfigFile({ configPath, tier: source });
+    if (!raw)
+      return null;
+    rawText = raw.text;
+    rawWarnings = raw.warnings;
+  } catch (error) {
+    const message = `failed to read config: ${error instanceof Error ? error.message : String(error)}`;
+    return {
+      config: {},
+      warnings: [`${configPath}: ${message}`],
+      parseFailures: [],
+      warningDetails: [
+        { warningClass: CONFIG_WARNING_CLASS.FILE_IO, source, path: configPath, message }
+      ],
+      outcome: "project-file-io-error",
+      source
+    };
+  }
+  try {
+    const substituted = substituteConfigVariables({
+      text: rawText,
+      configPath,
+      isProjectConfig: source === "project"
+    });
+    const rejectedKeyPaths = [];
+    const parsed = parseJsoncRecovering(substituted.text, {
+      onRejectedKey: (path) => rejectedKeyPaths.push(path.join("."))
+    });
+    const config = parsed.value && typeof parsed.value === "object" && !Array.isArray(parsed.value) ? parsed.value : {};
+    const unsafeKeyWarnings = rejectedKeyPaths.map((path) => `Ignored unsafe config key "${path}" (security: prototype-pollution keys are not allowed).`);
+    const firstIssue = parsed.issues[0];
+    const recovered = firstIssue !== undefined && Object.keys(config).length > 0;
+    const parseFailures = firstIssue ? [
+      {
+        warningClass: CONFIG_WARNING_CLASS.FILE_PARSE,
+        source,
+        path: configPath,
+        line: firstIssue.line,
+        column: firstIssue.column,
+        message: firstIssue.message,
+        recovered,
+        warning: `${configPath}:${firstIssue.line}:${firstIssue.column}: ${firstIssue.message}; ${recovered ? "recovered values were applied, but the file must be fixed." : "using defaults for this file."}`
+      }
+    ] : [];
+    return {
+      config,
+      warnings: [
+        ...parseFailures.map((failure) => failure.warning),
+        ...rawWarnings.map((warning) => `${configPath}: ${warning}`),
+        ...substituted.warnings.map((warning) => `${configPath}: ${warning}`),
+        ...unsafeKeyWarnings.map((warning) => `${configPath}: ${warning}`)
+      ],
+      parseFailures,
+      warningDetails: parseFailures,
+      outcome: parseFailures.length > 0 ? "project-file-parse-error" : rejectedKeyPaths.length > 0 ? "schema-recovery" : substituted.warnings.length > 0 ? "substitution-failure" : "ok",
+      source
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const warning = `${configPath}:1:1: ${message}; using defaults for this file.`;
+    const failure = {
+      warningClass: CONFIG_WARNING_CLASS.FILE_PARSE,
+      source,
+      path: configPath,
+      line: 1,
+      column: 1,
+      message,
+      recovered: false,
+      warning
+    };
+    return {
+      config: {},
+      warnings: [warning],
+      parseFailures: [failure],
+      warningDetails: [failure],
+      outcome: "project-file-parse-error",
+      source
+    };
+  }
+}
+function defineOwnConfigValue(target, key, value) {
+  Object.defineProperty(target, key, {
+    value,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  });
+}
+function deepMergeRawConfig(base, override) {
+  const result = {};
+  for (const key of Object.keys(base)) {
+    if (isPrototypePollutionKey(key))
+      continue;
+    defineOwnConfigValue(result, key, base[key]);
+  }
+  for (const key of Object.keys(override)) {
+    if (isPrototypePollutionKey(key))
+      continue;
+    const baseVal = Object.hasOwn(base, key) ? base[key] : undefined;
+    const overrideVal = override[key];
+    let mergedValue;
+    if (baseVal !== null && typeof baseVal === "object" && !Array.isArray(baseVal) && overrideVal !== null && typeof overrideVal === "object" && !Array.isArray(overrideVal)) {
+      mergedValue = key === "protected_tools" ? Object.fromEntries([baseVal, overrideVal].flatMap((value) => Object.entries(value).map(([name, count]) => [
+        name.toLowerCase().replace(/^mcp_/, ""),
+        count
+      ]))) : deepMergeRawConfig(baseVal, overrideVal);
+    } else if (key === "disabled_hooks" && Array.isArray(baseVal) && Array.isArray(overrideVal)) {
+      mergedValue = [...new Set([...baseVal, ...overrideVal])];
+    } else {
+      mergedValue = overrideVal;
+    }
+    defineOwnConfigValue(result, key, mergedValue);
+  }
+  return result;
+}
+function redactConfigValue(value) {
+  if (value === undefined)
+    return "<missing>";
+  if (value === null)
+    return "null";
+  if (typeof value === "string")
+    return `string, ${value.length} char${value.length === 1 ? "" : "s"}`;
+  if (typeof value === "number")
+    return `number ${value}`;
+  if (typeof value === "boolean")
+    return `boolean ${value}`;
+  if (Array.isArray(value))
+    return `array, ${value.length} item${value.length === 1 ? "" : "s"}`;
+  if (typeof value === "object") {
+    const keys = Object.keys(value);
+    return `object with keys [${keys.join(", ")}]`;
+  }
+  return typeof value;
+}
+var warnedProtectedTagsDeprecation = false;
+function formatProtectedTokensBelowMinWarning(value) {
+  return `protected_tokens is a token floor (minimum ${PROTECTED_TOKENS_MIN}, default derived from the context window); ${value} looks like the old protected_tags count. Remove the key to use the default, or set a token count such as 16000.`;
+}
+var MODEL_HARNESS_BLOCKS = ["opencode", "pi", "omp"];
+function misplacedAgentModelWarnings(rawConfig) {
+  const warnings = [];
+  for (const agent of ["historian", "dreamer"]) {
+    const block = rawConfig[agent];
+    if (!block || typeof block !== "object" || Array.isArray(block))
+      continue;
+    const record = block;
+    if (!Object.hasOwn(record, "model"))
+      continue;
+    const harnessWithModel = MODEL_HARNESS_BLOCKS.find((harness) => {
+      const sub = record[harness];
+      return sub !== null && typeof sub === "object" && !Array.isArray(sub) && Object.hasOwn(sub, "model");
+    });
+    if (harnessWithModel)
+      continue;
+    warnings.push(`${agent}.model is not read: the ${agent} model is resolved per harness, so it has to be ${agent}.opencode.model (OpenCode 1 and 2), ${agent}.pi.model, or ${agent}.omp.model. As written the ${agent} resolves to no models and never runs.`);
+  }
+  return warnings;
+}
+function warnProtectedTagsDeprecationOnce() {
+  if (!warnedProtectedTagsDeprecation) {
+    warnedProtectedTagsDeprecation = true;
+    log("[magic-context] protected_tags is deprecated and ignored; use protected_tokens instead.");
+  }
+}
+function parsePluginConfig(rawConfig, recoveredTopLevelKeys = []) {
+  const preMigrationWarnings = [];
+  const configWithoutRemovedAgent = stripRemovedAgentConfig(rawConfig, preMigrationWarnings);
+  if (Object.hasOwn(rawConfig, "protected_tags")) {
+    warnProtectedTagsDeprecationOnce();
+    preMigrationWarnings.push("protected_tags is deprecated and ignored; use protected_tokens instead.");
+  }
+  if (Object.hasOwn(rawConfig, "smart_drops")) {
+    preMigrationWarnings.push("smart_drops is deprecated and ignored; supersession reclaim is always on. This key no longer does anything; remove it.");
+  }
+  preMigrationWarnings.push(...misplacedAgentModelWarnings(rawConfig));
+  const migratedExperimental = migrateLegacyExperimental(configWithoutRemovedAgent, preMigrationWarnings);
+  const migratedDreamer = migrateDreamerV2(migratedExperimental, preMigrationWarnings);
+  const migrated = migrateLegacyAgentEnabledInMemory(migratedDreamer, preMigrationWarnings);
+  const parsed = MagicContextConfigSchema.safeParse(migrated);
+  const disabledHooks = Array.isArray(rawConfig.disabled_hooks) ? rawConfig.disabled_hooks.filter((value) => typeof value === "string") : undefined;
+  const command = typeof rawConfig.command === "object" && rawConfig.command !== null ? rawConfig.command : undefined;
+  if (parsed.success) {
+    return {
+      ...parsed.data,
+      disabled_hooks: disabledHooks,
+      command,
+      ...preMigrationWarnings.length > 0 ? { configWarnings: preMigrationWarnings } : {}
+    };
+  }
+  const defaults = MagicContextConfigSchema.parse({});
+  const warnings = [];
+  const errorPaths = new Set;
+  const customMessagesByKey = new Map;
+  const issuePathsByKey = new Map;
+  const GENERIC_ZOD_PREFIXES = ["Too big", "Too small", "Invalid input", "Invalid", "Expected"];
+  for (const issue of parsed.error.issues) {
+    const topKey = issue.path[0];
+    if (topKey !== undefined) {
+      const key = String(topKey);
+      errorPaths.add(key);
+      const paths = issuePathsByKey.get(key) ?? [];
+      if (issue.code === "unrecognized_keys") {
+        for (const unrecognizedKey of issue.keys) {
+          paths.push([...issue.path, unrecognizedKey]);
+        }
+      } else {
+        paths.push([...issue.path]);
+      }
+      issuePathsByKey.set(key, paths);
+      const msg = issue.message;
+      if (msg && !GENERIC_ZOD_PREFIXES.some((p) => msg.startsWith(p))) {
+        if (!customMessagesByKey.has(key)) {
+          customMessagesByKey.set(key, msg);
+        }
+      }
+    }
+  }
+  const patched = { ...rawConfig };
+  for (const key of errorPaths) {
+    recoveredTopLevelKeys.push(key);
+    const isAgentConfig = key === "historian" || key === "dreamer";
+    const issuePaths = issuePathsByKey.get(key) ?? [];
+    const rawValue = rawConfig[key];
+    const allNested = issuePaths.length > 0 && issuePaths.every((p) => p.length >= 2) && typeof rawValue === "object" && rawValue !== null && !Array.isArray(rawValue);
+    if (allNested) {
+      let prunedBlock = {
+        ...rawValue
+      };
+      const prunedLeaves = [];
+      for (const p of issuePaths) {
+        const relative = p.slice(1);
+        const result = pruneNestedConfigLeaf(prunedBlock, relative);
+        if (result) {
+          prunedBlock = result.block;
+          prunedLeaves.push(result.removed);
+        }
+      }
+      if (prunedLeaves.length === issuePaths.length) {
+        patched[key] = prunedBlock;
+        const reason = customMessagesByKey.get(key);
+        warnings.push(`"${key}": invalid nested field(s) ${prunedLeaves.map((leaf) => `"${key}.${leaf}"`).join(", ")}, using defaults for those.${reason ? ` ${reason}` : ""}`);
+        continue;
+      }
+    }
+    if (isAgentConfig) {
+      delete patched[key];
+      warnings.push(`"${key}": invalid agent configuration, ignoring. Check your magic-context.jsonc.`);
+      continue;
+    }
+    delete patched[key];
+    const defaultVal = defaults[key];
+    const reason = customMessagesByKey.get(key);
+    const invalidRawValue = rawConfig[key];
+    if (key === "protected_tokens" && typeof invalidRawValue === "number" && invalidRawValue < PROTECTED_TOKENS_MIN) {
+      warnings.push(formatProtectedTokensBelowMinWarning(invalidRawValue));
+      continue;
+    }
+    warnings.push(`"${key}": invalid value (${redactConfigValue(rawConfig[key])}), using default ${JSON.stringify(defaultVal)}.${reason ? ` ${reason}` : ""}`);
+  }
+  const retryMigrated = migrateLegacyAgentEnabledInMemory(migrateDreamerV2(migrateLegacyExperimental(patched, preMigrationWarnings), preMigrationWarnings), preMigrationWarnings);
+  const retryParsed = MagicContextConfigSchema.safeParse(retryMigrated);
+  if (retryParsed.success) {
+    return {
+      ...retryParsed.data,
+      disabled_hooks: disabledHooks,
+      command,
+      configWarnings: [...preMigrationWarnings, ...warnings]
+    };
+  }
+  warnings.push("Config recovery failed, using all defaults.");
+  return {
+    ...defaults,
+    disabled_hooks: disabledHooks,
+    command,
+    configWarnings: [...preMigrationWarnings, ...warnings]
+  };
+}
+function collectSchemaIssuePaths(rawConfig) {
+  const scratch = [];
+  const migrated = migrateLegacyAgentEnabledInMemory(migrateDreamerV2(migrateLegacyExperimental(stripRemovedAgentConfig(rawConfig, scratch), scratch), scratch), scratch);
+  const parsed = MagicContextConfigSchema.safeParse(migrated);
+  if (parsed.success)
+    return [];
+  return parsed.error.issues.flatMap((issue) => issue.code === "unrecognized_keys" ? issue.keys.map((key) => [...issue.path, key]) : [[...issue.path]]);
+}
+function hasUserTierSubcConfig(config) {
+  const subc = config?.subc;
+  if (typeof subc !== "object" || subc === null || Array.isArray(subc))
+    return false;
+  const connectionFile = subc.connection_file;
+  return typeof connectionFile === "string" && connectionFile.trim().length > 0;
+}
+function collectEmptyStringPaths(value, prefix = "") {
+  if (typeof value === "string") {
+    return value === "" && prefix ? [prefix] : [];
+  }
+  if (Array.isArray(value) || value === null || typeof value !== "object") {
+    return [];
+  }
+  const paths = [];
+  for (const [key, child] of Object.entries(value)) {
+    const nextPrefix = prefix ? `${prefix}.${key}` : key;
+    paths.push(...collectEmptyStringPaths(child, nextPrefix));
+  }
+  return paths;
+}
+function bindSubstitutionFailures(loaded) {
+  if (!loaded || loaded.warnings.length === 0 || loaded.outcome !== "substitution-failure") {
+    return [];
+  }
+  const emptyPaths = collectEmptyStringPaths(loaded.config);
+  return loaded.warnings.map((message) => {
+    const matchedPath = emptyPaths.find((path) => {
+      const tail = path.split(".").at(-1) ?? path;
+      return message.includes(path) || message.toLowerCase().includes(tail.toLowerCase());
+    });
+    return { keyPath: matchedPath ?? "<unknown>", source: loaded.source, message };
+  });
+}
+function combinedOutcome(args) {
+  const sourceOutcomes = Object.values(args.sources);
+  if (sourceOutcomes.includes("project-file-parse-error"))
+    return "project-file-parse-error";
+  if (sourceOutcomes.includes("project-file-io-error"))
+    return "project-file-io-error";
+  if (sourceOutcomes.includes("legacy-config-unmigrated"))
+    return "legacy-config-unmigrated";
+  if (args.recoveredTopLevelKeys.length > 0)
+    return "schema-recovery";
+  if (args.substitutionFailures.length > 0)
+    return "substitution-failure";
+  return "ok";
+}
+function loadPluginConfigDetailed(directory, applyRuntimeGlobals = true) {
+  const userDetected = detectConfigFile(getUserConfigBasePath());
+  const projectDetected = detectConfigFile(getProjectConfigBasePath(directory));
+  const legacySources = resolveLegacyConfigSources(directory);
+  const harnessLegacy = resolveLegacyConfigSourcesForHarness(directory, "opencode");
+  const userLegacyFallback = userDetected.format === "none" ? resolveLegacyReadFallback(harnessLegacy.user) : { source: null };
+  const projectLegacyFallback = projectDetected.format === "none" ? resolveLegacyReadFallback(harnessLegacy.project) : { source: null };
+  const legacyUserUnmigrated = userDetected.format === "none" && !userLegacyFallback.source && legacySources.user.some((source) => existsSync4(source.path));
+  const legacyProjectUnmigrated = projectDetected.format === "none" && !projectLegacyFallback.source && legacySources.project.some((source) => existsSync4(source.path));
+  const userLoaded = userDetected.format !== "none" ? loadConfigFileDetailed(userDetected.path, "user") : userLegacyFallback.source ? loadConfigFileDetailed(userLegacyFallback.source.path, "user") : null;
+  const projectLoaded = projectDetected.format !== "none" ? loadConfigFileDetailed(projectDetected.path, "project") : projectLegacyFallback.source ? loadConfigFileDetailed(projectLegacyFallback.source.path, "project") : null;
+  const allWarnings = [];
+  const removedConfigWarnings = [];
+  const userRaw = stripRemovedAgentConfig(userLoaded?.config ?? {}, removedConfigWarnings);
+  if (userLegacyFallback.source) {
+    allWarnings.push(`[user config] reading legacy config from ${userLegacyFallback.source.path} until migration completes; run \`npx @cortexkit/magic-context doctor\` to consolidate into the shared CortexKit location.`);
+  } else if (legacyUserUnmigrated) {
+    allWarnings.push("[user config] legacy Magic Context config exists but the shared CortexKit config is absent; embedding registration is paused until config migration completes.");
+  }
+  if (projectLegacyFallback.source) {
+    allWarnings.push(`[project config] reading legacy config from ${projectLegacyFallback.source.path} until migration completes; run \`npx @cortexkit/magic-context doctor\` to consolidate into the shared CortexKit location.`);
+  } else if (legacyProjectUnmigrated) {
+    allWarnings.push("[project config] legacy Magic Context config exists but the shared CortexKit config is absent; embedding registration is paused until config migration completes.");
+  }
+  if (userLoaded) {
+    allWarnings.push(...userLoaded.warnings.map((w) => `[user config] ${w}`));
+  }
+  let projectRaw = {};
+  if (projectLoaded) {
+    allWarnings.push(...projectLoaded.warnings.map((w) => `[project config] ${w}`));
+    projectRaw = stripRemovedAgentConfig(projectLoaded.config, removedConfigWarnings);
+    for (const warning of stripUnsafeProjectConfigFields(projectRaw)) {
+      allWarnings.push(`[project config] ${warning}`);
+    }
+  }
+  allWarnings.push(...removedConfigWarnings.map((warning) => `[config] ${warning}`));
+  const profileResolution = resolveConfigProfile({
+    userRaw,
+    projectRaw
+  });
+  allWarnings.push(...profileResolution.warnings.map((warning) => `[config] ${warning}`));
+  const trustedProfiledRaw = deepMergeRawConfig(profileResolution.userBase, profileResolution.overlay);
+  let mergedRaw = trustedProfiledRaw;
+  const trustedBaseConfig = parsePluginConfig(trustedProfiledRaw);
+  let projectRestoredTopLevelKeys = [];
+  if (projectLoaded) {
+    mergedRaw = deepMergeRawConfig(mergedRaw, profileResolution.projectBase);
+    for (const warning of dropInheritedEmbeddingKeyOnRedirect(projectRaw, mergedRaw, profileResolution.userBase)) {
+      allWarnings.push(`[project config] ${warning}`);
+    }
+    for (const warning of constrainProjectThresholdOverrides({
+      mergedRaw,
+      projectRaw: profileResolution.projectBase,
+      trustedBaseConfig
+    })) {
+      allWarnings.push(`[project config] ${warning}`);
+    }
+    const restoredOverProject = restoreTrustedValuesOverInvalidProjectValues({
+      mergedRaw,
+      trustedRaw: trustedProfiledRaw,
+      projectRaw: profileResolution.projectBase,
+      collectIssuePaths: collectSchemaIssuePaths
+    });
+    for (const warning of restoredOverProject.warnings) {
+      allWarnings.push(`[project config] ${warning}`);
+    }
+    projectRestoredTopLevelKeys = restoredOverProject.restoredTopLevelKeys;
+    for (const warning of constrainProjectCommands({
+      mergedRaw,
+      trustedRaw: trustedProfiledRaw,
+      projectRaw: profileResolution.projectBase,
+      reservedNames: Object.keys(getMagicContextBuiltinCommands())
+    })) {
+      allWarnings.push(`[project config] ${warning}`);
+    }
+  }
+  const recoveredTopLevelKeys = [];
+  const cacheTtlConfigured = Object.hasOwn(mergedRaw, "cache_ttl");
+  const config = parsePluginConfig(mergedRaw, recoveredTopLevelKeys);
+  for (const key of projectRestoredTopLevelKeys) {
+    if (!recoveredTopLevelKeys.includes(key))
+      recoveredTopLevelKeys.push(key);
+  }
+  attachProtectedTokensTierOverrides(config, {
+    trustedUser: trustedBaseConfig.protected_tokens,
+    project: projectLoaded ? profileResolution.projectBase.protected_tokens : undefined
+  });
+  if (profileResolution.activeProfile)
+    config.profile = profileResolution.activeProfile;
+  if (applyRuntimeGlobals) {
+    setOutputReserveConfig(config.output_reserve);
+    setWindowOverlayPath(config.models?.window_overlay_path);
+  }
+  const leafValidationWarnings = [...config.configWarnings ?? []];
+  if (config.configWarnings?.length) {
+    allWarnings.push(...config.configWarnings.map((w) => {
+      if (userLoaded && projectLoaded)
+        return `[config] ${w}`;
+      if (userLoaded)
+        return `[user config] ${w}`;
+      return `[project config] ${w}`;
+    }));
+  }
+  const resolvedTransformMode = resolveTransformMode({
+    configured: config.transform_mode,
+    userTierHasSubc: hasUserTierSubcConfig(userRaw),
+    compactionEnabled: isCompactionEnabled(config)
+  });
+  config.transform_mode = resolvedTransformMode.mode;
+  allWarnings.push(...resolvedTransformMode.warnings.map((warning) => `[config] ${warning}`));
+  if (allWarnings.length > 0) {
+    config.configWarnings = allWarnings;
+  } else if ("configWarnings" in config) {
+    config.configWarnings = undefined;
+  }
+  const substitutionFailures = [
+    ...bindSubstitutionFailures(userLoaded),
+    ...bindSubstitutionFailures(projectLoaded)
+  ];
+  const configParseFailures = [
+    ...userLoaded?.parseFailures ?? [],
+    ...projectLoaded?.parseFailures ?? []
+  ];
+  const warningDetails = [
+    ...userLoaded?.warningDetails ?? [],
+    ...projectLoaded?.warningDetails ?? [],
+    ...leafValidationWarnings.map((message) => ({
+      warningClass: CONFIG_WARNING_CLASS.INVALID_LEAF,
+      message
+    }))
+  ];
+  config.configParseFailures = configParseFailures;
+  config.configWarningDetails = warningDetails;
+  config.cacheTtlConfigured = cacheTtlConfigured;
+  const sources = {
+    userConfig: userLoaded?.outcome ?? (legacyUserUnmigrated ? "legacy-config-unmigrated" : "ok"),
+    projectConfig: projectLoaded?.outcome ?? (legacyProjectUnmigrated ? "legacy-config-unmigrated" : "ok")
+  };
+  return {
+    config,
+    registrationPromptSurface: trustedBaseConfig.prompt_surface,
+    loadOutcome: combinedOutcome({ sources, substitutionFailures, recoveredTopLevelKeys }),
+    sources,
+    substitutionFailures,
+    recoveredTopLevelKeys,
+    configParseFailures,
+    warningDetails,
+    cacheTtlConfigured
+  };
+}
+
+export { getMagicContextBuiltinCommands, parseJsoncRecovering, readJsoncFile, detectConfigFile, COMPACTION_ENABLED_PATH, isDreamerRunnable, isCompactionEnabled, cortexKitUserConfigBasePath, cortexKitProjectConfigBasePath, resolveLegacyConfigSources, resolveLegacyConfigSourcesForHarness, getProtectedTokensTierOverrides, loadPluginConfigDetailed };