@cortexkit/opencode-magic-context 0.46.1 → 0.48.0

package/dist/v2/{server-c5gz8wph.js → server-x2g40a71.js}

@@ -1,3 +1,10 @@
+import {
+  log2
+} from "./server-5m3dt5r1.js";
+import {
+  setWindowOverlayPath,
+  setOutputReserveConfig
+} from "./server-v06jcv0w.js";
 import {
   DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE,
   PROTECTED_TOKENS_MIN,
@@ -5,1039 +12,355 @@ import {
   PER_HARNESS_MODEL_KEYS,
   ConfigProfilesSchema,
   MagicContextConfigSchema
-} from "./server-e29d7p7c.js";
-import {
-  log
-} from "./server-1qbnzc80.js";
-import {
-  setWindowOverlayPath,
-  setOutputReserveConfig
-} from "./server-y8maxeft.js";
+} from "./server-zm570tr2.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/index.ts
+import { existsSync as existsSync4 } from "node:fs";
 
-// 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 } : {}
+// 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"
     },
-    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);
+    "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)"
     }
-  }
+  };
 }
-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);
+
+// 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++;
     }
-  }
-}
-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);
+    if (digits < count) {
+      value = -1;
     }
+    return value;
   }
-}
-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 };
+  function setPosition(newPosition) {
+    pos = newPosition;
+    value = "";
+    tokenOffset = 0;
+    token = 16;
+    scanError = 0;
   }
-  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);
+  function scanNumber() {
+    let start = pos;
+    if (text.charCodeAt(pos) === 48) {
+      pos++;
+    } else {
+      pos++;
+      while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
       }
     }
-    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);
+    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);
+      }
     }
-  }
-  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);
-          }
-        }
+    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++;
       }
-    }
-    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 (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
         }
+        end = pos;
+      } else {
+        scanError = 3;
       }
     }
-    if (removed.length > 0) {
-      warnings.push(`Ignoring ${removed.join(", ")} from project config ` + "(security: a repository cannot reprogram or re-permission hidden agents).");
-    }
+    return text.substring(start, end);
   }
-  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);
+  function scanString() {
+    let result = "", start = pos;
+    while (true) {
+      if (pos >= len) {
+        result += text.substring(start, pos);
+        scanError = 2;
+        break;
       }
-    }
-    for (const harness of HARNESS_KEYS) {
-      const harnessBlock = historian[harness];
-      if (!isPlainObject(harnessBlock))
+      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;
-      for (const field of HISTORIAN_USER_ONLY_FIELDS) {
-        if (field in harnessBlock) {
-          delete harnessBlock[field];
-          removed.push(`${harness}.${field}`);
+      }
+      if (ch >= 0 && ch <= 31) {
+        if (isLineBreak(ch)) {
+          result += text.substring(start, pos);
+          scanError = 2;
+          break;
+        } else {
+          scanError = 6;
         }
       }
+      pos++;
     }
-    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).");
-    }
+    return result;
   }
-  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));
+  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 += `
+`;
       }
-    } 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));
+      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;
         }
-      }
-      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);
+        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;
+            }
           }
-        } else {
-          warnings.push(makeProjectThresholdWarning(`execute_threshold_percentage.${modelKey}`, PERCENTAGE_THRESHOLD_REASON));
+          if (!commentClosed) {
+            pos++;
+            scanError = 1;
+          }
+          value = text.substring(start, pos);
+          return token = 13;
         }
-      }
-      if (touchedValidEntry) {
-        setMergedPercentageThreshold(args.mergedRaw, constrained);
-      }
+        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;
     }
   }
-  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));
-      }
+  function isUnknownContentCharacter(code) {
+    if (isWhiteSpace(code) || isLineBreak(code)) {
+      return false;
     }
-    if (touchedValidEntry) {
-      setMergedTokenThreshold(args.mergedRaw, constrained);
+    switch (code) {
+      case 125:
+      case 93:
+      case 123:
+      case 91:
+      case 34:
+      case 58:
+      case 44:
+      case 47:
+        return false;
     }
-  }
-  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;
+    return true;
   }
   function scanNextNonTrivia() {
     let result;
@@ -1673,1186 +996,1846 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
       }
     }
   }
-  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;
+  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");
         }
-        token = scanNext();
+        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);
     }
-  }
-  function parseString(isValue) {
-    const value = _scanner.getTokenValue();
-    if (isValue) {
-      onLiteralValue(value);
+  } 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 {
-      onObjectProperty(value);
-      _jsonPath.push(value);
+      throw new Error(`Can not ${value === undefined ? "remove" : options.isArrayInsertion ? "insert" : "modify"} Array index ${insertIndex} as length is not sufficient`);
     }
-    scanNext();
-    return true;
+  } else {
+    throw new Error(`Can not add ${typeof lastSegment !== "number" ? "index" : "property"} to parent of type ${parent.type}`);
   }
-  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;
+}
+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++;
     }
-    scanNext();
-    return true;
   }
-  function parseProperty() {
-    if (_scanner.getToken() !== 10) {
-      handleError(3, [], [2, 5]);
-      return false;
+  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;
     }
-    parseString(false);
-    if (_scanner.getToken() === 6) {
-      onSeparator(":");
-      scanNext();
-      if (!parseValue()) {
-        handleError(4, [], [2, 5]);
-      }
+    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 {
-      handleError(5, [], [2, 5]);
+      throw new Error("Overlapping edit");
     }
-    _jsonPath.pop();
-    return true;
+    lastModifiedOffset = e.offset;
   }
-  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, [], []);
+  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;
       }
-      if (!parseProperty()) {
-        handleError(4, [], [2, 5]);
+      continue;
+    }
+    if (inBlockComment) {
+      if (char === "*" && next === "/") {
+        inBlockComment = false;
+        index += 1;
       }
-      needsComma = true;
+      continue;
     }
-    onObjectEnd();
-    if (_scanner.getToken() !== 2) {
-      handleError(7, [2], []);
-    } else {
-      scanNext();
+    if (inString) {
+      result += char;
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === '"') {
+        inString = false;
+      }
+      continue;
     }
-    return true;
+    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;
   }
-  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]);
+  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;
       }
-      needsComma = true;
+      continue;
     }
-    onArrayEnd();
-    if (!isFirstElement) {
-      _jsonPath.pop();
+    if (char === '"') {
+      inString = true;
+      result += char;
+      continue;
     }
-    if (_scanner.getToken() !== 4) {
-      handleError(8, [4], []);
-    } else {
-      scanNext();
+    if (char === ",") {
+      let lookahead = index + 1;
+      while (lookahead < content.length && /\s/.test(content[lookahead] ?? "")) {
+        lookahead += 1;
+      }
+      const next = content[lookahead];
+      if (next === "}" || next === "]") {
+        continue;
+      }
     }
-    return true;
+    result += char;
   }
-  function parseValue() {
-    switch (_scanner.getToken()) {
-      case 3:
-        return parseArray();
-      case 1:
-        return parseObject();
-      case 10:
-        return parseString(true);
-      default:
-        return parseLiteral();
+  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;
   }
-  scanNext();
-  if (_scanner.getToken() === 17) {
-    if (options.allowEmptyContent) {
-      return true;
-    }
-    handleError(4, [], []);
-    return false;
+}
+function detectConfigFile(basePath) {
+  const jsoncPath = `${basePath}.jsonc`;
+  const jsonPath = `${basePath}.json`;
+  if (existsSync(jsoncPath)) {
+    return { format: "jsonc", path: jsoncPath };
   }
-  if (!parseValue()) {
-    handleError(4, [], []);
-    return false;
+  if (existsSync(jsonPath)) {
+    return { format: "json", path: jsonPath };
   }
-  if (_scanner.getToken() !== 17) {
-    handleError(9, [], []);
+  return { format: "none", path: jsoncPath };
+}
+
+// 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 true;
+  return { ...value };
 }
-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";
+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;
 }
 
-// ../../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();
+// 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 = 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;
-    }
+  const root = parseTree2(text, errors, { allowTrailingComma: true });
+  if (!root || errors.length > 0) {
+    throw new Error("Cannot edit invalid JSONC");
   }
-  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`);
+  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()
+      };
     }
-  } 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++;
-    }
+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 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 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 editLength = text.length - (newText.length - end) - begin;
-  return [{ offset: begin, length: editLength, content: newText.substring(begin, end) }];
+  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 applyEdit(text, edit) {
-  return text.substring(0, edit.offset) + edit.content + text.substring(edit.offset + edit.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);
 }
 
-// ../../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";
+// 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 "<unknown ParseErrorCode>";
+  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 modify(text, path, value, options) {
-  return setProperty(text, path, value, options);
+function asObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
 }
-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;
+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 text;
+  return 24 * 60;
 }
-
-// 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;
-      }
+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);
     }
-    if (char === '"') {
-      inString = true;
-      result += char;
-      continue;
+  }
+  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 };
     }
-    if (char === "/" && next === "/") {
-      inLineComment = true;
-      index += 1;
-      continue;
+    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
+      });
     }
-    if (char === "/" && next === "*") {
-      inBlockComment = true;
-      index += 1;
-      continue;
+    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)
+      });
     }
-    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 (!tasks["verify-broad"]) {
+      const verifyEnabled = typeof tasks.verify?.schedule === "string" && tasks.verify.schedule.trim() !== "";
+      tasks["verify-broad"] = withTimeout({
+        schedule: verifyEnabled ? DEFAULT_VERIFY_BROAD_CRON : ""
+      });
     }
-    if (char === '"') {
-      inString = true;
-      result += char;
-      continue;
+    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)
+      });
     }
-    if (char === ",") {
-      let lookahead = index + 1;
-      while (lookahead < content.length && /\s/.test(content[lookahead] ?? "")) {
-        lookahead += 1;
-      }
-      const next = content[lookahead];
-      if (next === "}" || next === "]") {
-        continue;
+    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 });
       }
     }
-    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
+  } 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
     });
-  }
-  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])
+    tasks.retrospective = withTimeout({
+      schedule: retrospectiveSchedule
+    });
+    tasks["maintain-docs"] = withTimeout({
+      schedule: legacyArray?.includes("maintain-docs") ? baseCron : ""
     });
   }
-  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 };
+  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 } : {}
+    });
   }
-  return { format: "none", path: jsoncPath };
+  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-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");
+// src/config/migrate-experimental.ts
+function migrateLegacyExperimental(rawConfig, warnings) {
+  const experimental = rawConfig.experimental;
+  if (typeof experimental !== "object" || experimental === null) {
+    return rawConfig;
   }
-  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)
+  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;
-    if (kind === TOKEN_COMMA) {
-      return {
-        offset,
-        length: scanner.getTokenLength(),
-        line: scanner.getTokenStartLine()
+    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;
   }
-}
-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);
+  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;
   }
-  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);
+  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;
   }
-  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);
+  patched.experimental = newExperimental;
+  patched.dreamer = dreamer;
+  if (Object.keys(memory).length > 0) {
+    patched.memory = memory;
+  }
+  return patched;
 }
 
-// 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();
+// src/config/mural-model-deprecation.ts
+var MURAL_MODEL_DEPRECATION_WARNING = "mural.model is deprecated and ignored; compress-cues now uses the dreamer model for each harness, like every other dreamer task. To override it, set dreamer.opencode.tasks.compress-cues.model (or the pi/omp equivalent). This key no longer does anything; remove it.";
+function warnDeprecatedMuralModel(config, warnings) {
+  const mural = config.mural;
+  if (typeof mural === "object" && mural !== null && Object.hasOwn(mural, "model")) {
+    warnings.push(MURAL_MODEL_DEPRECATION_WARNING);
   }
-  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`)
-  ]);
+
+// src/config/profiles.ts
+function withoutProfileFields(raw) {
+  const copy = { ...raw };
+  delete copy.profile;
+  delete copy.profiles;
+  return copy;
 }
-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 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 resolveLegacyConfigSourcesForHarness(directory, harness) {
-  if (harness === "pi") {
+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 {
-      user: legacySourcesForBase(join(homeDir(), ".pi", "agent", CONFIG_FILE_BASENAME), "Pi user"),
-      project: legacySourcesForBase(join(directory, ".pi", CONFIG_FILE_BASENAME), "Pi project")
+      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 {
-    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")
-    ]
+    userBase: withoutProfileFields(args.userRaw),
+    projectBase: withoutProfileFields(args.projectRaw),
+    overlay,
+    activeProfile: selection.name,
+    warnings
   };
 }
 
-// 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"
+// 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 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} * * *`;
+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 asObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+function resolveProtectedTokensScalar(value) {
+  if (typeof value === "number" && Number.isInteger(value) && value >= 4000 && value <= 1e6) {
+    return value;
+  }
+  return;
 }
-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;
+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);
+      }
+    }
   }
-  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 isValidPercentageThreshold(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 20 && value <= 90;
 }
-function withoutBroadInterval(entry) {
-  const { broad_interval_days: _broad, ...rest } = entry;
-  return rest;
+function isValidTokenThreshold(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 5000 && value <= 2000000;
 }
-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")
+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;
-    const obj = asObject(value);
-    nextTasks[key] = obj ? withoutBroadInterval(obj) : value;
+    if (typeof child === "number" && Number.isFinite(child)) {
+      overrides.set(key, child);
+    }
   }
-  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 {
+    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 { ...rawConfig, dreamer: { ...dreamer, tasks: nextTasks } };
+  return true;
 }
-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);
+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 smartNotes = projectRaw.smart_notes;
+  if (isPlainObject(smartNotes) && "enabled" in smartNotes) {
+    delete smartNotes.enabled;
+    warnings.push("Ignoring smart_notes.enabled from project config (only user-level config may change process-wide tool definitions; restart required).");
+  }
+  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 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 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 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 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);
+      }
     }
-    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 (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);
+          }
+        }
+      }
     }
-    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 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);
+        }
+      }
     }
-    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)
-      });
+    if (removed.length > 0) {
+      warnings.push(`Ignoring ${removed.join(", ")} from project config ` + "(security: a repository cannot reprogram or re-permission hidden agents).");
     }
-    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 });
+  }
+  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);
       }
     }
-  } 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 : ""
-    });
+    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).");
+    }
   }
-  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 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 {
-    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 } };
+  return warnings;
 }
-
-// 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;
+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);
+      }
+    }
   }
-  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 ("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));
+      }
     }
-    if (typeof value === "object" && value !== null) {
-      return { ...value };
+    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));
+      }
     }
-    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
-      };
+    if (touchedValidEntry) {
+      setMergedTokenThreshold(args.mergedRaw, constrained);
     }
-    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
-      };
+  }
+  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));
     }
-    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
-        };
-      }
+  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 [];
     }
-    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 };
-      }
+  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);
     }
-    delete newExperimental.pin_key_files;
   }
-  patched.experimental = newExperimental;
-  patched.dreamer = dreamer;
-  if (Object.keys(memory).length > 0) {
-    patched.memory = memory;
+  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 patched;
+  return;
 }
-
-// src/config/profiles.ts
-function withoutProfileFields(raw) {
-  const copy = { ...raw };
-  delete copy.profile;
-  delete copy.profiles;
-  return copy;
+function defineOwnValue(target, key, value) {
+  Object.defineProperty(target, key, {
+    value,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  });
 }
-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 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);
 }
-function resolveConfigProfile(args) {
+var MAX_PROJECT_RESTORE_ROUNDS = 16;
+function restoreTrustedValuesOverInvalidProjectValues(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.");
+  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;
   }
-  if (!selection) {
-    return {
-      userBase: withoutProfileFields(args.userRaw),
-      projectBase: withoutProfileFields(args.projectRaw),
-      overlay: {},
-      warnings
-    };
+  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 (!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
-    };
+  if (value.subtask !== undefined) {
+    if (typeof value.subtask !== "boolean")
+      return;
+    command.subtask = value.subtask;
   }
-  const overlay = profiles[selection.name];
-  return {
-    userBase: withoutProfileFields(args.userRaw),
-    projectBase: withoutProfileFields(args.projectRaw),
-    overlay,
-    activeProfile: selection.name,
-    warnings
-  };
+  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/prune-config-leaf.ts
@@ -3566,12 +3549,17 @@ function misplacedAgentModelWarnings(rawConfig) {
 function warnProtectedTagsDeprecationOnce() {
   if (!warnedProtectedTagsDeprecation) {
     warnedProtectedTagsDeprecation = true;
-    log("[magic-context] protected_tags is deprecated and ignored; use protected_tokens instead.");
+    log2("[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, "clear_reasoning_age")) {
+    const warning = "clear_reasoning_age is deprecated and ignored. Magic Context now keeps reasoning up to a token budget, keep_reasoning_tokens (default 10,000). Remove the key, or set keep_reasoning_tokens to a token count.";
+    preMigrationWarnings.push(warning);
+    log2(`[magic-context] ${warning}`);
+  }
   if (Object.hasOwn(rawConfig, "protected_tags")) {
     warnProtectedTagsDeprecationOnce();
     preMigrationWarnings.push("protected_tags is deprecated and ignored; use protected_tokens instead.");
@@ -3581,6 +3569,7 @@ function parsePluginConfig(rawConfig, recoveredTopLevelKeys = []) {
   }
   preMigrationWarnings.push(...misplacedAgentModelWarnings(rawConfig));
   const migratedExperimental = migrateLegacyExperimental(configWithoutRemovedAgent, preMigrationWarnings);
+  warnDeprecatedMuralModel(migratedExperimental, preMigrationWarnings);
   const migratedDreamer = migrateDreamerV2(migratedExperimental, preMigrationWarnings);
   const migrated = migrateLegacyAgentEnabledInMemory(migratedDreamer, preMigrationWarnings);
   const parsed = MagicContextConfigSchema.safeParse(migrated);