@cortexkit/pi-magic-context 0.38.1 → 0.39.0

package/dist/{index-8e0zezh7.js → index-qqgk7jmy.js}

@@ -50,7 +50,7 @@ var require_esprima = __commonJS(function(exports, module) {
         var jsx_parser_1 = __webpack_require__(3);
         var parser_1 = __webpack_require__(8);
         var tokenizer_1 = __webpack_require__(15);
-        function parse5(code, options, delegate) {
+        function parse6(code, options, delegate) {
           var commentHandler = null;
           var proxyDelegate = function(node, metadata) {
             if (delegate) {
@@ -95,17 +95,17 @@ var require_esprima = __commonJS(function(exports, module) {
           }
           return ast;
         }
-        exports2.parse = parse5;
+        exports2.parse = parse6;
         function parseModule(code, options, delegate) {
           var parsingOptions = options || {};
           parsingOptions.sourceType = "module";
-          return parse5(code, parsingOptions, delegate);
+          return parse6(code, parsingOptions, delegate);
         }
         exports2.parseModule = parseModule;
         function parseScript(code, options, delegate) {
           var parsingOptions = options || {};
           parsingOptions.sourceType = "script";
-          return parse5(code, parsingOptions, delegate);
+          return parse6(code, parsingOptions, delegate);
         }
         exports2.parseScript = parseScript;
         function tokenize(code, options, delegate) {
@@ -7564,7 +7564,7 @@ var require_parse = __commonJS(function(exports, module) {
         return {};
     }
   }
-  var parse5 = (code, rev, options) => {
+  var parse6 = (code, rev, options) => {
     clean();
     const {
       no_comments,
@@ -7601,7 +7601,7 @@ var require_parse = __commonJS(function(exports, module) {
     return result;
   };
   module.exports = {
-    parse: parse5,
+    parse: parse6,
     tokenize
   };
 });
@@ -7696,10 +7696,10 @@ var require_stringify = __commonJS(function(exports, module) {
     replacer = null;
     indent = EMPTY;
   };
-  var join8 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two)), gap) : EMPTY;
+  var join9 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two)), gap) : EMPTY;
   var join_content = (inside, value, gap) => {
     const comment = process_comments(value, PREFIX_BEFORE, gap + indent, true);
-    return join8(comment, inside, gap);
+    return join9(comment, inside, gap);
   };
   var stringify_string = (holder, key, value) => {
     const raw = get_raw_string_literal(holder, key);
@@ -7721,13 +7721,13 @@ var require_stringify = __commonJS(function(exports, module) {
       if (i !== 0) {
         inside += COMMA;
       }
-      const before = join8(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
+      const before = join9(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
       inside += before || LF + deeper_gap;
       inside += stringify(i, value, deeper_gap) || STR_NULL;
       inside += process_comments(value, AFTER_VALUE(i), deeper_gap);
       after_comma = process_comments(value, AFTER(i), deeper_gap);
     }
-    inside += join8(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join9(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
     return BRACKET_OPEN + join_content(inside, value, gap) + BRACKET_CLOSE;
   };
   var object_stringify = (value, gap) => {
@@ -7748,13 +7748,13 @@ var require_stringify = __commonJS(function(exports, module) {
         inside += COMMA;
       }
       first = false;
-      const before = join8(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
+      const before = join9(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
       inside += before || LF + deeper_gap;
       inside += quote(key) + process_comments(value, AFTER_PROP(key), deeper_gap) + COLON + process_comments(value, AFTER_COLON(key), deeper_gap) + SPACE + sv + process_comments(value, AFTER_VALUE(key), deeper_gap);
       after_comma = process_comments(value, AFTER(key), deeper_gap);
     };
     keys.forEach(iteratee);
-    inside += join8(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join9(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
     return CURLY_BRACKET_OPEN + join_content(inside, value, gap) + CURLY_BRACKET_CLOSE;
   };
   function stringify(key, holder, gap) {
@@ -7816,7 +7816,7 @@ var require_stringify = __commonJS(function(exports, module) {
 
 // ../../node_modules/.bun/comment-json@5.0.0/node_modules/comment-json/src/index.js
 var require_src2 = __commonJS(function(exports, module) {
-  var { parse: parse5, tokenize } = require_parse();
+  var { parse: parse6, tokenize } = require_parse();
   var stringify = require_stringify();
   var { CommentArray } = require_array();
   var {
@@ -7840,7 +7840,7 @@ var require_src2 = __commonJS(function(exports, module) {
     PREFIX_AFTER,
     PREFIX_BEFORE_ALL,
     PREFIX_AFTER_ALL,
-    parse: parse5,
+    parse: parse6,
     stringify,
     tokenize,
     CommentArray,
@@ -12298,6 +12298,37 @@ var MIGRATIONS = [
       ensureColumn(db, "transform_decisions", "m0_model_key_prev", "TEXT");
       ensureColumn(db, "transform_decisions", "m0_model_key_new", "TEXT");
     }
+  },
+  {
+    version: 80,
+    description: "record observed m[0] tool-set hash comparisons",
+    up(db) {
+      if (!tableExists2(db, "transform_decisions"))
+        return;
+      ensureColumn(db, "transform_decisions", "m0_tool_set_hash_prev", "TEXT");
+      ensureColumn(db, "transform_decisions", "m0_tool_set_hash_new", "TEXT");
+    }
+  },
+  {
+    version: 81,
+    description: "persist last-known-good transform snapshots across restarts",
+    up(db) {
+      db.exec(`
+                CREATE TABLE IF NOT EXISTS lkg_slots (
+                    session_id TEXT PRIMARY KEY,
+                    json_prefix TEXT NOT NULL,
+                    input_id_seq TEXT NOT NULL,
+                    input_content_digests TEXT NOT NULL,
+                    input_content_signatures TEXT,
+                    last_input_message_id TEXT NOT NULL,
+                    model_key TEXT,
+                    provider_key TEXT,
+                    captured_at INTEGER NOT NULL,
+                    row_version INTEGER,
+                    capture_sequence INTEGER
+                );
+            `);
+    }
   }
 ];
 var LATEST_MIGRATION_VERSION = MIGRATIONS.reduce((max, m) => Math.max(max, m.version), 0);
@@ -12732,7 +12763,7 @@ function getSchemaFenceRejection() {
 function getMigrationOnOpenRefusal() {
   return lastMigrationOnOpenRefusal;
 }
-var LATEST_SUPPORTED_VERSION = 79;
+var LATEST_SUPPORTED_VERSION = 81;
 var PERMISSIONS_ENFORCEABLE = process.platform !== "win32";
 var defaultStoragePermissionFs = { chmodSync, mkdirSync: mkdirSync2 };
 var storagePermissionFs = defaultStoragePermissionFs;
@@ -13884,10 +13915,12 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
       decision           TEXT    NOT NULL,
       materialized       INTEGER NOT NULL DEFAULT 0,
       materialize_reason TEXT,
-      system_hash_prev   TEXT,
-      system_hash_new    TEXT,
-      m0_model_key_prev  TEXT,
-      m0_model_key_new   TEXT,
+      system_hash_prev      TEXT,
+      system_hash_new       TEXT,
+      m0_tool_set_hash_prev TEXT,
+      m0_tool_set_hash_new  TEXT,
+      m0_model_key_prev     TEXT,
+      m0_model_key_new      TEXT,
       emergency          INTEGER NOT NULL DEFAULT 0,
       dropped_tokens     INTEGER NOT NULL DEFAULT 0,
       dropped_count      INTEGER NOT NULL DEFAULT 0,
@@ -14225,10 +14258,12 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
         decision           TEXT    NOT NULL,
         materialized       INTEGER NOT NULL DEFAULT 0,
         materialize_reason TEXT,
-        system_hash_prev   TEXT,
-        system_hash_new    TEXT,
-        m0_model_key_prev  TEXT,
-        m0_model_key_new   TEXT,
+      system_hash_prev      TEXT,
+      system_hash_new       TEXT,
+      m0_tool_set_hash_prev TEXT,
+      m0_tool_set_hash_new  TEXT,
+      m0_model_key_prev     TEXT,
+      m0_model_key_new      TEXT,
         emergency          INTEGER NOT NULL DEFAULT 0,
         dropped_tokens     INTEGER NOT NULL DEFAULT 0,
         dropped_count      INTEGER NOT NULL DEFAULT 0,
@@ -14682,9 +14717,10 @@ function persistCachedM0(db, sessionId, payload) {
             cached_m0_session_facts_version = ?,
             cached_m0_upgrade_state = ?,
             cached_m0_system_hash = ?,
+            cached_m0_tool_set_hash = ?,
             cached_m0_model_key = ?,
             cached_m0_project_identity = ?
-         WHERE session_id = ?`).run(Buffer2.from(payload.m0Bytes), payload.muralDataUrl ?? null, payload.muralHash ?? null, payload.projectMemoryEpoch, payload.workspaceFingerprint ?? null, payload.projectUserProfileVersion, payload.maxCompartmentSeq, payload.maxMemoryId, payload.maxMutationId, payload.maxMemoryMutationId ?? null, payload.m1Bytes ? Buffer2.from(payload.m1Bytes) : null, payload.projectDocsHash, payload.materializedAt, payload.sessionFactsVersion, payload.upgradeState, payload.systemHash ?? "", payload.modelKey ? piModelRefToCanonical(payload.modelKey) : "", payload.projectIdentity ?? null, sessionId);
+         WHERE session_id = ?`).run(Buffer2.from(payload.m0Bytes), payload.muralDataUrl ?? null, payload.muralHash ?? null, payload.projectMemoryEpoch, payload.workspaceFingerprint ?? null, payload.projectUserProfileVersion, payload.maxCompartmentSeq, payload.maxMemoryId, payload.maxMutationId, payload.maxMemoryMutationId ?? null, payload.m1Bytes ? Buffer2.from(payload.m1Bytes) : null, payload.projectDocsHash, payload.materializedAt, payload.sessionFactsVersion, payload.upgradeState, payload.systemHash ?? "", payload.toolSetHash ?? "", payload.modelKey ? piModelRefToCanonical(payload.modelKey) : "", payload.projectIdentity ?? null, sessionId);
 }
 function clearCachedM0M1(db, sessionId) {
   ensureSessionMetaRow(db, sessionId);
@@ -15189,6 +15225,7 @@ function clearEmergencyDropSample(db, sessionId) {
     db.prepare("UPDATE session_meta SET last_emergency_input_sample = 0 WHERE session_id = ?").run(sessionId);
   })();
 }
+var EMPTY_CHANNEL1_NUDGE_STATE = { level: "", ordinal: 0 };
 function isLastNudgeUndroppedRow(row) {
   return typeof row === "object" && row !== null && typeof row.last_nudge_undropped === "number";
 }
@@ -15198,6 +15235,24 @@ function isLastNudgeLevelRow(row) {
 function normalizeLastNudgeLevel(value) {
   return value === "gentle" || value === "firm" || value === "urgent" ? value : "";
 }
+function parseChannel1NudgeState(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return {
+        level: normalizeLastNudgeLevel(parsed.level),
+        ordinal: typeof parsed.ordinal === "number" ? Math.max(0, Math.round(parsed.ordinal)) : 0
+      };
+    }
+  } catch {}
+  return { level: normalizeLastNudgeLevel(raw), ordinal: 0 };
+}
+function serializeChannel1NudgeState(value) {
+  return JSON.stringify({
+    level: normalizeLastNudgeLevel(value.level),
+    ordinal: Math.max(0, Math.round(value.ordinal))
+  });
+}
 function getLastNudgeUndropped(db, sessionId) {
   const result = db.prepare("SELECT last_nudge_undropped FROM session_meta WHERE session_id = ?").get(sessionId);
   return isLastNudgeUndroppedRow(result) ? result.last_nudge_undropped : 0;
@@ -15208,27 +15263,27 @@ function setLastNudgeUndropped(db, sessionId, value) {
     db.prepare("UPDATE session_meta SET last_nudge_undropped = ? WHERE session_id = ?").run(Math.max(0, Math.round(value)), sessionId);
   })();
 }
-function getLastNudgeLevel(db, sessionId) {
+function getChannel1NudgeState(db, sessionId) {
   const result = db.prepare("SELECT last_nudge_level FROM session_meta WHERE session_id = ?").get(sessionId);
-  return isLastNudgeLevelRow(result) ? normalizeLastNudgeLevel(result.last_nudge_level) : "";
+  return isLastNudgeLevelRow(result) ? parseChannel1NudgeState(result.last_nudge_level) : EMPTY_CHANNEL1_NUDGE_STATE;
 }
-function setLastNudgeLevel(db, sessionId, value) {
+function setChannel1NudgeState(db, sessionId, value) {
   db.transaction(() => {
     ensureSessionMetaRow(db, sessionId);
-    db.prepare("UPDATE session_meta SET last_nudge_level = ? WHERE session_id = ?").run(normalizeLastNudgeLevel(value), sessionId);
+    db.prepare("UPDATE session_meta SET last_nudge_level = ? WHERE session_id = ?").run(serializeChannel1NudgeState(value), sessionId);
   })();
 }
 function resetLastNudgeCycle(db, sessionId) {
   db.transaction(() => {
     ensureSessionMetaRow(db, sessionId);
-    db.prepare("UPDATE session_meta SET last_nudge_undropped = 0, last_nudge_level = '' WHERE session_id = ?").run(sessionId);
+    db.prepare("UPDATE session_meta SET last_nudge_undropped = 0, last_nudge_level = ? WHERE session_id = ?").run(serializeChannel1NudgeState(EMPTY_CHANNEL1_NUDGE_STATE), sessionId);
   })();
 }
 function resetLastNudgeCycleIfTailShrank(db, sessionId, measuredUndropped) {
   let changed = false;
   db.transaction(() => {
     ensureSessionMetaRow(db, sessionId);
-    const result = db.prepare("UPDATE session_meta SET last_nudge_undropped = 0, last_nudge_level = '' WHERE session_id = ? AND last_nudge_undropped > ?").run(sessionId, Math.max(0, Math.round(measuredUndropped)));
+    const result = db.prepare("UPDATE session_meta SET last_nudge_undropped = 0, last_nudge_level = ? WHERE session_id = ? AND last_nudge_undropped > ?").run(serializeChannel1NudgeState(EMPTY_CHANNEL1_NUDGE_STATE), sessionId, Math.max(0, Math.round(measuredUndropped)));
     changed = (result.changes ?? 0) > 0;
   })();
   return changed;
@@ -15895,7 +15950,8 @@ var SESSION_SCOPED_TABLES = [
   { table: "pending_session_cleanup", harnessScoped: true },
   { table: "message_history_fts" },
   { table: "message_history_source", harnessScoped: true },
-  { table: "message_history_index", harnessScoped: true }
+  { table: "message_history_index", harnessScoped: true },
+  { table: "lkg_slots" }
 ];
 function deleteSessionScopedRows(db, sessionIds, harness) {
   if (sessionIds.length === 0)
@@ -19440,26 +19496,44 @@ function formatOldestReclaimableHint(hint) {
   return rendered.length > 0 ? `
 oldest reclaimable: ${rendered}.` : "";
 }
-function buildChannel2Reminder(undroppedTokens, hint) {
+function buildChannel2Reminder(undroppedTokens, usableWindowTokens, hint) {
   const amount = approxThousands(undroppedTokens);
+  const usableWindow = approxThousands(usableWindowTokens);
   const hintText = formatOldestReclaimableHint(hint);
   return `<system-reminder>
-` + `Routine context housekeeping is near: a large span of this session will be comparted soon, ` + `and ~${amount} tokens of tool output remain unreduced. Drop spent outputs with ctx_reduce ` + `first so the archived span is the part that matters.${hintText}
+` + `Routine housekeeping: an older span of this session folds into compact history automatically — nothing is lost and nothing pauses. ` + `Drop spent tool outputs with ctx_reduce first so the archive keeps only what matters (~${amount} of ~${usableWindow} reclaimable).${hintText}
 ` + `</system-reminder>`;
 }
-function buildChannel1Reminder(level, undroppedTokens, hint) {
-  const amount = approxThousands(undroppedTokens);
+var CHANNEL1_STICKY_REAL_USER_TURN_GAP = 3;
+function shouldUseStickyChannel1Reminder(input) {
+  if (input.lastLevel !== input.level)
+    return false;
+  if (input.lastOrdinal > input.currentRealUserTurnCount)
+    return false;
+  const gap = input.currentRealUserTurnCount - input.lastOrdinal;
+  return gap >= 0 && gap < CHANNEL1_STICKY_REAL_USER_TURN_GAP;
+}
+function buildChannel1Reminder(level, undroppedTokens, usableWindowTokens, hint, sticky = false) {
   const hintText = formatOldestReclaimableHint(hint);
+  if (sticky) {
+    return `
+
+<system-reminder>
+Reminder: ctx_reduce housekeeping still pending —${hintText}
+</system-reminder>`;
+  }
+  const amount = approxThousands(undroppedTokens);
+  const usableWindow = approxThousands(usableWindowTokens);
   let body;
   switch (level) {
     case "gentle":
-      body = `You have ~${amount} tokens of content you have not reduced. ` + `When you are done with earlier outputs, dropping them with ctx_reduce keeps context lean.`;
+      body = `Housekeeping: some earlier tool outputs are spent and can be dropped with ctx_reduce when you are done with them. ` + `Context is managed automatically — this is tidiness, never a reason to rush or narrow scope.`;
       break;
     case "firm":
-      body = `~${amount} tokens of unreduced content has built up. ` + `At your next natural stopping point, consider dropping what you have already processed with ctx_reduce.`;
+      body = `Housekeeping: ~${amount} of this session's ~${usableWindow} window is spent tool output. ` + `Drop what you have already processed with ctx_reduce at a natural stopping point. ` + `Not a limit — nothing is lost either way.`;
       break;
     case "urgent":
-      body = `~${amount} tokens of unreduced content remain across most of the live tail. ` + `Consider dropping spent outputs with ctx_reduce so the archived span is the part that matters.`;
+      body = `Housekeeping backlog: ~${amount} of this session's ~${usableWindow} window is spent tool output — worth a ctx_reduce pass now. ` + `This is routine and lossless; it is never a reason to change scope.`;
       break;
   }
   return `
@@ -19689,8 +19763,14 @@ function getOldestActiveUnprotectedToolTags(db, sessionId, protectedTags = 0, li
   const params = protectedTags > 0 ? [sessionId, AGE_RECLAIM_MIN_TOKENS, sessionId, protectedTags - 1] : [sessionId, AGE_RECLAIM_MIN_TOKENS];
   const rows = db.prepare(`SELECT tag_number, tool_name
              FROM tags
-             WHERE session_id = ? AND status = 'active' AND type = 'tool'
-             ${valueFloor}
+               WHERE session_id = ? AND status = 'active' AND type = 'tool'
+                    AND NOT EXISTS (
+                        SELECT 1 FROM pending_ops
+                        WHERE pending_ops.session_id = tags.session_id
+                          AND pending_ops.tag_id = tags.tag_number
+                          AND pending_ops.operation = 'drop'
+                    )
+                    ${valueFloor}
              ${whereProtected}
              ORDER BY tag_number ASC, id ASC`).all(...params);
   return rows.filter((row) => typeof row.tag_number === "number").map((row) => ({
@@ -20373,6 +20453,42 @@ function stripJsonComments(content) {
   }
   return result;
 }
+function stripTrailingCommas(content) {
+  let result = "";
+  let inString = false;
+  let escaped = false;
+  for (let index = 0;index < content.length; index += 1) {
+    const char = content[index];
+    if (inString) {
+      result += char;
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      result += char;
+      continue;
+    }
+    if (char === ",") {
+      let lookahead = index + 1;
+      while (lookahead < content.length && /\s/.test(content[lookahead] ?? "")) {
+        lookahead += 1;
+      }
+      const next = content[lookahead];
+      if (next === "}" || next === "]") {
+        continue;
+      }
+    }
+    result += char;
+  }
+  return result;
+}
 var PROTOTYPE_POLLUTION_KEYS = new Set(["__proto__", "constructor", "prototype"]);
 function isPrototypePollutionKey(key) {
   return PROTOTYPE_POLLUTION_KEYS.has(key);
@@ -20403,6 +20519,10 @@ function sanitizeParsedJson(value, options = {}, path3 = []) {
   }
   return sanitized;
 }
+function parseJsonc(content, options = {}) {
+  const normalized = stripTrailingCommas(stripJsonComments(content));
+  return sanitizeParsedJson(JSON.parse(normalized), options);
+}
 function detectConfigFile(basePath) {
   const jsoncPath = `${basePath}.jsonc`;
   const jsonPath = `${basePath}.json`;
@@ -20967,7 +21087,7 @@ function pruneNestedConfigLeaf(block, relativePath) {
 }
 
 // src/config/index.ts
-import { existsSync as existsSync10, readFileSync as readFileSync11 } from "node:fs";
+import { existsSync as existsSync11 } from "node:fs";
 
 // ../plugin/src/config/migrate-dreamer-v2.ts
 var OLD_VERIFY_TASK = "verify";
@@ -35841,16 +35961,103 @@ var PromptSurfaceConfigSchema = exports_external.object({
     message: "tool description values must not be empty or whitespace-only"
   })).optional().describe("USER-LEVEL ONLY top-level description overrides keyed by ctx_* tool ID; parameter schemas and descriptions are unchanged.")
 }).describe("Prompt-surface preset routing. Project config may select default/models, while guidance_override_path and tool_descriptions are user-level only.");
+var PER_HARNESS_MIGRATION_INVENTORY = {
+  historian: {
+    retained: [
+      "temperature",
+      "top_p",
+      "prompt",
+      "tools",
+      "disable",
+      "description",
+      "mode",
+      "color",
+      "maxSteps",
+      "permission",
+      "maxTokens",
+      "two_pass",
+      "disallowed_tools"
+    ],
+    migrated_execution: ["model", "fallback_models", "variant", "thinking_level"]
+  },
+  dreamer: {
+    retained: [
+      "temperature",
+      "top_p",
+      "prompt",
+      "tools",
+      "disable",
+      "description",
+      "mode",
+      "color",
+      "maxSteps",
+      "permission",
+      "maxTokens",
+      "inject_docs"
+    ],
+    migrated_execution: ["model", "fallback_models", "variant", "thinking_level"]
+  },
+  task: {
+    retained: ["schedule", "promotion_threshold"],
+    migrated_execution: [
+      "model",
+      "fallback_models",
+      "variant",
+      "thinking_level",
+      "timeout_minutes"
+    ]
+  }
+};
+var OcEntryObjectSchema = exports_external.object({
+  model: exports_external.string().describe("OpenCode model ID (for example, provider/model)."),
+  variant: exports_external.string().optional().describe("OpenCode reasoning variant for this entry.")
+}).strict();
+var OcEntrySchema = exports_external.union([exports_external.string(), OcEntryObjectSchema]);
+var PiEntryObjectSchema = exports_external.object({
+  model: exports_external.string().describe("Pi model ID (for example, provider/model)."),
+  thinking_level: PiThinkingLevelSchema.describe("Pi thinking level for this entry.")
+}).strict();
+var PiEntrySchema = exports_external.union([exports_external.string(), PiEntryObjectSchema]);
+var OpenCodeHarnessBlockSchema = exports_external.object({
+  model: OcEntrySchema.optional().describe("Primary OpenCode model entry."),
+  fallback_models: exports_external.array(OcEntrySchema).optional().describe("Ordered fallback OpenCode entries. New-shape configuration requires an array; legacy singleton values migrate to a one-element array."),
+  variant: exports_external.string().optional().describe("OpenCode reasoning variant for the primary entry when it declares none. Fallback entries declare variants per-entry.")
+}).strict().describe("Strict OpenCode model-resolution block. It accepts no Pi vocabulary.");
+var PiHarnessBlockSchema = exports_external.object({
+  model: PiEntrySchema.optional().describe("Primary Pi model entry."),
+  fallback_models: exports_external.array(PiEntrySchema).optional().describe("Ordered fallback Pi entries. New-shape configuration requires an array; legacy singleton values migrate to a one-element array."),
+  thinking_level: PiThinkingLevelSchema.describe("Pi thinking level for the primary entry when it declares none. Fallback entries declare thinking levels per-entry.")
+}).strict().describe("Strict Pi model-resolution block. It accepts no OpenCode vocabulary.");
+var OpenCodeTaskExecutionSchema = exports_external.object({
+  model: OcEntrySchema.optional().describe("OpenCode model entry for this task."),
+  fallback_models: exports_external.array(OcEntrySchema).optional().describe("Ordered OpenCode fallback entries for this task."),
+  variant: exports_external.string().optional().describe("OpenCode reasoning variant for this task's primary entry when it declares none. Fallback entries declare variants per-entry."),
+  timeout_minutes: exports_external.number().min(5).optional().describe("Minutes allowed for this task before it is aborted.")
+}).strict();
+var PiTaskExecutionSchema = exports_external.object({
+  model: PiEntrySchema.optional().describe("Pi model entry for this task."),
+  fallback_models: exports_external.array(PiEntrySchema).optional().describe("Ordered Pi fallback entries for this task."),
+  thinking_level: PiThinkingLevelSchema.describe("Pi thinking level for this task's primary entry when it declares none. Fallback entries declare thinking levels per-entry."),
+  timeout_minutes: exports_external.number().min(5).optional().describe("Minutes allowed for this task before it is aborted.")
+}).strict();
+var DreamerOpenCodeHarnessBlockSchema = exports_external.object({
+  model: OcEntrySchema.optional().describe("Primary OpenCode model entry."),
+  fallback_models: exports_external.array(OcEntrySchema).optional().describe("Ordered fallback OpenCode entries. New-shape configuration requires an array; legacy singleton values migrate to a one-element array."),
+  variant: exports_external.string().optional().describe("OpenCode reasoning variant for the primary entry when it declares none. Fallback entries declare variants per-entry."),
+  tasks: exports_external.record(exports_external.string(), OpenCodeTaskExecutionSchema).optional().describe("OpenCode task execution overrides. Each named task accepts only model, fallback_models, variant, and timeout_minutes.")
+}).strict().describe("Strict OpenCode dreamer model-resolution block. It accepts no Pi vocabulary.");
+var DreamerPiHarnessBlockSchema = exports_external.object({
+  model: PiEntrySchema.optional().describe("Primary Pi model entry."),
+  fallback_models: exports_external.array(PiEntrySchema).optional().describe("Ordered fallback Pi entries. New-shape configuration requires an array; legacy singleton values migrate to a one-element array."),
+  thinking_level: PiThinkingLevelSchema.describe("Pi thinking level for the primary entry when it declares none. Fallback entries declare thinking levels per-entry."),
+  tasks: exports_external.record(exports_external.string(), PiTaskExecutionSchema).optional().describe("Pi task execution overrides. Each named task accepts only model, fallback_models, thinking_level, and timeout_minutes.")
+}).strict().describe("Strict Pi dreamer model-resolution block. It accepts no OpenCode vocabulary.");
 var CronScheduleSchema = exports_external.string().refine((s) => s.trim() === "" || isValidCron(s), {
   message: 'Invalid schedule: use a 5-field cron expression (e.g. "0 3 * * *" for 3am daily, "0 3 * * 0" for Sunday 3am, "0 */6 * * *" every 6h) or "" to disable.'
 }).describe('5-field cron schedule (e.g. "0 3 * * *"), or "" to disable this task.');
 var DreamTaskBaseConfigSchema = exports_external.object({
-  schedule: CronScheduleSchema.default(""),
-  model: exports_external.string().optional().describe("Per-task model override (inherits dreamer.model)"),
-  fallback_models: exports_external.union([exports_external.string(), exports_external.array(exports_external.string())]).optional().describe("Per-task fallback chain (inherits dreamer.fallback_models)"),
-  thinking_level: PiThinkingLevelSchema.describe("Pi only: per-task thinking level"),
-  timeout_minutes: exports_external.number().min(5).default(20).describe("Minutes allowed for this task before it is aborted")
-});
+  schedule: CronScheduleSchema.default("")
+}).strict();
 var PromotionThresholdSchema = exports_external.number().min(2).max(20).optional().describe("review-user-memories: min candidate observations before promotion is considered (default: 3)");
 var PrimerPromotionThresholdSchema = exports_external.number().min(2).max(20).optional().describe("promote-primers: min recurring source days before promotion is considered (default: 2)");
 var DreamTaskConfigSchema = DreamTaskBaseConfigSchema.extend({
@@ -35897,20 +36104,35 @@ var DreamTasksSchema = exports_external.object({
   "review-user-memories": ReviewUserMemoriesTaskConfigSchema.default(() => ReviewUserMemoriesTaskConfigSchema.parse(defaultTaskConfig("review-user-memories"))),
   "promote-primers": PromotePrimersTaskConfigSchema.default(() => PromotePrimersTaskConfigSchema.parse(defaultTaskConfig("promote-primers"))),
   "refresh-primers": DreamTaskBaseConfigSchema.default(() => DreamTaskBaseConfigSchema.parse(defaultTaskConfig("refresh-primers")))
-}).describe("Per-task scheduling + model config. Each task has its own cron schedule and may override the dreamer-level model.");
-var DreamerConfigSchema = AgentOverrideConfigSchema.merge(exports_external.object({
+}).describe("Harness-independent task metadata. schedule, promotion_threshold, and other task metadata remain here; execution settings live under dreamer.opencode.tasks or dreamer.pi.tasks.");
+var AgentMetadataSchema = AgentOverrideConfigSchema.pick({
+  temperature: true,
+  top_p: true,
+  prompt: true,
+  tools: true,
+  disable: true,
+  description: true,
+  mode: true,
+  color: true,
+  maxSteps: true,
+  permission: true,
+  maxTokens: true
+});
+var DreamerConfigSchema = AgentMetadataSchema.extend({
+  opencode: DreamerOpenCodeHarnessBlockSchema.optional(),
+  pi: DreamerPiHarnessBlockSchema.optional(),
   tasks: DreamTasksSchema.default(() => DreamTasksSchema.parse({})),
-  inject_docs: exports_external.boolean().default(true).describe("Inject ARCHITECTURE.md and STRUCTURE.md into the m[0] `<project-docs>` block (default true)"),
-  thinking_level: PiThinkingLevelSchema.describe("Pi only: default thinking level for dreamer subagent invocations. See historian.thinking_level.")
-}));
+  inject_docs: exports_external.boolean().default(true).describe("Inject ARCHITECTURE.md and STRUCTURE.md into the m[0] `<project-docs>` block (default true)")
+});
 var SidekickConfigSchema = AgentOverrideConfigSchema.extend({
   timeout_ms: exports_external.number().default(30000).describe("Timeout for sidekick calls in milliseconds"),
   system_prompt: exports_external.string().optional().describe("Custom system prompt for sidekick"),
-  thinking_level: PiThinkingLevelSchema.describe("Pi only: explicit thinking level for sidekick subagent invocations. See historian.thinking_level.")
+  thinking_level: PiThinkingLevelSchema.describe("Pi only: explicit thinking level for sidekick subagent invocations. See historian.pi.thinking_level.")
 }).optional();
-var HistorianConfigSchema = AgentOverrideConfigSchema.extend({
+var HistorianConfigSchema = AgentMetadataSchema.extend({
+  opencode: OpenCodeHarnessBlockSchema.optional(),
+  pi: PiHarnessBlockSchema.optional(),
   two_pass: exports_external.boolean().default(false).describe("Run a second editor pass over historian output to clean low-signal U: lines and cross-compartment duplicates. Adds ~1 extra API call and ~1.3x cost per historian run. Useful for models without extended thinking support. (default: false)"),
-  thinking_level: PiThinkingLevelSchema.describe("Pi only: explicit thinking level passed as --thinking <level> to Pi historian subagent invocations. Required when using reasoning models (e.g. github-copilot/gpt-5.4) because Pi's default thinking-level resolution can pick a value the provider rejects. OpenCode users set variant instead. Valid: off | minimal | low | medium | high | xhigh | max"),
   disallowed_tools: exports_external.array(exports_external.enum(["*", "read", "aft_outline", "aft_zoom", "aft_search"])).default([]).describe(`OpenCode only. Tools to REMOVE from the historian's default allow-list [read, aft_outline, aft_zoom, aft_search]. Applies to both historian and historian-editor agents. Use ["*"] to strip all tool definitions from the model request — this prevents weak instruction-following models (e.g. mistral-small-latest) from entering tool-calling loops. Individual tool names remove just that tool. Note: a user-supplied historian.permission override can re-allow a tool that disallowed_tools removed — disallowed_tools sets the baseline, permission overrides take precedence. (default: [])`)
 }).optional();
 var EmbeddingFallbackProviderSchema = exports_external.enum(["local", "openai-compatible", "off"]);
@@ -36020,8 +36242,8 @@ var MagicContextConfigSchema = exports_external.object({
   transform_mode: exports_external.enum(["ts", "rust"]).default("ts").describe('Experimental: routes the entire Magic Context runtime for the project through the ck-mc Rust module over subc (requires user-level `subc` config); "ts" is the current TypeScript pipeline.'),
   auto_update: exports_external.boolean().optional().describe("Enable automatic npm self-update checks for the OpenCode plugin. Security: USER-only in config loader, so hostile project configs cannot suppress updates."),
   language: exports_external.string().trim().toLowerCase().refine((s) => isValidLanguageCode(s), 'language must be a 2-letter ISO 639-1 code (e.g. "tr", "es", "de")').optional().describe("Output language for Magic Context's generated content and guidance, as a " + '2-letter ISO 639-1 code (e.g. "tr", "es", "de", "ja", "pt"). When set, the ' + "historian, dreamer, sidekick, and the agent-guidance block instruct the model to " + "write its PROSE in this language while keeping all structural tokens (XML tags, " + "the five memory category names, code identifiers, file paths) in English. " + "USER-LEVEL ONLY (ignored in project config for security). Unset = today's " + "behavior (model mirrors the conversation; English scaffolding). Changing it " + "triggers one cache re-materialization; existing compartments/memories keep their " + "original language until naturally rewritten."),
-  historian: HistorianConfigSchema.describe("Historian agent configuration (model, fallback_models, variant, temperature, maxTokens, permission, two_pass, etc.)"),
-  dreamer: DreamerConfigSchema.optional().describe("Dreamer agent + scheduling configuration (model, fallback_models, disable, schedule, tasks, etc.)"),
+  historian: HistorianConfigSchema.describe("Historian metadata plus independent strict OpenCode and Pi execution blocks. Retained metadata stays at historian; model, fallback_models, variant, and thinking_level belong only in historian.opencode or historian.pi."),
+  dreamer: DreamerConfigSchema.optional().describe("Dreamer metadata and scheduling plus independent strict OpenCode and Pi execution blocks. schedule and promotion_threshold stay at dreamer.tasks; model, fallback_models, variant, thinking_level, and timeout_minutes belong only in the matching harness block."),
   smart_notes: exports_external.object({
     retina_handoff: exports_external.boolean().default(false).describe("When true, dreamer skips smart notes whose surface conditions compiled to retina provider configs at authoring time. Default false keeps both paths active until the retina consumer is deployed.")
   }).default({ retina_handoff: false }).describe("Smart-note ownership transition controls."),
@@ -36123,7 +36345,8 @@ var MagicContextConfigSchema = exports_external.object({
 
 // ../plugin/src/config/project-security.ts
 var HIDDEN_AGENT_KEYS = ["historian", "dreamer", "sidekick"];
-var HISTORIAN_USER_ONLY_FIELDS = ["model", "fallback_models"];
+var HARNESS_KEYS = ["opencode", "pi"];
+var HISTORIAN_USER_ONLY_FIELDS = PER_HARNESS_MIGRATION_INVENTORY.historian.migrated_execution;
 var PROMPT_SURFACE_USER_ONLY_FIELDS = ["guidance_override_path", "tool_descriptions"];
 var AGENT_ESCALATION_FIELDS = ["prompt", "permission", "tools", "system_prompt"];
 var EMBEDDING_DESTINATION_FIELDS = ["endpoint", "provider", "fallback_provider"];
@@ -36133,6 +36356,38 @@ var TOKEN_THRESHOLD_INTRODUCTION_REASON = "security: a repository cannot introdu
 function isPlainObject3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function stripListedFields(target, fields, path3, removed) {
+  for (const field of fields) {
+    if (field in target) {
+      delete target[field];
+      removed.push(path3.length > 0 ? `${path3}.${field}` : field);
+    }
+  }
+}
+function stripEscalationAtExecutableSite(block, path3, removed) {
+  stripListedFields(block, AGENT_ESCALATION_FIELDS, path3, removed);
+  if (isPlainObject3(block.model)) {
+    stripListedFields(block.model, AGENT_ESCALATION_FIELDS, `${path3}.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 (isPlainObject3(entry)) {
+        stripListedFields(entry, AGENT_ESCALATION_FIELDS, `${path3}.fallback_models.${index}`, removed);
+      }
+    }
+  }
+}
+function stripNestedMuralModels(node, path3, removed) {
+  for (const [key, value] of Object.entries(node)) {
+    if (key === "mural" && isPlainObject3(value) && "model" in value) {
+      delete value.model;
+      removed.push(`${path3}.${key}.model`);
+    } else if (isPlainObject3(value)) {
+      stripNestedMuralModels(value, `${path3}.${key}`, removed);
+    }
+  }
+}
 function isValidPercentageThreshold(value) {
   return typeof value === "number" && Number.isFinite(value) && value >= 20 && value <= 80;
 }
@@ -36302,6 +36557,38 @@ function stripUnsafeProjectConfigFields(projectRaw) {
       warnings.push(`Ignoring embedding.${removed.join("/")} from project config ` + "(security: a repository cannot choose where private text is embedded).");
     }
   }
+  for (const agentKey of HIDDEN_AGENT_KEYS) {
+    const block = projectRaw[agentKey];
+    if (!isPlainObject3(block))
+      continue;
+    const removed = [];
+    stripEscalationAtExecutableSite(block, agentKey, removed);
+    for (const harness of HARNESS_KEYS) {
+      const harnessBlock = block[harness];
+      if (!isPlainObject3(harnessBlock))
+        continue;
+      stripEscalationAtExecutableSite(harnessBlock, `${agentKey}.${harness}`, removed);
+      const tasks = harnessBlock.tasks;
+      if (isPlainObject3(tasks)) {
+        for (const [taskName, taskBlock] of Object.entries(tasks)) {
+          if (isPlainObject3(taskBlock)) {
+            stripEscalationAtExecutableSite(taskBlock, `${agentKey}.${harness}.tasks.${taskName}`, removed);
+          }
+        }
+      }
+    }
+    const schedulingTasks = block.tasks;
+    if (isPlainObject3(schedulingTasks)) {
+      for (const [taskName, taskBlock] of Object.entries(schedulingTasks)) {
+        if (isPlainObject3(taskBlock)) {
+          stripListedFields(taskBlock, AGENT_ESCALATION_FIELDS, `${agentKey}.tasks.${taskName}`, removed);
+        }
+      }
+    }
+    if (removed.length > 0) {
+      warnings.push(`Ignoring ${removed.join(", ")} from project config ` + "(security: a repository cannot reprogram or re-permission hidden agents).");
+    }
+  }
   const historian = projectRaw.historian;
   if (isPlainObject3(historian)) {
     const removed = [];
@@ -36311,8 +36598,19 @@ function stripUnsafeProjectConfigFields(projectRaw) {
         removed.push(field);
       }
     }
+    for (const harness of HARNESS_KEYS) {
+      const harnessBlock = historian[harness];
+      if (!isPlainObject3(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 historian.${removed.join("/")} from project config ` + "(security: historian model selection is user-level only; a repository cannot force extra compaction cost).");
+      warnings.push(`Ignoring ${removed.map((path3) => `historian.${path3}`).join(", ")} from project config ` + "(security: historian model selection is user-level only; a repository cannot force extra compaction cost).");
     }
   }
   const mural = projectRaw.mural;
@@ -36326,20 +36624,15 @@ function stripUnsafeProjectConfigFields(projectRaw) {
     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 (!isPlainObject3(block))
       continue;
-    const removed = [];
-    for (const field of AGENT_ESCALATION_FIELDS) {
-      if (field in block) {
-        delete block[field];
-        removed.push(field);
-      }
-    }
-    if (removed.length > 0) {
-      warnings.push(`Ignoring ${agentKey}.${removed.join("/")} from project config ` + "(security: a repository cannot reprogram or re-permission hidden agents).");
-    }
+    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;
 }
@@ -36473,10 +36766,1755 @@ function dropInheritedEmbeddingKeyOnRedirect(projectRaw, mergedRaw, userRaw) {
   ];
 }
 
+// ../plugin/src/config/raw-loader.ts
+import {
+  closeSync as closeSync2,
+  existsSync as existsSync9,
+  linkSync,
+  openSync as openSync2,
+  readFileSync as readFileSync8,
+  renameSync as renameSync2,
+  statSync as statSync6,
+  unlinkSync as unlinkSync3,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import { basename as basename3, dirname as dirname5, join as join6 } from "node:path";
+
+// ../../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 value2 = 0;
+    while (digits < count || !exact) {
+      let ch = text.charCodeAt(pos);
+      if (ch >= 48 && ch <= 57) {
+        value2 = value2 * 16 + ch - 48;
+      } else if (ch >= 65 && ch <= 70) {
+        value2 = value2 * 16 + ch - 65 + 10;
+      } else if (ch >= 97 && ch <= 102) {
+        value2 = value2 * 16 + ch - 97 + 10;
+      } else {
+        break;
+      }
+      pos++;
+      digits++;
+    }
+    if (digits < count) {
+      value2 = -1;
+    }
+    return value2;
+  }
+  function setPosition(newPosition) {
+    pos = newPosition;
+    value = "";
+    tokenOffset = 0;
+    token = 16;
+    scanError = 0;
+  }
+  function scanNumber() {
+    let start = pos;
+    if (text.charCodeAt(pos) === 48) {
+      pos++;
+    } else {
+      pos++;
+      while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+      }
+    }
+    if (pos < text.length && text.charCodeAt(pos) === 46) {
+      pos++;
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+      } else {
+        scanError = 3;
+        return text.substring(start, pos);
+      }
+    }
+    let end = pos;
+    if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
+      pos++;
+      if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) {
+        pos++;
+      }
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+        end = pos;
+      } else {
+        scanError = 3;
+      }
+    }
+    return text.substring(start, end);
+  }
+  function scanString() {
+    let result = "", start = pos;
+    while (true) {
+      if (pos >= len) {
+        result += text.substring(start, pos);
+        scanError = 2;
+        break;
+      }
+      const ch = text.charCodeAt(pos);
+      if (ch === 34) {
+        result += text.substring(start, pos);
+        pos++;
+        break;
+      }
+      if (ch === 92) {
+        result += text.substring(start, pos);
+        pos++;
+        if (pos >= len) {
+          scanError = 2;
+          break;
+        }
+        const ch2 = text.charCodeAt(pos++);
+        switch (ch2) {
+          case 34:
+            result += '"';
+            break;
+          case 92:
+            result += "\\";
+            break;
+          case 47:
+            result += "/";
+            break;
+          case 98:
+            result += "\b";
+            break;
+          case 102:
+            result += "\f";
+            break;
+          case 110:
+            result += `
+`;
+            break;
+          case 114:
+            result += "\r";
+            break;
+          case 116:
+            result += "\t";
+            break;
+          case 117:
+            const ch3 = scanHexDigits(4, true);
+            if (ch3 >= 0) {
+              result += String.fromCharCode(ch3);
+            } else {
+              scanError = 4;
+            }
+            break;
+          default:
+            scanError = 5;
+        }
+        start = pos;
+        continue;
+      }
+      if (ch >= 0 && ch <= 31) {
+        if (isLineBreak(ch)) {
+          result += text.substring(start, pos);
+          scanError = 2;
+          break;
+        } else {
+          scanError = 6;
+        }
+      }
+      pos++;
+    }
+    return result;
+  }
+  function scanNext() {
+    value = "";
+    scanError = 0;
+    tokenOffset = pos;
+    lineStartOffset = lineNumber;
+    prevTokenLineStartOffset = tokenLineStartOffset;
+    if (pos >= len) {
+      tokenOffset = len;
+      return token = 17;
+    }
+    let code = text.charCodeAt(pos);
+    if (isWhiteSpace(code)) {
+      do {
+        pos++;
+        value += String.fromCharCode(code);
+        code = text.charCodeAt(pos);
+      } while (isWhiteSpace(code));
+      return token = 15;
+    }
+    if (isLineBreak(code)) {
+      pos++;
+      value += String.fromCharCode(code);
+      if (code === 13 && text.charCodeAt(pos) === 10) {
+        pos++;
+        value += `
+`;
+      }
+      lineNumber++;
+      tokenLineStartOffset = pos;
+      return token = 14;
+    }
+    switch (code) {
+      case 123:
+        pos++;
+        return token = 1;
+      case 125:
+        pos++;
+        return token = 2;
+      case 91:
+        pos++;
+        return token = 3;
+      case 93:
+        pos++;
+        return token = 4;
+      case 58:
+        pos++;
+        return token = 6;
+      case 44:
+        pos++;
+        return token = 5;
+      case 34:
+        pos++;
+        value = scanString();
+        return token = 10;
+      case 47:
+        const start = pos - 1;
+        if (text.charCodeAt(pos + 1) === 47) {
+          pos += 2;
+          while (pos < len) {
+            if (isLineBreak(text.charCodeAt(pos))) {
+              break;
+            }
+            pos++;
+          }
+          value = text.substring(start, pos);
+          return token = 12;
+        }
+        if (text.charCodeAt(pos + 1) === 42) {
+          pos += 2;
+          const safeLength = len - 1;
+          let commentClosed = false;
+          while (pos < safeLength) {
+            const ch = text.charCodeAt(pos);
+            if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
+              pos += 2;
+              commentClosed = true;
+              break;
+            }
+            pos++;
+            if (isLineBreak(ch)) {
+              if (ch === 13 && text.charCodeAt(pos) === 10) {
+                pos++;
+              }
+              lineNumber++;
+              tokenLineStartOffset = pos;
+            }
+          }
+          if (!commentClosed) {
+            pos++;
+            scanError = 1;
+          }
+          value = text.substring(start, pos);
+          return token = 13;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+      case 45:
+        value += String.fromCharCode(code);
+        pos++;
+        if (pos === len || !isDigit(text.charCodeAt(pos))) {
+          return token = 16;
+        }
+      case 48:
+      case 49:
+      case 50:
+      case 51:
+      case 52:
+      case 53:
+      case 54:
+      case 55:
+      case 56:
+      case 57:
+        value += scanNumber();
+        return token = 11;
+      default:
+        while (pos < len && isUnknownContentCharacter(code)) {
+          pos++;
+          code = text.charCodeAt(pos);
+        }
+        if (tokenOffset !== pos) {
+          value = text.substring(tokenOffset, pos);
+          switch (value) {
+            case "true":
+              return token = 8;
+            case "false":
+              return token = 9;
+            case "null":
+              return token = 7;
+          }
+          return token = 16;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+    }
+  }
+  function isUnknownContentCharacter(code) {
+    if (isWhiteSpace(code) || isLineBreak(code)) {
+      return false;
+    }
+    switch (code) {
+      case 125:
+      case 93:
+      case 123:
+      case 91:
+      case 34:
+      case 58:
+      case 44:
+      case 47:
+        return false;
+    }
+    return true;
+  }
+  function scanNextNonTrivia() {
+    let result;
+    do {
+      result = scanNext();
+    } while (result >= 12 && result <= 15);
+    return result;
+  }
+  return {
+    setPosition,
+    getPosition: () => pos,
+    scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+    getToken: () => token,
+    getTokenValue: () => value,
+    getTokenOffset: () => tokenOffset,
+    getTokenLength: () => pos - tokenOffset,
+    getTokenStartLine: () => lineStartOffset,
+    getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
+    getTokenError: () => scanError
+  };
+}
+function isWhiteSpace(ch) {
+  return ch === 32 || ch === 9;
+}
+function isLineBreak(ch) {
+  return ch === 10 || ch === 13;
+}
+function isDigit(ch) {
+  return ch >= 48 && ch <= 57;
+}
+var CharacterCodes;
+(function(CharacterCodes2) {
+  CharacterCodes2[CharacterCodes2["lineFeed"] = 10] = "lineFeed";
+  CharacterCodes2[CharacterCodes2["carriageReturn"] = 13] = "carriageReturn";
+  CharacterCodes2[CharacterCodes2["space"] = 32] = "space";
+  CharacterCodes2[CharacterCodes2["_0"] = 48] = "_0";
+  CharacterCodes2[CharacterCodes2["_1"] = 49] = "_1";
+  CharacterCodes2[CharacterCodes2["_2"] = 50] = "_2";
+  CharacterCodes2[CharacterCodes2["_3"] = 51] = "_3";
+  CharacterCodes2[CharacterCodes2["_4"] = 52] = "_4";
+  CharacterCodes2[CharacterCodes2["_5"] = 53] = "_5";
+  CharacterCodes2[CharacterCodes2["_6"] = 54] = "_6";
+  CharacterCodes2[CharacterCodes2["_7"] = 55] = "_7";
+  CharacterCodes2[CharacterCodes2["_8"] = 56] = "_8";
+  CharacterCodes2[CharacterCodes2["_9"] = 57] = "_9";
+  CharacterCodes2[CharacterCodes2["a"] = 97] = "a";
+  CharacterCodes2[CharacterCodes2["b"] = 98] = "b";
+  CharacterCodes2[CharacterCodes2["c"] = 99] = "c";
+  CharacterCodes2[CharacterCodes2["d"] = 100] = "d";
+  CharacterCodes2[CharacterCodes2["e"] = 101] = "e";
+  CharacterCodes2[CharacterCodes2["f"] = 102] = "f";
+  CharacterCodes2[CharacterCodes2["g"] = 103] = "g";
+  CharacterCodes2[CharacterCodes2["h"] = 104] = "h";
+  CharacterCodes2[CharacterCodes2["i"] = 105] = "i";
+  CharacterCodes2[CharacterCodes2["j"] = 106] = "j";
+  CharacterCodes2[CharacterCodes2["k"] = 107] = "k";
+  CharacterCodes2[CharacterCodes2["l"] = 108] = "l";
+  CharacterCodes2[CharacterCodes2["m"] = 109] = "m";
+  CharacterCodes2[CharacterCodes2["n"] = 110] = "n";
+  CharacterCodes2[CharacterCodes2["o"] = 111] = "o";
+  CharacterCodes2[CharacterCodes2["p"] = 112] = "p";
+  CharacterCodes2[CharacterCodes2["q"] = 113] = "q";
+  CharacterCodes2[CharacterCodes2["r"] = 114] = "r";
+  CharacterCodes2[CharacterCodes2["s"] = 115] = "s";
+  CharacterCodes2[CharacterCodes2["t"] = 116] = "t";
+  CharacterCodes2[CharacterCodes2["u"] = 117] = "u";
+  CharacterCodes2[CharacterCodes2["v"] = 118] = "v";
+  CharacterCodes2[CharacterCodes2["w"] = 119] = "w";
+  CharacterCodes2[CharacterCodes2["x"] = 120] = "x";
+  CharacterCodes2[CharacterCodes2["y"] = 121] = "y";
+  CharacterCodes2[CharacterCodes2["z"] = 122] = "z";
+  CharacterCodes2[CharacterCodes2["A"] = 65] = "A";
+  CharacterCodes2[CharacterCodes2["B"] = 66] = "B";
+  CharacterCodes2[CharacterCodes2["C"] = 67] = "C";
+  CharacterCodes2[CharacterCodes2["D"] = 68] = "D";
+  CharacterCodes2[CharacterCodes2["E"] = 69] = "E";
+  CharacterCodes2[CharacterCodes2["F"] = 70] = "F";
+  CharacterCodes2[CharacterCodes2["G"] = 71] = "G";
+  CharacterCodes2[CharacterCodes2["H"] = 72] = "H";
+  CharacterCodes2[CharacterCodes2["I"] = 73] = "I";
+  CharacterCodes2[CharacterCodes2["J"] = 74] = "J";
+  CharacterCodes2[CharacterCodes2["K"] = 75] = "K";
+  CharacterCodes2[CharacterCodes2["L"] = 76] = "L";
+  CharacterCodes2[CharacterCodes2["M"] = 77] = "M";
+  CharacterCodes2[CharacterCodes2["N"] = 78] = "N";
+  CharacterCodes2[CharacterCodes2["O"] = 79] = "O";
+  CharacterCodes2[CharacterCodes2["P"] = 80] = "P";
+  CharacterCodes2[CharacterCodes2["Q"] = 81] = "Q";
+  CharacterCodes2[CharacterCodes2["R"] = 82] = "R";
+  CharacterCodes2[CharacterCodes2["S"] = 83] = "S";
+  CharacterCodes2[CharacterCodes2["T"] = 84] = "T";
+  CharacterCodes2[CharacterCodes2["U"] = 85] = "U";
+  CharacterCodes2[CharacterCodes2["V"] = 86] = "V";
+  CharacterCodes2[CharacterCodes2["W"] = 87] = "W";
+  CharacterCodes2[CharacterCodes2["X"] = 88] = "X";
+  CharacterCodes2[CharacterCodes2["Y"] = 89] = "Y";
+  CharacterCodes2[CharacterCodes2["Z"] = 90] = "Z";
+  CharacterCodes2[CharacterCodes2["asterisk"] = 42] = "asterisk";
+  CharacterCodes2[CharacterCodes2["backslash"] = 92] = "backslash";
+  CharacterCodes2[CharacterCodes2["closeBrace"] = 125] = "closeBrace";
+  CharacterCodes2[CharacterCodes2["closeBracket"] = 93] = "closeBracket";
+  CharacterCodes2[CharacterCodes2["colon"] = 58] = "colon";
+  CharacterCodes2[CharacterCodes2["comma"] = 44] = "comma";
+  CharacterCodes2[CharacterCodes2["dot"] = 46] = "dot";
+  CharacterCodes2[CharacterCodes2["doubleQuote"] = 34] = "doubleQuote";
+  CharacterCodes2[CharacterCodes2["minus"] = 45] = "minus";
+  CharacterCodes2[CharacterCodes2["openBrace"] = 123] = "openBrace";
+  CharacterCodes2[CharacterCodes2["openBracket"] = 91] = "openBracket";
+  CharacterCodes2[CharacterCodes2["plus"] = 43] = "plus";
+  CharacterCodes2[CharacterCodes2["slash"] = 47] = "slash";
+  CharacterCodes2[CharacterCodes2["formFeed"] = 12] = "formFeed";
+  CharacterCodes2[CharacterCodes2["tab"] = 9] = "tab";
+})(CharacterCodes || (CharacterCodes = {}));
+
+// ../../node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/string-intern.js
+var cachedSpaces = new Array(20).fill(0).map((_, index) => {
+  return " ".repeat(index);
+});
+var maxCachedValues = 200;
+var cachedBreakLinesWithSpaces = {
+  " ": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `
+` + " ".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + " ".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `\r
+` + " ".repeat(index);
+    })
+  },
+  "\t": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `
+` + "\t".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + "\t".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `\r
+` + "\t".repeat(index);
+    })
+  }
+};
+var supportedEols = [`
+`, "\r", `\r
+`];
+
+// ../../node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/format.js
+function format(documentText, range, options) {
+  let initialIndentLevel;
+  let formatText;
+  let formatTextStart;
+  let rangeStart;
+  let rangeEnd;
+  if (range) {
+    rangeStart = range.offset;
+    rangeEnd = rangeStart + range.length;
+    formatTextStart = rangeStart;
+    while (formatTextStart > 0 && !isEOL(documentText, formatTextStart - 1)) {
+      formatTextStart--;
+    }
+    let endOffset = rangeEnd;
+    while (endOffset < documentText.length && !isEOL(documentText, endOffset)) {
+      endOffset++;
+    }
+    formatText = documentText.substring(formatTextStart, endOffset);
+    initialIndentLevel = computeIndentLevel(formatText, options);
+  } else {
+    formatText = documentText;
+    initialIndentLevel = 0;
+    formatTextStart = 0;
+    rangeStart = 0;
+    rangeEnd = documentText.length;
+  }
+  const eol = getEOL(options, documentText);
+  const eolFastPathSupported = supportedEols.includes(eol);
+  let numberLineBreaks = 0;
+  let indentLevel = 0;
+  let indentValue;
+  if (options.insertSpaces) {
+    indentValue = cachedSpaces[options.tabSize || 4] ?? repeat(cachedSpaces[1], options.tabSize || 4);
+  } else {
+    indentValue = "\t";
+  }
+  const indentType = indentValue === "\t" ? "\t" : " ";
+  let scanner = createScanner(formatText, false);
+  let hasError = false;
+  function newLinesAndIndent() {
+    if (numberLineBreaks > 1) {
+      return repeat(eol, numberLineBreaks) + repeat(indentValue, initialIndentLevel + indentLevel);
+    }
+    const amountOfSpaces = indentValue.length * (initialIndentLevel + indentLevel);
+    if (!eolFastPathSupported || amountOfSpaces > cachedBreakLinesWithSpaces[indentType][eol].length) {
+      return eol + repeat(indentValue, initialIndentLevel + indentLevel);
+    }
+    if (amountOfSpaces <= 0) {
+      return eol;
+    }
+    return cachedBreakLinesWithSpaces[indentType][eol][amountOfSpaces];
+  }
+  function scanNext() {
+    let token = scanner.scan();
+    numberLineBreaks = 0;
+    while (token === 15 || token === 14) {
+      if (token === 14 && options.keepLines) {
+        numberLineBreaks += 1;
+      } else if (token === 14) {
+        numberLineBreaks = 1;
+      }
+      token = scanner.scan();
+    }
+    hasError = token === 16 || scanner.getTokenError() !== 0;
+    return token;
+  }
+  const editOperations = [];
+  function addEdit(text, startOffset, endOffset) {
+    if (!hasError && (!range || startOffset < rangeEnd && endOffset > rangeStart) && documentText.substring(startOffset, endOffset) !== text) {
+      editOperations.push({ offset: startOffset, length: endOffset - startOffset, content: text });
+    }
+  }
+  let firstToken = scanNext();
+  if (options.keepLines && numberLineBreaks > 0) {
+    addEdit(repeat(eol, numberLineBreaks), 0, 0);
+  }
+  if (firstToken !== 17) {
+    let firstTokenStart = scanner.getTokenOffset() + formatTextStart;
+    let initialIndent = indentValue.length * initialIndentLevel < 20 && options.insertSpaces ? cachedSpaces[indentValue.length * initialIndentLevel] : repeat(indentValue, initialIndentLevel);
+    addEdit(initialIndent, formatTextStart, firstTokenStart);
+  }
+  while (firstToken !== 17) {
+    let firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+    let secondToken = scanNext();
+    let replaceContent = "";
+    let needsLineBreak = false;
+    while (numberLineBreaks === 0 && (secondToken === 12 || secondToken === 13)) {
+      let commentTokenStart = scanner.getTokenOffset() + formatTextStart;
+      addEdit(cachedSpaces[1], firstTokenEnd, commentTokenStart);
+      firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+      needsLineBreak = secondToken === 12;
+      replaceContent = needsLineBreak ? newLinesAndIndent() : "";
+      secondToken = scanNext();
+    }
+    if (secondToken === 2) {
+      if (firstToken !== 1) {
+        indentLevel--;
+      }
+      if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && firstToken !== 1) {
+        replaceContent = newLinesAndIndent();
+      } else if (options.keepLines) {
+        replaceContent = cachedSpaces[1];
+      }
+    } else if (secondToken === 4) {
+      if (firstToken !== 3) {
+        indentLevel--;
+      }
+      if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && firstToken !== 3) {
+        replaceContent = newLinesAndIndent();
+      } else if (options.keepLines) {
+        replaceContent = cachedSpaces[1];
+      }
+    } else {
+      switch (firstToken) {
+        case 3:
+        case 1:
+          indentLevel++;
+          if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) {
+            replaceContent = newLinesAndIndent();
+          } else {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 5:
+          if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) {
+            replaceContent = newLinesAndIndent();
+          } else {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 12:
+          replaceContent = newLinesAndIndent();
+          break;
+        case 13:
+          if (numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else if (!needsLineBreak) {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 6:
+          if (options.keepLines && numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else if (!needsLineBreak) {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 10:
+          if (options.keepLines && numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else if (secondToken === 6 && !needsLineBreak) {
+            replaceContent = "";
+          }
+          break;
+        case 7:
+        case 8:
+        case 9:
+        case 11:
+        case 2:
+        case 4:
+          if (options.keepLines && numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else {
+            if ((secondToken === 12 || secondToken === 13) && !needsLineBreak) {
+              replaceContent = cachedSpaces[1];
+            } else if (secondToken !== 5 && secondToken !== 17) {
+              hasError = true;
+            }
+          }
+          break;
+        case 16:
+          hasError = true;
+          break;
+      }
+      if (numberLineBreaks > 0 && (secondToken === 12 || secondToken === 13)) {
+        replaceContent = newLinesAndIndent();
+      }
+    }
+    if (secondToken === 17) {
+      if (options.keepLines && numberLineBreaks > 0) {
+        replaceContent = newLinesAndIndent();
+      } else {
+        replaceContent = options.insertFinalNewline ? eol : "";
+      }
+    }
+    const secondTokenStart = scanner.getTokenOffset() + formatTextStart;
+    addEdit(replaceContent, firstTokenEnd, secondTokenStart);
+    firstToken = secondToken;
+  }
+  return editOperations;
+}
+function repeat(s, count) {
+  let result = "";
+  for (let i = 0;i < count; i++) {
+    result += s;
+  }
+  return result;
+}
+function computeIndentLevel(content, options) {
+  let i = 0;
+  let nChars = 0;
+  const tabSize = options.tabSize || 4;
+  while (i < content.length) {
+    let ch = content.charAt(i);
+    if (ch === cachedSpaces[1]) {
+      nChars++;
+    } else if (ch === "\t") {
+      nChars += tabSize;
+    } else {
+      break;
+    }
+    i++;
+  }
+  return Math.floor(nChars / tabSize);
+}
+function getEOL(options, text) {
+  for (let i = 0;i < text.length; i++) {
+    const ch = text.charAt(i);
+    if (ch === "\r") {
+      if (i + 1 < text.length && text.charAt(i + 1) === `
+`) {
+        return `\r
+`;
+      }
+      return "\r";
+    } else if (ch === `
+`) {
+      return `
+`;
+    }
+  }
+  return options && options.eol || `
+`;
+}
+function isEOL(text, offset) {
+  return `\r
+`.indexOf(text.charAt(offset)) !== -1;
+}
+
+// ../../node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/parser.js
+var ParseOptions;
+(function(ParseOptions2) {
+  ParseOptions2.DEFAULT = {
+    allowTrailingComma: false
+  };
+})(ParseOptions || (ParseOptions = {}));
+function parseTree(text, errors3 = [], options = ParseOptions.DEFAULT) {
+  let currentParent = { type: "array", offset: -1, length: -1, children: [], parent: undefined };
+  function ensurePropertyComplete(endOffset) {
+    if (currentParent.type === "property") {
+      currentParent.length = endOffset - currentParent.offset;
+      currentParent = currentParent.parent;
+    }
+  }
+  function onValue(valueNode) {
+    currentParent.children.push(valueNode);
+    return valueNode;
+  }
+  const visitor = {
+    onObjectBegin: (offset) => {
+      currentParent = onValue({ type: "object", offset, length: -1, parent: currentParent, children: [] });
+    },
+    onObjectProperty: (name, offset, length) => {
+      currentParent = onValue({ type: "property", offset, length: -1, parent: currentParent, children: [] });
+      currentParent.children.push({ type: "string", value: name, offset, length, parent: currentParent });
+    },
+    onObjectEnd: (offset, length) => {
+      ensurePropertyComplete(offset + length);
+      currentParent.length = offset + length - currentParent.offset;
+      currentParent = currentParent.parent;
+      ensurePropertyComplete(offset + length);
+    },
+    onArrayBegin: (offset, length) => {
+      currentParent = onValue({ type: "array", offset, length: -1, parent: currentParent, children: [] });
+    },
+    onArrayEnd: (offset, length) => {
+      currentParent.length = offset + length - currentParent.offset;
+      currentParent = currentParent.parent;
+      ensurePropertyComplete(offset + length);
+    },
+    onLiteralValue: (value, offset, length) => {
+      onValue({ type: getNodeType(value), offset, length, parent: currentParent, value });
+      ensurePropertyComplete(offset + length);
+    },
+    onSeparator: (sep, offset, length) => {
+      if (currentParent.type === "property") {
+        if (sep === ":") {
+          currentParent.colonOffset = offset;
+        } else if (sep === ",") {
+          ensurePropertyComplete(offset);
+        }
+      }
+    },
+    onError: (error51, offset, length) => {
+      errors3.push({ error: error51, offset, length });
+    }
+  };
+  visit(text, visitor, options);
+  const result = currentParent.children[0];
+  if (result) {
+    delete result.parent;
+  }
+  return result;
+}
+function findNodeAtLocation(root, path3) {
+  if (!root) {
+    return;
+  }
+  let node = root;
+  for (let segment of path3) {
+    if (typeof segment === "string") {
+      if (node.type !== "object" || !Array.isArray(node.children)) {
+        return;
+      }
+      let found = false;
+      for (const propertyNode of node.children) {
+        if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment && propertyNode.children.length === 2) {
+          node = propertyNode.children[1];
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        return;
+      }
+    } else {
+      const index = segment;
+      if (node.type !== "array" || index < 0 || !Array.isArray(node.children) || index >= node.children.length) {
+        return;
+      }
+      node = node.children[index];
+    }
+  }
+  return node;
+}
+function getNodeValue(node) {
+  switch (node.type) {
+    case "array":
+      return node.children.map(getNodeValue);
+    case "object":
+      const obj = Object.create(null);
+      for (let prop of node.children) {
+        const valueNode = prop.children[1];
+        if (valueNode) {
+          obj[prop.children[0].value] = getNodeValue(valueNode);
+        }
+      }
+      return obj;
+    case "null":
+    case "string":
+    case "number":
+    case "boolean":
+      return node.value;
+    default:
+      return;
+  }
+}
+function visit(text, visitor, options = ParseOptions.DEFAULT) {
+  const _scanner = createScanner(text, false);
+  const _jsonPath = [];
+  let suppressedCallbacks = 0;
+  function toNoArgVisit(visitFunction) {
+    return visitFunction ? () => suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisit(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisitWithPath(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+  }
+  function toBeginVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks++;
+      } else {
+        let cbReturn = visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice());
+        if (cbReturn === false) {
+          suppressedCallbacks = 1;
+        }
+      }
+    } : () => true;
+  }
+  function toEndVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks--;
+      }
+      if (suppressedCallbacks === 0) {
+        visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
+      }
+    } : () => true;
+  }
+  const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
+  const disallowComments = options && options.disallowComments;
+  const allowTrailingComma = options && options.allowTrailingComma;
+  function scanNext() {
+    while (true) {
+      const token = _scanner.scan();
+      switch (_scanner.getTokenError()) {
+        case 4:
+          handleError(14);
+          break;
+        case 5:
+          handleError(15);
+          break;
+        case 3:
+          handleError(13);
+          break;
+        case 1:
+          if (!disallowComments) {
+            handleError(11);
+          }
+          break;
+        case 2:
+          handleError(12);
+          break;
+        case 6:
+          handleError(16);
+          break;
+      }
+      switch (token) {
+        case 12:
+        case 13:
+          if (disallowComments) {
+            handleError(10);
+          } else {
+            onComment();
+          }
+          break;
+        case 16:
+          handleError(1);
+          break;
+        case 15:
+        case 14:
+          break;
+        default:
+          return token;
+      }
+    }
+  }
+  function handleError(error51, skipUntilAfter = [], skipUntil = []) {
+    onError(error51);
+    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 path3 = originalPath.slice();
+  const errors3 = [];
+  const root = parseTree(text, errors3);
+  let parent = undefined;
+  let lastSegment = undefined;
+  while (path3.length > 0) {
+    lastSegment = path3.pop();
+    parent = findNodeAtLocation(root, path3);
+    if (parent === undefined && value !== undefined) {
+      if (typeof lastSegment === "string") {
+        value = { [lastSegment]: value };
+      } else {
+        value = [value];
+      }
+    } else {
+      break;
+    }
+  }
+  if (!parent) {
+    if (value === undefined) {
+      throw new Error("Can not delete in empty document");
+    }
+    return withFormatting(text, { offset: root ? root.offset : 0, length: root ? root.length : 0, content: JSON.stringify(value) }, options);
+  } else if (parent.type === "object" && typeof lastSegment === "string" && Array.isArray(parent.children)) {
+    const existing = findNodeAtLocation(parent, [lastSegment]);
+    if (existing !== undefined) {
+      if (value === undefined) {
+        if (!existing.parent) {
+          throw new Error("Malformed AST");
+        }
+        const propertyIndex = parent.children.indexOf(existing.parent);
+        let removeBegin;
+        let removeEnd = existing.parent.offset + existing.parent.length;
+        if (propertyIndex > 0) {
+          let previous = parent.children[propertyIndex - 1];
+          removeBegin = previous.offset + previous.length;
+        } else {
+          removeBegin = parent.offset + 1;
+          if (parent.children.length > 1) {
+            let next = parent.children[1];
+            removeEnd = next.offset;
+          }
+        }
+        return withFormatting(text, { offset: removeBegin, length: removeEnd - removeBegin, content: "" }, options);
+      } else {
+        return withFormatting(text, { offset: existing.offset, length: existing.length, content: JSON.stringify(value) }, options);
+      }
+    } else {
+      if (value === undefined) {
+        return [];
+      }
+      const newProperty = `${JSON.stringify(lastSegment)}: ${JSON.stringify(value)}`;
+      const index = options.getInsertionIndex ? options.getInsertionIndex(parent.children.map((p) => p.children[0].value)) : parent.children.length;
+      let edit;
+      if (index > 0) {
+        let previous = parent.children[index - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      } else if (parent.children.length === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty };
+      } else {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty + "," };
+      }
+      return withFormatting(text, edit, options);
+    }
+  } else if (parent.type === "array" && typeof lastSegment === "number" && Array.isArray(parent.children)) {
+    const insertIndex = lastSegment;
+    if (insertIndex === -1) {
+      const newProperty = `${JSON.stringify(value)}`;
+      let edit;
+      if (parent.children.length === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty };
+      } else {
+        const previous = parent.children[parent.children.length - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      }
+      return withFormatting(text, edit, options);
+    } else if (value === undefined && parent.children.length >= 0) {
+      const removalIndex = lastSegment;
+      const toRemove = parent.children[removalIndex];
+      let edit;
+      if (parent.children.length === 1) {
+        edit = { offset: parent.offset + 1, length: parent.length - 2, content: "" };
+      } else if (parent.children.length - 1 === removalIndex) {
+        let previous = parent.children[removalIndex - 1];
+        let offset = previous.offset + previous.length;
+        let parentEndOffset = parent.offset + parent.length;
+        edit = { offset, length: parentEndOffset - 2 - offset, content: "" };
+      } else {
+        edit = { offset: toRemove.offset, length: parent.children[removalIndex + 1].offset - toRemove.offset, content: "" };
+      }
+      return withFormatting(text, edit, options);
+    } else if (value !== undefined) {
+      let edit;
+      const newProperty = `${JSON.stringify(value)}`;
+      if (!options.isArrayInsertion && parent.children.length > lastSegment) {
+        const toModify = parent.children[lastSegment];
+        edit = { offset: toModify.offset, length: toModify.length, content: newProperty };
+      } else if (parent.children.length === 0 || lastSegment === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: parent.children.length === 0 ? newProperty : newProperty + "," };
+      } else {
+        const index = lastSegment > parent.children.length ? parent.children.length : lastSegment;
+        const previous = parent.children[index - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      }
+      return withFormatting(text, edit, options);
+    } else {
+      throw new Error(`Can not ${value === undefined ? "remove" : options.isArrayInsertion ? "insert" : "modify"} Array index ${insertIndex} as length is not sufficient`);
+    }
+  } else {
+    throw new Error(`Can not add ${typeof lastSegment !== "number" ? "index" : "property"} to parent of type ${parent.type}`);
+  }
+}
+function withFormatting(text, edit, options) {
+  if (!options.formattingOptions) {
+    return [edit];
+  }
+  let newText = applyEdit(text, edit);
+  let begin = edit.offset;
+  let end = edit.offset + edit.content.length;
+  if (edit.length === 0 || edit.content.length === 0) {
+    while (begin > 0 && !isEOL(newText, begin - 1)) {
+      begin--;
+    }
+    while (end < newText.length && !isEOL(newText, end)) {
+      end++;
+    }
+  }
+  const edits = format(newText, { offset: begin, length: end - begin }, { ...options.formattingOptions, keepLines: false });
+  for (let i = edits.length - 1;i >= 0; i--) {
+    const edit2 = edits[i];
+    newText = applyEdit(newText, edit2);
+    begin = Math.min(begin, edit2.offset);
+    end = Math.max(end, edit2.offset + edit2.length);
+    end += edit2.content.length - edit2.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(ScanError2) {
+  ScanError2[ScanError2["None"] = 0] = "None";
+  ScanError2[ScanError2["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+  ScanError2[ScanError2["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+  ScanError2[ScanError2["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+  ScanError2[ScanError2["InvalidUnicode"] = 4] = "InvalidUnicode";
+  ScanError2[ScanError2["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+  ScanError2[ScanError2["InvalidCharacter"] = 6] = "InvalidCharacter";
+})(ScanError || (ScanError = {}));
+var SyntaxKind;
+(function(SyntaxKind2) {
+  SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 1] = "OpenBraceToken";
+  SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 2] = "CloseBraceToken";
+  SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 3] = "OpenBracketToken";
+  SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 4] = "CloseBracketToken";
+  SyntaxKind2[SyntaxKind2["CommaToken"] = 5] = "CommaToken";
+  SyntaxKind2[SyntaxKind2["ColonToken"] = 6] = "ColonToken";
+  SyntaxKind2[SyntaxKind2["NullKeyword"] = 7] = "NullKeyword";
+  SyntaxKind2[SyntaxKind2["TrueKeyword"] = 8] = "TrueKeyword";
+  SyntaxKind2[SyntaxKind2["FalseKeyword"] = 9] = "FalseKeyword";
+  SyntaxKind2[SyntaxKind2["StringLiteral"] = 10] = "StringLiteral";
+  SyntaxKind2[SyntaxKind2["NumericLiteral"] = 11] = "NumericLiteral";
+  SyntaxKind2[SyntaxKind2["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+  SyntaxKind2[SyntaxKind2["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+  SyntaxKind2[SyntaxKind2["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+  SyntaxKind2[SyntaxKind2["Trivia"] = 15] = "Trivia";
+  SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
+  SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
+})(SyntaxKind || (SyntaxKind = {}));
+var parseTree2 = parseTree;
+var findNodeAtLocation2 = findNodeAtLocation;
+var getNodeValue2 = getNodeValue;
+var ParseErrorCode;
+(function(ParseErrorCode2) {
+  ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
+  ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+  ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+  ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
+  ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
+  ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+  ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+  ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+  ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
+  ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+  ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
+})(ParseErrorCode || (ParseErrorCode = {}));
+function modify(text, path3, value, options) {
+  return setProperty(text, path3, value, options);
+}
+function applyEdits(text, edits) {
+  let sortedEdits = edits.slice(0).sort((a, b) => {
+    const diff = a.offset - b.offset;
+    if (diff === 0) {
+      return a.length - b.length;
+    }
+    return diff;
+  });
+  let lastModifiedOffset = text.length;
+  for (let i = sortedEdits.length - 1;i >= 0; i--) {
+    let e = sortedEdits[i];
+    if (e.offset + e.length <= lastModifiedOffset) {
+      text = applyEdit(text, e);
+    } else {
+      throw new Error("Overlapping edit");
+    }
+    lastModifiedOffset = e.offset;
+  }
+  return text;
+}
+
+// ../plugin/src/shared/jsonc-edit.ts
+var TOKEN_COMMA = 5;
+var TOKEN_EOF = 17;
+function parseDocument(text) {
+  const errors3 = [];
+  const root = parseTree2(text, errors3, { allowTrailingComma: true });
+  if (!root || errors3.length > 0) {
+    throw new Error("Cannot edit invalid JSONC");
+  }
+  return root;
+}
+function findNode(text, path3) {
+  return findNodeAtLocation2(parseDocument(text), path3);
+}
+function findComma(text, start, end) {
+  const scanner = createScanner2(text, false);
+  scanner.setPosition(start);
+  for (;; ) {
+    const kind = scanner.scan();
+    const offset = scanner.getTokenOffset();
+    if (kind === TOKEN_EOF || offset >= end)
+      return;
+    if (kind === TOKEN_COMMA) {
+      return {
+        offset,
+        length: scanner.getTokenLength(),
+        line: scanner.getTokenStartLine()
+      };
+    }
+  }
+}
+function setJsoncValue(text, path3, value) {
+  const node = findNode(text, path3);
+  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, path3, value, {}));
+}
+function removeObjectProperty(text, object2, key) {
+  const properties = object2.children ?? [];
+  const index = properties.findIndex((property2) => {
+    const propertyKey = property2.children?.[0];
+    return propertyKey !== undefined && getNodeValue2(propertyKey) === key;
+  });
+  if (index === -1)
+    return text;
+  const property = properties[index];
+  if (!property)
+    return text;
+  const closingBrace = object2.offset + object2.length - 1;
+  const next = properties[index + 1];
+  if (next) {
+    const followingComma = findComma(text, property.offset + property.length, next.offset);
+    if (!followingComma)
+      return text;
+    return text.slice(0, property.offset) + text.slice(followingComma.offset + followingComma.length);
+  }
+  const previous = properties[index - 1];
+  const trailingComma = findComma(text, property.offset + property.length, closingBrace);
+  if (!previous) {
+    const afterProperty2 = property.offset + property.length;
+    if (!trailingComma)
+      return text.slice(0, property.offset) + text.slice(afterProperty2);
+    return text.slice(0, property.offset) + text.slice(afterProperty2, trailingComma.offset) + text.slice(trailingComma.offset + trailingComma.length);
+  }
+  const precedingComma = findComma(text, previous.offset + previous.length, property.offset);
+  if (!precedingComma)
+    return text;
+  const afterProperty = property.offset + property.length;
+  const withoutProperty = text.slice(0, precedingComma.offset) + text.slice(precedingComma.offset + precedingComma.length, property.offset) + text.slice(afterProperty);
+  if (!trailingComma)
+    return withoutProperty;
+  const shiftedTrailingComma = trailingComma.offset - 1;
+  return withoutProperty.slice(0, shiftedTrailingComma) + withoutProperty.slice(shiftedTrailingComma + trailingComma.length);
+}
+function removeJsoncValue(text, path3) {
+  const key = path3.at(-1);
+  if (typeof key !== "string")
+    return text;
+  const parent = findNode(text, path3.slice(0, -1));
+  if (parent?.type !== "object")
+    return text;
+  return removeObjectProperty(text, parent, key);
+}
+
+// ../plugin/src/config/raw-loader.ts
+var MODEL_FIELDS = ["model", "fallback_models"];
+var QUALIFIER_FIELDS = ["variant", "thinking_level"];
+var TASK_MODEL_FIELDS = [...MODEL_FIELDS, ...QUALIFIER_FIELDS, "timeout_minutes"];
+var PRE_PER_HARNESS_BACKUP_SUFFIX = ".pre-per-harness.bak";
+var temporaryFileSequence = 0;
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asDocument(text) {
+  try {
+    const document = parseJsonc(text.startsWith("\uFEFF") ? text.slice(1) : text);
+    return isRecord2(document) ? document : null;
+  } catch {
+    return null;
+  }
+}
+function getAtPath(document, path3) {
+  let current = document;
+  for (const part of path3) {
+    if (!isRecord2(current) || !Object.hasOwn(current, part))
+      return;
+    current = current[part];
+  }
+  return current;
+}
+function stableJson(value) {
+  if (Array.isArray(value))
+    return `[${value.map(stableJson).join(",")}]`;
+  if (!isRecord2(value))
+    return JSON.stringify(value);
+  return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(",")}}`;
+}
+function valuesMatch(left, right) {
+  return stableJson(left) === stableJson(right);
+}
+function valueForDiagnostic(value) {
+  return stableJson(value);
+}
+function migrateEntryForHarness(value, harness) {
+  if (Array.isArray(value))
+    return value.map((entry2) => migrateEntryForHarness(entry2, harness));
+  if (!isRecord2(value) || !Object.hasOwn(value, "model"))
+    return value;
+  const entry = { model: value.model };
+  if (harness === "opencode" && Object.hasOwn(value, "variant")) {
+    entry.variant = value.variant;
+  }
+  if (harness === "pi" && Object.hasOwn(value, "thinking_level")) {
+    entry.thinking_level = value.thinking_level;
+  }
+  return entry;
+}
+function migrateFallbackForHarness(value, harness) {
+  if (typeof value === "string")
+    return [value];
+  return migrateEntryForHarness(value, harness);
+}
+function canCreateAtPath(document, path3) {
+  let current = document;
+  for (const part of path3) {
+    if (current === undefined)
+      return true;
+    if (!isRecord2(current))
+      return false;
+    current = current[part];
+  }
+  return current === undefined || isRecord2(current);
+}
+function flatFieldPath(parts) {
+  return parts.join(".");
+}
+function updateDocumentForFlatFields(text) {
+  const hasBom = text.startsWith("\uFEFF");
+  const editableText = hasBom ? text.slice(1) : text;
+  const document = asDocument(text);
+  if (!document) {
+    return { text, hasFlatKeys: false, diagnostics: [], flatPaths: [] };
+  }
+  let nextText = editableText;
+  let hasFlatKeys = false;
+  const diagnostics = [];
+  const flatPaths = [];
+  const sourcePathsToRemove = [];
+  const addDestination = (sourcePath, destinationPath, destinationValue) => {
+    const sourceLabel = flatFieldPath(sourcePath);
+    const destinationLabel = flatFieldPath(destinationPath);
+    if (!canCreateAtPath(document, destinationPath.slice(0, -1))) {
+      diagnostics.push({
+        path: sourceLabel,
+        message: `Flat config field "${sourceLabel}" (${valueForDiagnostic(destinationValue)}) conflicts with non-object destination "${destinationLabel}" (${valueForDiagnostic(getAtPath(document, destinationPath.slice(0, -1)))}); kept the destination and ignored the flat field.`
+      });
+      return;
+    }
+    const existing = getAtPath(document, destinationPath);
+    if (existing !== undefined) {
+      if (!valuesMatch(existing, destinationValue)) {
+        diagnostics.push({
+          path: sourceLabel,
+          message: `Flat config field "${sourceLabel}" (${valueForDiagnostic(destinationValue)}) conflicts with "${destinationLabel}" (${valueForDiagnostic(existing)}); kept "${destinationLabel}" and ignored the flat field.`
+        });
+      }
+      return;
+    }
+    nextText = setJsoncValue(nextText, destinationPath, destinationValue);
+  };
+  const migrateAgentFields = (agentName) => {
+    const agent = document[agentName];
+    if (!isRecord2(agent))
+      return;
+    for (const field of MODEL_FIELDS) {
+      if (!Object.hasOwn(agent, field))
+        continue;
+      const sourcePath = [agentName, field];
+      hasFlatKeys = true;
+      flatPaths.push(flatFieldPath(sourcePath));
+      sourcePathsToRemove.push(sourcePath);
+      const migrateValue = field === "fallback_models" ? migrateFallbackForHarness : migrateEntryForHarness;
+      addDestination(sourcePath, [agentName, "opencode", field], migrateValue(agent[field], "opencode"));
+      addDestination(sourcePath, [agentName, "pi", field], migrateValue(agent[field], "pi"));
+    }
+    if (Object.hasOwn(agent, "variant")) {
+      const sourcePath = [agentName, "variant"];
+      hasFlatKeys = true;
+      flatPaths.push(flatFieldPath(sourcePath));
+      sourcePathsToRemove.push(sourcePath);
+      addDestination(sourcePath, [agentName, "opencode", "variant"], agent.variant);
+    }
+    if (Object.hasOwn(agent, "thinking_level")) {
+      const sourcePath = [agentName, "thinking_level"];
+      hasFlatKeys = true;
+      flatPaths.push(flatFieldPath(sourcePath));
+      sourcePathsToRemove.push(sourcePath);
+      addDestination(sourcePath, [agentName, "pi", "thinking_level"], agent.thinking_level);
+    }
+  };
+  migrateAgentFields("historian");
+  migrateAgentFields("dreamer");
+  const dreamer = document.dreamer;
+  const tasks = isRecord2(dreamer) ? dreamer.tasks : undefined;
+  if (isRecord2(tasks)) {
+    for (const taskName of Object.keys(tasks).sort()) {
+      const task = tasks[taskName];
+      if (!isRecord2(task))
+        continue;
+      for (const field of TASK_MODEL_FIELDS) {
+        if (!Object.hasOwn(task, field))
+          continue;
+        const sourcePath = ["dreamer", "tasks", taskName, field];
+        hasFlatKeys = true;
+        flatPaths.push(flatFieldPath(sourcePath));
+        sourcePathsToRemove.push(sourcePath);
+        if (field === "model" || field === "fallback_models") {
+          addDestination(sourcePath, ["dreamer", "opencode", "tasks", taskName, field], field === "fallback_models" ? migrateFallbackForHarness(task[field], "opencode") : migrateEntryForHarness(task[field], "opencode"));
+          addDestination(sourcePath, ["dreamer", "pi", "tasks", taskName, field], field === "fallback_models" ? migrateFallbackForHarness(task[field], "pi") : migrateEntryForHarness(task[field], "pi"));
+        } else if (field === "variant") {
+          addDestination(sourcePath, ["dreamer", "opencode", "tasks", taskName, field], task[field]);
+        } else if (field === "thinking_level") {
+          addDestination(sourcePath, ["dreamer", "pi", "tasks", taskName, field], task[field]);
+        } else {
+          addDestination(sourcePath, ["dreamer", "opencode", "tasks", taskName, field], task[field]);
+          addDestination(sourcePath, ["dreamer", "pi", "tasks", taskName, field], task[field]);
+        }
+      }
+    }
+  }
+  for (const sourcePath of sourcePathsToRemove) {
+    nextText = removeJsoncValue(nextText, sourcePath);
+  }
+  return {
+    text: hasBom ? `\uFEFF${nextText}` : nextText,
+    hasFlatKeys,
+    diagnostics,
+    flatPaths
+  };
+}
+function hasFlatKeys(input) {
+  const text = typeof input === "string" ? input : input.toString("utf-8");
+  return updateDocumentForFlatFields(text).hasFlatKeys;
+}
+function migrateFlatDetailed(input) {
+  const bytes = typeof input === "string" ? Buffer.from(input, "utf-8") : input;
+  const result = updateDocumentForFlatFields(bytes.toString("utf-8"));
+  return {
+    bytes: Buffer.from(result.text, "utf-8"),
+    hasFlatKeys: result.hasFlatKeys,
+    diagnostics: result.diagnostics
+  };
+}
+function writeExclusiveBackup(backupPath, bytes, mode) {
+  const temporaryPath = writeTemporaryCandidate(backupPath, bytes, mode);
+  try {
+    try {
+      linkSync(temporaryPath, backupPath);
+      return;
+    } catch (error51) {
+      if (error51.code !== "EEXIST")
+        throw error51;
+    }
+    const existingBytes = readFileSync8(backupPath);
+    if (existingBytes.equals(bytes))
+      return;
+    if (bytes.subarray(0, existingBytes.length).equals(existingBytes)) {
+      renameSync2(temporaryPath, backupPath);
+      return;
+    }
+  } finally {
+    try {
+      unlinkSync3(temporaryPath);
+    } catch {}
+  }
+}
+function writeTemporaryCandidate(configPath, bytes, mode) {
+  const directory = dirname5(configPath);
+  const stem = basename3(configPath);
+  for (let attempt = 0;attempt < 32; attempt++) {
+    temporaryFileSequence += 1;
+    const path3 = join6(directory, `.${stem}.per-harness-${process.pid}-${temporaryFileSequence}.tmp`);
+    let descriptor;
+    try {
+      descriptor = openSync2(path3, "wx", mode);
+      writeFileSync2(descriptor, bytes);
+      closeSync2(descriptor);
+      return path3;
+    } catch (error51) {
+      if (descriptor !== undefined) {
+        try {
+          closeSync2(descriptor);
+        } catch {}
+      }
+      try {
+        unlinkSync3(path3);
+      } catch {}
+      if (error51.code !== "EEXIST")
+        throw error51;
+    }
+  }
+  throw new Error(`Could not allocate a temporary config file beside ${configPath}`);
+}
+function migrationWarning(diagnostic) {
+  return diagnostic.message;
+}
+function loadRawConfigFile(options) {
+  if (!existsSync9(options.configPath))
+    return null;
+  let observedBytes;
+  try {
+    observedBytes = readFileSync8(options.configPath);
+  } catch (error51) {
+    throw new Error(`failed to read config: ${error51 instanceof Error ? error51.message : String(error51)}`);
+  }
+  const initialMigration = migrateFlatDetailed(observedBytes);
+  if (!initialMigration.hasFlatKeys) {
+    return {
+      configPath: options.configPath,
+      bytes: observedBytes,
+      text: observedBytes.toString("utf-8"),
+      warnings: [],
+      migrated: false
+    };
+  }
+  if (options.tier === "project") {
+    return {
+      configPath: options.configPath,
+      bytes: initialMigration.bytes,
+      text: initialMigration.bytes.toString("utf-8"),
+      warnings: [
+        "Adapted flat model config in memory; use historian.opencode/historian.pi and dreamer.opencode/dreamer.pi instead. Project config files are never rewritten.",
+        ...initialMigration.diagnostics.map(migrationWarning)
+      ],
+      migrated: false
+    };
+  }
+  const backupPath = `${options.configPath}${PRE_PER_HARNESS_BACKUP_SUFFIX}`;
+  for (;; ) {
+    const migration = migrateFlatDetailed(observedBytes);
+    if (!migration.hasFlatKeys) {
+      return {
+        configPath: options.configPath,
+        bytes: observedBytes,
+        text: observedBytes.toString("utf-8"),
+        warnings: [],
+        migrated: false
+      };
+    }
+    let temporaryPath;
+    try {
+      const mode = statSync6(options.configPath).mode & 511;
+      writeExclusiveBackup(backupPath, observedBytes, mode);
+      temporaryPath = writeTemporaryCandidate(options.configPath, migration.bytes, mode);
+      options.afterTemporaryWrite?.();
+      const currentBytes = readFileSync8(options.configPath);
+      if (!hasFlatKeys(currentBytes)) {
+        unlinkSync3(temporaryPath);
+        return {
+          configPath: options.configPath,
+          bytes: currentBytes,
+          text: currentBytes.toString("utf-8"),
+          warnings: [],
+          migrated: false
+        };
+      }
+      if (!currentBytes.equals(observedBytes)) {
+        unlinkSync3(temporaryPath);
+        observedBytes = currentBytes;
+        continue;
+      }
+      renameSync2(temporaryPath, options.configPath);
+      return {
+        configPath: options.configPath,
+        bytes: migration.bytes,
+        text: migration.bytes.toString("utf-8"),
+        warnings: [
+          "Migrated flat historian/dreamer model config to per-harness blocks.",
+          ...migration.diagnostics.map(migrationWarning)
+        ],
+        migrated: true
+      };
+    } catch (error51) {
+      if (temporaryPath) {
+        try {
+          unlinkSync3(temporaryPath);
+        } catch {}
+      }
+      return {
+        configPath: options.configPath,
+        bytes: observedBytes,
+        text: observedBytes.toString("utf-8"),
+        warnings: [
+          `Could not migrate flat model config: ${error51 instanceof Error ? error51.message : String(error51)}. Flat fields were not applied.`,
+          ...migration.diagnostics.map(migrationWarning)
+        ],
+        migrated: false
+      };
+    }
+  }
+}
+
 // ../plugin/src/config/variable.ts
-import { existsSync as existsSync9, readFileSync as readFileSync8 } from "node:fs";
+import { existsSync as existsSync10, readFileSync as readFileSync9 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { dirname as dirname5, isAbsolute as isAbsolute3, resolve as resolve4 } from "node:path";
+import { dirname as dirname6, isAbsolute as isAbsolute3, resolve as resolve4 } from "node:path";
 var ENV_PATTERN = /\{env:([^}]+)\}/g;
 var FILE_PATTERN = /\{file:([^}]+)\}/g;
 function sensitiveFilePathReason(resolvedPath) {
@@ -36525,7 +38563,7 @@ function substituteConfigVariables(input) {
   if (fileMatches.length === 0) {
     return { text, warnings };
   }
-  const configDir = input.configPath ? dirname5(input.configPath) : process.cwd();
+  const configDir = input.configPath ? dirname6(input.configPath) : process.cwd();
   let output = "";
   let cursor = 0;
   for (const match of fileMatches) {
@@ -36551,13 +38589,13 @@ function substituteConfigVariables(input) {
     if (sensitiveReason) {
       warnings.push(`${token} resolves to a sensitive path (${sensitiveReason}: ${filePath}); ` + "inlining its contents into config — make sure this is intentional.");
     }
-    if (!existsSync9(filePath)) {
+    if (!existsSync10(filePath)) {
       warnings.push(`File not found for ${token} (resolved to ${filePath}); using empty string`);
       continue;
     }
     let contents;
     try {
-      contents = readFileSync8(filePath, "utf-8").trim();
+      contents = readFileSync9(filePath, "utf-8").trim();
     } catch (error51) {
       const message = error51 instanceof Error ? error51.message : String(error51);
       warnings.push(`Failed to read file for ${token} (${filePath}): ${message}; using empty string`);
@@ -36570,12 +38608,12 @@ function substituteConfigVariables(input) {
 }
 
 // ../plugin/src/shared/models-dev-cache.ts
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync10, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join7 } from "node:path";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync11, renameSync as renameSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join8 } from "node:path";
 
 // ../plugin/src/shared/window-geometry.ts
-import { readFileSync as readFileSync9 } from "node:fs";
-import { join as join6 } from "node:path";
+import { readFileSync as readFileSync10 } from "node:fs";
+import { join as join7 } from "node:path";
 var WINDOW_OVERLAY_SCHEMA = "fusiform-window-overlay/v1";
 var PROMPT_WALL_MARGIN = 4096;
 var PI_OUTPUT_FLOOR = 4096;
@@ -36615,7 +38653,7 @@ var configuredOverlayPath;
 var loadedOverlayPath;
 var loadedOverlay;
 var geometryClampLogSeen = new Set;
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isFinitePositive(value) {
@@ -36630,7 +38668,7 @@ function scalarizeFact(value) {
   return;
 }
 function parseFactValue(value) {
-  if (!isRecord2(value) || typeof value.kind !== "string")
+  if (!isRecord3(value) || typeof value.kind !== "string")
     return;
   if (value.kind === "stated") {
     if ((typeof value.value !== "number" || !Number.isFinite(value.value)) && typeof value.value !== "string") {
@@ -36662,7 +38700,7 @@ function parseFactValue(value) {
   return;
 }
 function parseFact(key, value) {
-  if (!isRecord2(value))
+  if (!isRecord3(value))
     return;
   const parsedValue = parseFactValue(value.value);
   if (!parsedValue || !GRADES.has(value.grade) || !UNITS.has(value.units) || !BOUNDARIES.has(value.boundary) || typeof value.source_ref !== "string" || value.source_ref.length === 0 || typeof value.observed_at !== "string" || value.observed_at.length === 0) {
@@ -36685,7 +38723,7 @@ function parseFact(key, value) {
   };
 }
 function parseWindowOverlay(value) {
-  if (!isRecord2(value)) {
+  if (!isRecord3(value)) {
     return { badCells: 0, refusal: "overlay root is not an object" };
   }
   if (value.schema !== WINDOW_OVERLAY_SCHEMA) {
@@ -36700,7 +38738,7 @@ function parseWindowOverlay(value) {
   const cells = [];
   let badCells = 0;
   for (const rawCell of value.cells) {
-    if (!isRecord2(rawCell) || typeof rawCell.provider_id !== "string" || rawCell.provider_id.length === 0 || typeof rawCell.model_id !== "string" || rawCell.model_id.length === 0 || !isRecord2(rawCell.facts)) {
+    if (!isRecord3(rawCell) || typeof rawCell.provider_id !== "string" || rawCell.provider_id.length === 0 || typeof rawCell.model_id !== "string" || rawCell.model_id.length === 0 || !isRecord3(rawCell.facts)) {
       badCells++;
       continue;
     }
@@ -36735,12 +38773,12 @@ function parseWindowOverlay(value) {
   };
 }
 function defaultWindowOverlayPath() {
-  return join6(getDataDir(), "fusiform", "window-overlay.json");
+  return join7(getDataDir(), "fusiform", "window-overlay.json");
 }
 function readWindowOverlayFile(path3, log2 = (message) => sessionLog("global", message)) {
   let raw;
   try {
-    raw = readFileSync9(path3, "utf8");
+    raw = readFileSync10(path3, "utf8");
   } catch (error51) {
     if (error51.code === "ENOENT")
       return;
@@ -36966,14 +39004,14 @@ var reserveClampLogSeen = new Set;
 var apiCache = null;
 var persistSeedLoaded = false;
 function persistFilePath() {
-  return join7(getMagicContextStorageDir(), `model-context-limits-${getHarness()}.json`);
+  return join8(getMagicContextStorageDir(), `model-context-limits-${getHarness()}.json`);
 }
 function loadPersistedApiCacheOnce() {
   if (persistSeedLoaded || apiCache !== null)
     return;
   persistSeedLoaded = true;
   try {
-    const raw = readFileSync10(persistFilePath(), "utf-8");
+    const raw = readFileSync11(persistFilePath(), "utf-8");
     const obj = JSON.parse(raw);
     const map2 = new Map;
     for (const [key, persisted] of Object.entries(obj)) {
@@ -37143,16 +39181,18 @@ function getUserConfigPaths() {
   return [`${basePath}.jsonc`, `${basePath}.json`];
 }
 function resolveFirstExisting(paths) {
-  return paths.find((path3) => existsSync10(path3));
+  return paths.find((path3) => existsSync11(path3));
 }
 function resolvePiLegacyFallback(sources) {
-  return sources.find((source) => existsSync10(source.path)) ?? null;
+  return sources.find((source) => existsSync11(source.path)) ?? null;
 }
 function loadConfigFile(path3, scope) {
   try {
-    const rawText = readFileSync11(path3, "utf-8");
+    const raw = loadRawConfigFile({ configPath: path3, tier: scope });
+    if (!raw)
+      return null;
     const substituted = substituteConfigVariables({
-      text: rawText,
+      text: raw.text,
       configPath: path3,
       isProjectConfig: scope === "project"
     });
@@ -37163,7 +39203,11 @@ function loadConfigFile(path3, scope) {
       path: path3,
       scope,
       config: config2,
-      warnings: [...substituted.warnings, ...unsafeKeyWarnings].map((warning) => `${path3}: ${warning}`),
+      warnings: [
+        ...raw.warnings,
+        ...substituted.warnings,
+        ...unsafeKeyWarnings
+      ].map((warning) => `${path3}: ${warning}`),
       loadOutcome: rejectedKeyPaths.length > 0 ? "schema-recovery" : substituted.warnings.length > 0 ? "substitution-failure" : "ok"
     };
   } catch (error51) {
@@ -37244,7 +39288,13 @@ function parsePiConfig(rawConfig, recoveredTopLevelKeys = []) {
       const key = String(topKey);
       errorPaths.add(key);
       const paths = issuePathsByKey.get(key) ?? [];
-      paths.push([...issue2.path]);
+      if (issue2.code === "unrecognized_keys") {
+        for (const unrecognizedKey of issue2.keys) {
+          paths.push([...issue2.path, unrecognizedKey]);
+        }
+      } else {
+        paths.push([...issue2.path]);
+      }
       issuePathsByKey.set(key, paths);
     }
   }
@@ -37253,11 +39303,6 @@ function parsePiConfig(rawConfig, recoveredTopLevelKeys = []) {
   for (const key of errorPaths) {
     recoveredTopLevelKeys.push(key);
     const isAgentConfig = key === "historian" || key === "dreamer" || key === "sidekick";
-    if (isAgentConfig) {
-      delete patched[key];
-      warnings.push(`"${key}": invalid agent configuration, ignoring. Check your magic-context.jsonc.`);
-      continue;
-    }
     const issuePaths = issuePathsByKey.get(key) ?? [];
     const rawValue = migrated[key];
     const allNested = issuePaths.length > 0 && issuePaths.every((p) => p.length >= 2) && typeof rawValue === "object" && rawValue !== null && !Array.isArray(rawValue);
@@ -37274,8 +39319,15 @@ function parsePiConfig(rawConfig, recoveredTopLevelKeys = []) {
           prunedLeaves.push(result.removed);
         }
       }
-      patched[key] = prunedBlock;
-      warnings.push(`"${key}": invalid nested field(s) ${prunedLeaves.map((l) => `"${l}"`).join(", ")}, using defaults for those.`);
+      if (prunedLeaves.length === issuePaths.length) {
+        patched[key] = prunedBlock;
+        warnings.push(`"${key}": invalid nested field(s) ${prunedLeaves.map((leaf) => `"${key}.${leaf}"`).join(", ")}, using defaults for those.`);
+        continue;
+      }
+    }
+    if (isAgentConfig) {
+      delete patched[key];
+      warnings.push(`"${key}": invalid agent configuration, ignoring. Check your magic-context.jsonc.`);
       continue;
     }
     delete patched[key];
@@ -37303,7 +39355,7 @@ function loadPiConfig(opts = {}) {
     if (loaded)
       loadedFiles.push(loaded);
   }
-  const legacyProjectUnmigrated = !projectPath && !projectLegacyFallback && legacySources.project.some((source) => existsSync10(source.path));
+  const legacyProjectUnmigrated = !projectPath && !projectLegacyFallback && legacySources.project.some((source) => existsSync11(source.path));
   const userPath = resolveFirstExisting(getUserConfigPaths());
   const userLegacyFallback = userPath ? null : resolvePiLegacyFallback(harnessLegacy.user);
   const userReadPath = userPath ?? userLegacyFallback?.path;
@@ -37312,7 +39364,7 @@ function loadPiConfig(opts = {}) {
     if (loaded)
       loadedFiles.push(loaded);
   }
-  const legacyUserUnmigrated = !userPath && !userLegacyFallback && legacySources.user.some((source) => existsSync10(source.path));
+  const legacyUserUnmigrated = !userPath && !userLegacyFallback && legacySources.user.some((source) => existsSync11(source.path));
   if (userLegacyFallback) {
     warnings.push(`[user config] reading legacy config from ${userLegacyFallback.path} until migration completes; run \`npx @cortexkit/magic-context doctor\` to consolidate into the shared CortexKit location.`);
   } else if (legacyUserUnmigrated) {
@@ -37424,7 +39476,7 @@ function loadPiConfigDetailed(opts = {}) {
     if (loaded)
       loadedFiles.push(loaded);
   }
-  const legacyProjectUnmigrated = !projectPath && !projectLegacyFallback && legacySources.project.some((source) => existsSync10(source.path));
+  const legacyProjectUnmigrated = !projectPath && !projectLegacyFallback && legacySources.project.some((source) => existsSync11(source.path));
   const userPath = resolveFirstExisting(getUserConfigPaths());
   const userLegacyFallback = userPath ? null : resolvePiLegacyFallback(harnessLegacy.user);
   const userReadPath = userPath ?? userLegacyFallback?.path;
@@ -37433,7 +39485,7 @@ function loadPiConfigDetailed(opts = {}) {
     if (loaded)
       loadedFiles.push(loaded);
   }
-  const legacyUserUnmigrated = !userPath && !userLegacyFallback && legacySources.user.some((source) => existsSync10(source.path));
+  const legacyUserUnmigrated = !userPath && !userLegacyFallback && legacySources.user.some((source) => existsSync11(source.path));
   if (userLegacyFallback) {
     warnings.push(`[user config] reading legacy config from ${userLegacyFallback.path} until migration completes; run \`npx @cortexkit/magic-context doctor\` to consolidate into the shared CortexKit location.`);
   } else if (legacyUserUnmigrated) {
@@ -37504,7 +39556,7 @@ function loadPiConfigDetailed(opts = {}) {
 }
 
 // src/embedding-bootstrap.ts
-import { statSync as statSync6 } from "node:fs";
+import { statSync as statSync7 } from "node:fs";
 
 // ../plugin/src/features/magic-context/compartment-chunk-embedding.ts
 import { createHash as createHash8 } from "node:crypto";
@@ -39630,19 +41682,19 @@ function wait(ms) {
 function sha256(value) {
   return createHash9("sha256").update(value).digest("hex");
 }
-function stableJson(value) {
+function stableJson2(value) {
   if (Array.isArray(value))
-    return `[${value.map(stableJson).join(",")}]`;
+    return `[${value.map(stableJson2).join(",")}]`;
   if (value && typeof value === "object") {
-    return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`).join(",")}}`;
+    return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => `${JSON.stringify(key)}:${stableJson2(entry)}`).join(",")}}`;
   }
   return JSON.stringify(value);
 }
 function getSynapseLaneIdentity(model, fingerprint) {
-  return `synapse:v1:${sha256(stableJson({ model, fingerprint }))}`;
+  return `synapse:v1:${sha256(stableJson2({ model, fingerprint }))}`;
 }
 function getSynapseBatchRequestKey(args) {
-  return sha256(stableJson({
+  return sha256(stableJson2({
     op: "embed.batch",
     model: args.model,
     required_fingerprint: args.fingerprint,
@@ -40104,7 +42156,7 @@ function getEmbeddingProviderIdentity(config2) {
 // ../plugin/src/features/magic-context/memory/embedding-local.ts
 import { chmodSync as chmodSync2, mkdirSync as mkdirSync4 } from "node:fs";
 import { open, stat, unlink, writeFile } from "node:fs/promises";
-import { dirname as dirname6, join as join8 } from "node:path";
+import { dirname as dirname7, join as join9 } from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 var LOCK_POLL_MS = 150;
 var STALE_LOCK_MS = 3 * 60000;
@@ -40168,7 +42220,7 @@ async function injectWasmOrtForElectron() {
       const { createRequire: createRequireFn } = await import("node:module");
       const requireFn = createRequireFn(import.meta.url);
       const mainEntry = requireFn.resolve("onnxruntime-web");
-      const distDir = dirname6(mainEntry);
+      const distDir = dirname7(mainEntry);
       const wasmPathsPrefix = `${pathToFileURL2(distDir).href}/`;
       if (ortWeb.env?.wasm) {
         ortWeb.env.wasm.wasmPaths = wasmPathsPrefix;
@@ -40305,7 +42357,7 @@ class LocalEmbeddingProvider {
         if (LogLevel && "ERROR" in LogLevel) {
           env.logLevel = LogLevel.ERROR;
         }
-        const modelCacheDir = join8(getMagicContextStorageDir(), "models");
+        const modelCacheDir = join9(getMagicContextStorageDir(), "models");
         try {
           if (shouldEnforcePrivateStoragePermissions()) {
             mkdirSync4(modelCacheDir, { recursive: true, mode: 448 });
@@ -40322,7 +42374,7 @@ class LocalEmbeddingProvider {
           log("[magic-context] could not create model cache dir, using library default");
         }
         const createPipeline = transformersModule.pipeline;
-        const lockPath = join8(modelCacheDir, ".load.lock");
+        const lockPath = join9(modelCacheDir, ".load.lock");
         const releaseLock = await acquireModelLoadLock(lockPath);
         const stopHeartbeat = startLockHeartbeat(lockPath);
         try {
@@ -42785,7 +44837,7 @@ function configCandidatePaths(directory, loadedPaths) {
 function configFingerprint(paths) {
   return paths.map((path3) => {
     try {
-      const stat2 = statSync6(path3);
+      const stat2 = statSync7(path3);
       return `${path3}:${stat2.size}:${stat2.mtimeMs}`;
     } catch {
       return `${path3}:missing`;
@@ -43284,7 +45336,7 @@ Two recovery modes for finer detail:
 var CTX_EXPAND_TOKEN_BUDGET = 15000;
 
 // ../plugin/src/tools/ctx-expand/render.ts
-function isRecord3(value) {
+function isRecord4(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function roleLabel(role) {
@@ -43313,15 +45365,15 @@ function keyArg(input) {
 function asToolPart(part) {
   const type = typeof part.type === "string" ? part.type : "";
   if (type === "tool") {
-    const state = isRecord3(part.state) ? part.state : null;
+    const state = isRecord4(part.state) ? part.state : null;
     const output = state && typeof state.output === "string" ? state.output : state && state.output != null ? JSON.stringify(state.output) : null;
-    const metadata = state && isRecord3(state.metadata) ? state.metadata : null;
+    const metadata = state && isRecord4(state.metadata) ? state.metadata : null;
     const title = state && typeof state.title === "string" && state.title || metadata && typeof metadata.title === "string" && metadata.title || null;
     return {
       name: typeof part.tool === "string" ? part.tool : "tool",
       callId: typeof part.callID === "string" ? part.callID : "",
       title,
-      input: state && isRecord3(state.input) ? state.input : null,
+      input: state && isRecord4(state.input) ? state.input : null,
       output
     };
   }
@@ -43330,7 +45382,7 @@ function asToolPart(part) {
       name: typeof part.name === "string" ? part.name : "tool",
       callId: typeof part.id === "string" ? part.id : "",
       title: null,
-      input: isRecord3(part.input) ? part.input : null,
+      input: isRecord4(part.input) ? part.input : null,
       output: null
     };
   }
@@ -43359,7 +45411,7 @@ function reasoningOf(part) {
   return null;
 }
 function renderPartPreview(part) {
-  if (!isRecord3(part))
+  if (!isRecord4(part))
     return null;
   const text = textOf(part);
   if (text !== null) {
@@ -43383,7 +45435,7 @@ function renderPartPreview(part) {
   return `    • [${type}]`;
 }
 function renderPartFull(part) {
-  if (!isRecord3(part))
+  if (!isRecord4(part))
     return null;
   const text = textOf(part);
   if (text !== null) {
@@ -48887,7 +50939,7 @@ function getMemoryVerifications(db, memoryIds) {
 }
 // ../plugin/src/features/magic-context/memory/verification-paths.ts
 import { execFile } from "node:child_process";
-import { existsSync as existsSync11, realpathSync as realpathSync3, statSync as statSync7 } from "node:fs";
+import { existsSync as existsSync12, realpathSync as realpathSync3, statSync as statSync8 } from "node:fs";
 import path3 from "node:path";
 import { promisify } from "node:util";
 var execFileAsync = promisify(execFile);
@@ -48994,7 +51046,7 @@ function verificationFileExists(baseRoot, filePath) {
     return false;
   const root = path3.resolve(baseRoot);
   const candidate = path3.resolve(root, filePath);
-  return isWithin(root, candidate) && existsSync11(candidate);
+  return isWithin(root, candidate) && existsSync12(candidate);
 }
 async function normalizeVerificationFiles(args) {
   const cwd = path3.resolve(args.cwd);
@@ -49027,9 +51079,9 @@ async function normalizeVerificationFiles(args) {
       warnings.push(`Skipped verification path "${value}" because it is the repo/project root.`);
       continue;
     }
-    if (existsSync11(candidate)) {
+    if (existsSync12(candidate)) {
       try {
-        if (statSync7(candidate).isDirectory()) {
+        if (statSync8(candidate).isDirectory()) {
           warnings.push(`Skipped verification path "${value}" because it is a directory.`);
           continue;
         }
@@ -49058,7 +51110,7 @@ async function normalizeVerificationFiles(args) {
       }
       normalized.push(tracked);
     } else {
-      if (!existsSync11(candidate)) {
+      if (!existsSync12(candidate)) {
         warnings.push(`Skipped verification path "${value}" because it does not exist.`);
         continue;
       }
@@ -49548,13 +51600,13 @@ function createCtxMemoryTool(deps) {
 }
 
 // ../plugin/src/features/magic-context/smart-notes/condition-compiler.ts
-import { existsSync as existsSync12 } from "node:fs";
+import { existsSync as existsSync13 } from "node:fs";
 import { isAbsolute as isAbsolute5 } from "node:path";
 
 // ../retina-local-fs/src/path-fence.ts
 import { lstat, readlink, realpath } from "node:fs/promises";
 import { homedir as homedir6 } from "node:os";
-import { basename as basename3, dirname as dirname7, isAbsolute as isAbsolute4, join as join9, relative, resolve as resolve5, sep } from "node:path";
+import { basename as basename4, dirname as dirname8, isAbsolute as isAbsolute4, join as join10, relative, resolve as resolve5, sep } from "node:path";
 
 // ../retina-local-fs/src/errors.ts
 class ProviderError extends Error {
@@ -49569,7 +51621,7 @@ class ProviderError extends Error {
 // ../retina-local-fs/src/path-fence.ts
 async function resolveAndFenceProviderPath(configuredPath, options) {
   const { home, dataDirectory } = await resolveFenceRoots(options);
-  const expanded = configuredPath.startsWith("~/") ? join9(home, configuredPath.slice(2)) : configuredPath === "~" ? home : configuredPath;
+  const expanded = configuredPath.startsWith("~/") ? join10(home, configuredPath.slice(2)) : configuredPath === "~" ? home : configuredPath;
   const absolute = isAbsolute4(expanded) ? resolve5(expanded) : resolve5(options.cwd ?? process.cwd(), expanded);
   const canonical = await canonicalPath(absolute, options.allowMissing);
   if (isFencedPath(canonical, home, dataDirectory)) {
@@ -49585,7 +51637,7 @@ async function resolveFenceRoots(options) {
   } catch (error51) {
     throw fsError(configuredHomePath, error51);
   }
-  const configuredDataDirectory = resolve5(options.dataDirectory ?? process.env.XDG_DATA_HOME ?? join9(home, ".local", "share"));
+  const configuredDataDirectory = resolve5(options.dataDirectory ?? process.env.XDG_DATA_HOME ?? join10(home, ".local", "share"));
   const dataDirectory = await canonicalPath(configuredDataDirectory, true);
   return { home, dataDirectory };
 }
@@ -49603,22 +51655,22 @@ async function canonicalPath(path4, allowMissing) {
         const metadata = await lstat(candidate);
         if (metadata.isSymbolicLink()) {
           const target2 = await readlink(candidate);
-          const resolvedTarget = resolve5(dirname7(candidate), target2);
-          return canonicalPath(join9(resolvedTarget, ...suffix), true);
+          const resolvedTarget = resolve5(dirname8(candidate), target2);
+          return canonicalPath(join10(resolvedTarget, ...suffix), true);
         }
       } catch (candidateError) {
         if (!isMissingError(candidateError)) {
           throw fsError(path4, candidateError);
         }
       }
-      const parent = dirname7(candidate);
+      const parent = dirname8(candidate);
       if (parent === candidate) {
         throw fsError(path4, error51);
       }
-      suffix.unshift(basename3(candidate));
+      suffix.unshift(basename4(candidate));
       candidate = parent;
       try {
-        return join9(await realpath(candidate), ...suffix);
+        return join10(await realpath(candidate), ...suffix);
       } catch (parentError) {
         if (!isMissingError(parentError)) {
           throw fsError(path4, parentError);
@@ -49627,13 +51679,13 @@ async function canonicalPath(path4, allowMissing) {
     }
   }
 }
-function isFencedPath(canonicalPath2, homeDirectory, dataDirectory = process.env.XDG_DATA_HOME ?? join9(resolve5(homeDirectory), ".local", "share")) {
-  const cortexkitRoot = join9(resolve5(dataDirectory), "cortexkit");
+function isFencedPath(canonicalPath2, homeDirectory, dataDirectory = process.env.XDG_DATA_HOME ?? join10(resolve5(homeDirectory), ".local", "share")) {
+  const cortexkitRoot = join10(resolve5(dataDirectory), "cortexkit");
   const relativeToCortexkit = relative(cortexkitRoot, canonicalPath2);
   const insideCortexkit = relativeToCortexkit !== "" && relativeToCortexkit !== ".." && !relativeToCortexkit.startsWith(`..${sep}`) && !isAbsolute4(relativeToCortexkit);
   const parts = insideCortexkit ? relativeToCortexkit.split(sep) : [];
   const pathParts = canonicalPath2.split(sep).filter(Boolean);
-  const name = basename3(canonicalPath2);
+  const name = basename4(canonicalPath2);
   const catalogDirectoryCarveIn = pathParts.includes("catalog");
   const moduleBinCarveIn = parts.length >= 2 && parts[1] === "bin";
   const catalogJsonCarveIn = name.endsWith(".json") && name.includes("catalog");
@@ -49802,9 +51854,10 @@ async function compileSurfaceCondition(surfaceCondition, options) {
     const resolved = await resolveAndFenceProviderPath(path4, {
       allowMissing: true,
       homeDirectory: options.homeDirectory,
+      dataDirectory: options.dataDirectory,
       cwd: options.projectPath
     });
-    return { path: resolved, exists: existsSync12(resolved) };
+    return { path: resolved, exists: existsSync13(resolved) };
   });
   let predicates;
   try {
@@ -50036,7 +52089,7 @@ function singleLine(value) {
 }
 
 // ../plugin/src/features/magic-context/smart-notes/wake-plane.ts
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 var WAKE_PLANE_CAPABILITY = "wake.create";
 var WAKE_PLANE_STATUS_TTL_MS = 5 * 60 * 1000;
 var WAKE_PLANE_HANDSHAKE_TIMEOUT_MS = 2000;
@@ -50045,7 +52098,7 @@ var inFlightProbe = null;
 var catalogProbe = probeWakePlaneCatalog;
 var now = () => Date.now();
 function connectionFile() {
-  return join10(getDataDir(), "cortexkit", "run", "subc-connection.json");
+  return join11(getDataDir(), "cortexkit", "run", "subc-connection.json");
 }
 async function probeWakePlaneCatalog() {
   const file2 = connectionFile();
@@ -52928,8 +54981,8 @@ class BoundedSessionMap {
 
 // ../plugin/src/features/magic-context/compaction-marker.ts
 import { createHash as createHash16 } from "node:crypto";
-import { existsSync as existsSync13 } from "node:fs";
-import { join as join11 } from "node:path";
+import { existsSync as existsSync14 } from "node:fs";
+import { join as join12 } from "node:path";
 var BASE62_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 var ID_PREFIX_HEX_LENGTH = 12;
 var ID_SUFFIX_LENGTH = 14;
@@ -52955,7 +55008,7 @@ function generatePartId(timestampMs, counter = 0n, identity = "") {
   return generateId("prt", timestampMs, counter, identity);
 }
 function getOpenCodeDbPath2() {
-  return join11(getDataDir(), "opencode", "opencode.db");
+  return join12(getDataDir(), "opencode", "opencode.db");
 }
 var cachedWriteDb = null;
 var REQUIRED_MESSAGE_COLUMNS = ["id", "session_id", "time_created", "time_updated", "data"];
@@ -53000,7 +55053,7 @@ function getWritableOpenCodeDb() {
       closeQuietly(cachedWriteDb.db);
     } catch {}
   }
-  if (!existsSync13(dbPath)) {
+  if (!existsSync14(dbPath)) {
     throw new Error(`OpenCode database not found at ${dbPath} (is OpenCode installed?)`);
   }
   const db = new Database(dbPath);
@@ -54141,4 +56194,4 @@ function registerMagicContextTools(pi, opts) {
   }
 }
 
-export { COMPACTION_ENABLED_PATH, isDreamerRunnable, isCompactionEnabled, migrateMagicContextConfigLocations, ProjectIdentityError, resolveProjectIdentityStrict, resolveProjectIdentity, resolveProjectIdentityForSession, beginBootQuietPeriod, scheduleAfterBootQuiet, Database, closeQuietly, isMidTurn, textMentionsRecentCommit, hasMeaningfulUserText, extractTexts, extractToolCallSummaries, preloadTokenizer, estimateTokens, normalizeText, isRecord, completedToolArcCrossesBoundary, estimateTrueRawMessageTokens, buildToolArcs, fenceBoundaryForToolArcs, buildTrueRawTokenIndex, computeRawRangeFingerprint, invalidateTrueRawTokenCache, stripPersistedAssistantText, byteSize, stripTagPrefix, peelLeadingMcTagNotation, prependTag, isEditTool, applyEditMarkerToInput, setRawMessageProvider, withRawMessageProvider, cleanUserText, withRawSessionMessageCache, readRawSessionMessages, primeTailRawMessageCache, getCachedAbsoluteMessageCount, primeInMemoryTailRawMessageCache, getRawSessionMessageCount, getRawSessionTagKeysThrough, getLegacyProtectedTailStartOrdinal, readSessionChunk, clearCompressionDepth, clearCompressionDepthRange, getMessageIndexSourceIdentity, isMessageIndexSourceCurrent, getLastIndexedOrdinal, getMessageIndexReconciliationStartOrdinal, isMessageIndexReconciledThrough, indexSingleMessage, indexMessagesAfterOrdinal, sweepOrphanedOpenCodeMessageIndexes, recordSessionProjectIdentity, COMPARTMENT_LEASE_RENEWAL_MS, acquireCompartmentLease, renewCompartmentLease, releaseCompartmentLease, isCompartmentLeaseHeld, piModelRefToCanonical, resolveModelRefForPi, modelRefLookupOrder, ompModelRefToCanonical, resolveModelRefForOmp, persistCachedM0, clearCachedM0M1, getCompartments, getLastCompartmentEndMessage, getLastCompartmentEndMessageId, getCompartmentsByEndMessageId, appendCompartments, saveRecompStagingPass, getRecompStaging, clearRecompStaging, getRecompPartialRange, setRecompPartialRange, escapeXmlAttr, escapeXmlContent, getModuleNoteEvaluationBridge, getContextStoreUuid, parseCompartmentOutput, resolveWorkspaceShareCategories, resolveWorkspaceIdentitySet, expandWorkspaceIdentitySetWithAliases, sourceNameForMemory, computeWorkspaceEpochFingerprint, bumpEpochsForWorkspaceMembers, readProjectDocsCanonical, copySessionStateForClone, getErrorMessage, describeError, setStoragePrivatePermissionEnforcement, getSchemaFenceRejection, getMigrationOnOpenRefusal, LATEST_SUPPORTED_VERSION, getDatabasePath, getPersistedSchemaVersion, setSqlitePragmaConfig, applySqliteTuningPragmas, runSqliteOptimize, openDatabase, openDatabaseAsync, queueM0Mutation, getMaxM0MutationId, queueMemoryMutation, getMemoryMutationsForRender, getMemoryMutationsForRenderByProjects, getMaxMemoryMutationId, getMaxMemoryMutationIdForProjects, MAX_EXECUTE_THRESHOLD, escalationBands, loadProtectedTailMeta, markProtectedTailPolicyV3Seeded, recordProtectedTailPublicationFloor, recordProtectedTailNoEligibleHead, getWrapupInProgressState, isWrapupInProgress, acquireWrapupInProgress, updateWrapupInProgress, releaseWrapupInProgress, resolveCompactionModeRecord, getCompactionModeRecord, setCompactionModeRecord, reserveProtectedTailDrainTokens, clearEmergencyDrainLatch, recordHistorianDrainFailure, clearHistorianDrainFailure, rollbackProtectedTailDrainReservation, clearPersistedReasoningWatermark, getEmergencyInputSample, setEmergencyDropSample, clearEmergencyDropSample, getLastNudgeUndropped, setLastNudgeUndropped, getLastNudgeLevel, setLastNudgeLevel, resetLastNudgeCycle, resetLastNudgeCycleIfTailShrank, getChannel2NudgeState, getChannel2NudgeClaim, setChannel2NudgeState, casChannel2NudgeState, claimChannel2NudgeState, casChannel2NudgeClaim, getPersistedNoteNudge, setPersistedNoteNudgeTrigger, setPersistedNoteNudgeTriggerMessageId, getNoteNudgeAnchors, getAutoSearchHintDecisions, deliverNoteNudgeAtomic, appendAutoSearchHintDecision, pruneNoteNudgeAnchors, pruneAutoSearchHintDecisions, getPersistedTodoSyntheticAnchor, setPersistedTodoSyntheticAnchor, clearPersistedTodoSyntheticAnchor, getNoteLastReadAt, getHistorianFailureState, incrementHistorianFailure, clearHistorianFailureState, getOverflowState, recordOverflowDetected, clearEmergencyRecovery, clearDetectedContextLimit, getStrippedPlaceholderIds, applyStrippedPlaceholderDelta, getProcessedImageStrippedIds, addProcessedImageStrippedIds, getPendingCompactionMarkerState, clearPendingCompactionMarkerStateIf, getPendingPiCompactionMarkerState, setPendingPiCompactionMarkerState, clearPendingPiCompactionMarkerStateIf, getSessionsWithPendingPiMarker, peekDeferredExecutePending, setDeferredExecutePendingIfAbsent, clearDeferredExecutePendingIfMatches, setSessionWorkMetrics, getSessionWorkMetrics, getOrCreateSessionMeta, updateSessionMeta, advanceToolReclaimWatermark, retryPendingSessionCleanups, getNotes, getSessionNotes, getPendingSmartNotes, getReadySmartNotes, markNoteReady, markNoteChecked, queuePendingOp, getPendingOps, clearPendingOps, removePendingOp, PRIMER_CANDIDATE_TTL_MS, PRIMER_CANDIDATE_MAX_AGE_MS, primerOccurrenceKey, primerOccurrenceUtcDay, insertPrimerCandidates, updatePrimerCandidateEmbedding, getPrimerCandidatesByIds, getPrimerCandidatesForPromotion, countPrimerCandidatesForProject, getActivePrimers, createPrimer, updatePrimerSupport, updatePrimerAnswer, GLOBAL_USER_PROFILE_PROJECT_PATH, getProjectState, bumpProjectUserProfileVersion, saveSourceContent, replaceSourceContent, getSourceContents, recordSubagentInvocation, getLatestHistorianInvocationId, CTX_REDUCE_KEEP, estimateImageTokensFromDataUrl, normalizeTodoStateJson, buildSyntheticTodoPart, stripChannel1ReminderSpans, effectiveTailHygiene, CHANNEL1_SENTINEL, CHANNEL1_FLOOR_TOKENS, decideChannel1, evaluateChannel2, buildChannel2Reminder, buildChannel1Reminder, planEmergencyDrop, updateTagByteSize, AGE_RECLAIM_MIN_TOKENS, getOldestActiveUnprotectedToolTags, getActiveToolTagsForAgeReclaim, getTriggerTagTokenUpperBound, updateTagInputByteSize, updateTagTokenCount, getPersistedToolTagAccounting, getAllStatusTagTokenTotalsFlat, updateTagInputTokenCount, tagTokenCountIsNull, backfillTagTokenCounts, insertTag, updateTagStatus, updateTagDropMode, updateCavemanDepth, hasPiFallbackMessageTags, findAdoptableFallbackTags, hasPiFallbackToolOwnerTags, findPiFallbackToolOwnerTags, adoptPiFallbackToolOwnerTag, adoptPiFallbackMessageTag, getMaxTagNumberBySession, getTagNumberByMessageId, deriveTagLoadFloor, getTagsBySession, getActiveTagsBySession, getTagsForPendingOperations, getTagsByNumbers, getDroppedTagsByNumbers, getMaxDroppedTagNumber, getToolTagNumberByOwner, getNullOwnerToolTag, adoptNullOwnerToolTag, BoundedSessionMap, getWindowOverlay, resolveWindowOverlayFacts, deriveWindowGeometry, formatWindowDerivationLine, isSaneLimit, resolveOutputReserve, getSdkContextLimit, resolveModelConfigOrDefault, promptSurfaceHashMaterial, createPromptSurfaceRuntime, createPromptSurfaceGuidanceEpochCache, SYNTH_USER_ID_PREFIX, resolvePiStableId, isMidTurnPi, readPiSessionMessages, findLastModelKeyFromBranch, convertEntriesToRawMessages, withContentLanguageDirective, withMigrationLanguageDirective, buildPrimaryLanguageDirective, computeCueContentHash, hasMuralCueColumns, getMuralCueState, memoryNeedsCue, setMuralCue, recordMuralCueRejection, invalidateMemory, computeNormalizedHash, hasMemoryShareableColumn, hasMemoryClassifiedAtColumn, getUnclassifiedMemoryIds, insertMemory, getMemoryByHash, getMemoriesByProject, getMemoriesByProjects, getMaxMemoryIdForProjects, getAllActiveMemoriesForMigration, getMemoryById, setMemoryClassification, archiveMemory, deleteMemory, getMemoryCount, getMemoryCountsByStatus, USER_MEMORY_CANDIDATE_TTL_MS, insertUserMemoryCandidates, getUserMemoryCandidates, deleteUserMemoryCandidates, pruneExpiredUserMemoryCandidates, insertUserMemory, getActiveUserMemories, updateUserMemoryContent, dismissUserMemory, getOpenCodeDbPath2 as getOpenCodeDbPath, parseCron, nextOccurrence, nextDueAtMs, DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE, DEFAULT_HISTORIAN_TIMEOUT_MS, buildCanonicalChunkTextFromFts, buildCompartmentSummaryFallbackText, canonicalizeInMemoryChunkTextForEmbedding, chunkCanonicalText, chunkEmbeddingWindowsAreCurrent, replaceCompartmentChunkEmbeddings, cosineSimilarity, GIT_SWEEP_LEASE_RENEWAL_MS, acquireGitSweepLease, renewGitSweepLease, markGitSweepSuccessAndRelease, parkGitSweepNonIndexable, releaseGitSweepLease, contentSha256, sweepStaleEmbeddingIdentitiesForProject, enqueueShadowEmbeddingItems, getProjectEmbeddingSnapshot, getProjectChunkEmbeddingModelId, getProjectEmbeddingMaxInputTokens, embedTextForProject, embedBatchForProject, embedItemsForProject, embedUnembeddedMemoriesForProject, drainCommitBacklogForProject, embedSessionCompartmentChunks, getEmbeddingCoverageStatus, promoteSessionFactsDurable, embedPromotedFacts, recordMemoryMapping, recordMemoryVerifications, getUnmappedMemoryIds, clearMemoryVerifications, getMemoryVerifications, resolveGitTopLevel, readGitHead, readGitChangedFilesSince, readGitFileChangeTimesSince, verificationFileExists, normalizeVerificationFiles, wakePlaneStatus, indexCommitsForProject, embedUnembeddedCommits, loadPiConfig, ensureProjectRegisteredFromPiDirectory, resolveMuralWire, updateCompactionMarkerAfterPublication, COMPARTMENT_RENDER_EPOCH, encodeCachedM0UpgradeIdentity, decodeCachedM0UpgradeIdentity, DEFAULT_HISTORY_BUDGET_TOKENS, renderCompartmentAtTier, renderDecayedCompartments, extractM0Block, TEMPORAL_MARKER_PATTERN, temporalMarkerPrefix, clearInjectionCache, getVisibleMemoryIds, renderMemoryBlock, DEFAULT_MEMORY_BUDGET_TOKENS, DEFAULT_USER_PROFILE_BUDGET_TOKENS, trimMemoriesToBudgetV2, trimWorkspaceMemoriesToBudgetV2, trimUserMemoriesToBudget, renderMemoryBlockV2, stripMemoryMuralBlock, unifiedSearch, rememberTodowriteToolCallTodos, parseTodos, setTodoSnapshot, registerTodoOverlay, registerTodoStateLifecycle, registerMagicContextTools };
+export { COMPACTION_ENABLED_PATH, isDreamerRunnable, isCompactionEnabled, migrateMagicContextConfigLocations, ProjectIdentityError, resolveProjectIdentityStrict, resolveProjectIdentity, resolveProjectIdentityForSession, beginBootQuietPeriod, scheduleAfterBootQuiet, Database, closeQuietly, isMidTurn, textMentionsRecentCommit, hasMeaningfulUserText, extractTexts, extractToolCallSummaries, preloadTokenizer, estimateTokens, normalizeText, isRecord, completedToolArcCrossesBoundary, estimateTrueRawMessageTokens, buildToolArcs, fenceBoundaryForToolArcs, buildTrueRawTokenIndex, computeRawRangeFingerprint, invalidateTrueRawTokenCache, stripPersistedAssistantText, byteSize, stripTagPrefix, peelLeadingMcTagNotation, prependTag, isEditTool, applyEditMarkerToInput, setRawMessageProvider, withRawMessageProvider, cleanUserText, withRawSessionMessageCache, readRawSessionMessages, primeTailRawMessageCache, getCachedAbsoluteMessageCount, primeInMemoryTailRawMessageCache, getRawSessionMessageCount, getRawSessionTagKeysThrough, getLegacyProtectedTailStartOrdinal, readSessionChunk, clearCompressionDepth, clearCompressionDepthRange, getMessageIndexSourceIdentity, isMessageIndexSourceCurrent, getLastIndexedOrdinal, getMessageIndexReconciliationStartOrdinal, isMessageIndexReconciledThrough, indexSingleMessage, indexMessagesAfterOrdinal, sweepOrphanedOpenCodeMessageIndexes, recordSessionProjectIdentity, COMPARTMENT_LEASE_RENEWAL_MS, acquireCompartmentLease, renewCompartmentLease, releaseCompartmentLease, isCompartmentLeaseHeld, piModelRefToCanonical, resolveModelRefForPi, modelRefLookupOrder, ompModelRefToCanonical, resolveModelRefForOmp, persistCachedM0, clearCachedM0M1, getCompartments, getLastCompartmentEndMessage, getLastCompartmentEndMessageId, getCompartmentsByEndMessageId, appendCompartments, saveRecompStagingPass, getRecompStaging, clearRecompStaging, getRecompPartialRange, setRecompPartialRange, escapeXmlAttr, escapeXmlContent, getModuleNoteEvaluationBridge, getContextStoreUuid, parseCompartmentOutput, resolveWorkspaceShareCategories, resolveWorkspaceIdentitySet, expandWorkspaceIdentitySetWithAliases, sourceNameForMemory, computeWorkspaceEpochFingerprint, bumpEpochsForWorkspaceMembers, readProjectDocsCanonical, copySessionStateForClone, getErrorMessage, describeError, setStoragePrivatePermissionEnforcement, getSchemaFenceRejection, getMigrationOnOpenRefusal, LATEST_SUPPORTED_VERSION, getDatabasePath, getPersistedSchemaVersion, setSqlitePragmaConfig, applySqliteTuningPragmas, runSqliteOptimize, openDatabase, openDatabaseAsync, queueM0Mutation, getMaxM0MutationId, queueMemoryMutation, getMemoryMutationsForRender, getMemoryMutationsForRenderByProjects, getMaxMemoryMutationId, getMaxMemoryMutationIdForProjects, MAX_EXECUTE_THRESHOLD, escalationBands, loadProtectedTailMeta, markProtectedTailPolicyV3Seeded, recordProtectedTailPublicationFloor, recordProtectedTailNoEligibleHead, getWrapupInProgressState, isWrapupInProgress, acquireWrapupInProgress, updateWrapupInProgress, releaseWrapupInProgress, resolveCompactionModeRecord, getCompactionModeRecord, setCompactionModeRecord, reserveProtectedTailDrainTokens, clearEmergencyDrainLatch, recordHistorianDrainFailure, clearHistorianDrainFailure, rollbackProtectedTailDrainReservation, clearPersistedReasoningWatermark, getEmergencyInputSample, setEmergencyDropSample, clearEmergencyDropSample, getLastNudgeUndropped, setLastNudgeUndropped, getChannel1NudgeState, setChannel1NudgeState, resetLastNudgeCycle, resetLastNudgeCycleIfTailShrank, getChannel2NudgeState, getChannel2NudgeClaim, setChannel2NudgeState, casChannel2NudgeState, claimChannel2NudgeState, casChannel2NudgeClaim, getPersistedNoteNudge, setPersistedNoteNudgeTrigger, setPersistedNoteNudgeTriggerMessageId, getNoteNudgeAnchors, getAutoSearchHintDecisions, deliverNoteNudgeAtomic, appendAutoSearchHintDecision, pruneNoteNudgeAnchors, pruneAutoSearchHintDecisions, getPersistedTodoSyntheticAnchor, setPersistedTodoSyntheticAnchor, clearPersistedTodoSyntheticAnchor, getNoteLastReadAt, getHistorianFailureState, incrementHistorianFailure, clearHistorianFailureState, getOverflowState, recordOverflowDetected, clearEmergencyRecovery, clearDetectedContextLimit, getStrippedPlaceholderIds, applyStrippedPlaceholderDelta, getProcessedImageStrippedIds, addProcessedImageStrippedIds, getPendingCompactionMarkerState, clearPendingCompactionMarkerStateIf, getPendingPiCompactionMarkerState, setPendingPiCompactionMarkerState, clearPendingPiCompactionMarkerStateIf, getSessionsWithPendingPiMarker, peekDeferredExecutePending, setDeferredExecutePendingIfAbsent, clearDeferredExecutePendingIfMatches, setSessionWorkMetrics, getSessionWorkMetrics, getOrCreateSessionMeta, updateSessionMeta, advanceToolReclaimWatermark, retryPendingSessionCleanups, getNotes, getSessionNotes, getPendingSmartNotes, getReadySmartNotes, markNoteReady, markNoteChecked, queuePendingOp, getPendingOps, clearPendingOps, removePendingOp, PRIMER_CANDIDATE_TTL_MS, PRIMER_CANDIDATE_MAX_AGE_MS, primerOccurrenceKey, primerOccurrenceUtcDay, insertPrimerCandidates, updatePrimerCandidateEmbedding, getPrimerCandidatesByIds, getPrimerCandidatesForPromotion, countPrimerCandidatesForProject, getActivePrimers, createPrimer, updatePrimerSupport, updatePrimerAnswer, GLOBAL_USER_PROFILE_PROJECT_PATH, getProjectState, bumpProjectUserProfileVersion, saveSourceContent, replaceSourceContent, getSourceContents, recordSubagentInvocation, getLatestHistorianInvocationId, CTX_REDUCE_KEEP, estimateImageTokensFromDataUrl, normalizeTodoStateJson, buildSyntheticTodoPart, stripChannel1ReminderSpans, effectiveTailHygiene, CHANNEL1_SENTINEL, CHANNEL1_FLOOR_TOKENS, decideChannel1, evaluateChannel2, buildChannel2Reminder, shouldUseStickyChannel1Reminder, buildChannel1Reminder, planEmergencyDrop, updateTagByteSize, AGE_RECLAIM_MIN_TOKENS, getOldestActiveUnprotectedToolTags, getActiveToolTagsForAgeReclaim, getTriggerTagTokenUpperBound, updateTagInputByteSize, updateTagTokenCount, getPersistedToolTagAccounting, getAllStatusTagTokenTotalsFlat, updateTagInputTokenCount, tagTokenCountIsNull, backfillTagTokenCounts, insertTag, updateTagStatus, updateTagDropMode, updateCavemanDepth, hasPiFallbackMessageTags, findAdoptableFallbackTags, hasPiFallbackToolOwnerTags, findPiFallbackToolOwnerTags, adoptPiFallbackToolOwnerTag, adoptPiFallbackMessageTag, getMaxTagNumberBySession, getTagNumberByMessageId, deriveTagLoadFloor, getTagsBySession, getActiveTagsBySession, getTagsForPendingOperations, getTagsByNumbers, getDroppedTagsByNumbers, getMaxDroppedTagNumber, getToolTagNumberByOwner, getNullOwnerToolTag, adoptNullOwnerToolTag, BoundedSessionMap, getWindowOverlay, resolveWindowOverlayFacts, deriveWindowGeometry, formatWindowDerivationLine, isSaneLimit, resolveOutputReserve, getSdkContextLimit, resolveModelConfigOrDefault, promptSurfaceHashMaterial, createPromptSurfaceRuntime, createPromptSurfaceGuidanceEpochCache, SYNTH_USER_ID_PREFIX, resolvePiStableId, isMidTurnPi, readPiSessionMessages, findLastModelKeyFromBranch, convertEntriesToRawMessages, withContentLanguageDirective, withMigrationLanguageDirective, buildPrimaryLanguageDirective, computeCueContentHash, hasMuralCueColumns, getMuralCueState, memoryNeedsCue, setMuralCue, recordMuralCueRejection, invalidateMemory, computeNormalizedHash, hasMemoryShareableColumn, hasMemoryClassifiedAtColumn, getUnclassifiedMemoryIds, insertMemory, getMemoryByHash, getMemoriesByProject, getMemoriesByProjects, getMaxMemoryIdForProjects, getAllActiveMemoriesForMigration, getMemoryById, setMemoryClassification, archiveMemory, deleteMemory, getMemoryCount, getMemoryCountsByStatus, USER_MEMORY_CANDIDATE_TTL_MS, insertUserMemoryCandidates, getUserMemoryCandidates, deleteUserMemoryCandidates, pruneExpiredUserMemoryCandidates, insertUserMemory, getActiveUserMemories, updateUserMemoryContent, dismissUserMemory, getOpenCodeDbPath2 as getOpenCodeDbPath, parseCron, nextOccurrence, nextDueAtMs, DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE, DEFAULT_HISTORIAN_TIMEOUT_MS, buildCanonicalChunkTextFromFts, buildCompartmentSummaryFallbackText, canonicalizeInMemoryChunkTextForEmbedding, chunkCanonicalText, chunkEmbeddingWindowsAreCurrent, replaceCompartmentChunkEmbeddings, cosineSimilarity, GIT_SWEEP_LEASE_RENEWAL_MS, acquireGitSweepLease, renewGitSweepLease, markGitSweepSuccessAndRelease, parkGitSweepNonIndexable, releaseGitSweepLease, contentSha256, sweepStaleEmbeddingIdentitiesForProject, enqueueShadowEmbeddingItems, getProjectEmbeddingSnapshot, getProjectChunkEmbeddingModelId, getProjectEmbeddingMaxInputTokens, embedTextForProject, embedBatchForProject, embedItemsForProject, embedUnembeddedMemoriesForProject, drainCommitBacklogForProject, embedSessionCompartmentChunks, getEmbeddingCoverageStatus, promoteSessionFactsDurable, embedPromotedFacts, recordMemoryMapping, recordMemoryVerifications, getUnmappedMemoryIds, clearMemoryVerifications, getMemoryVerifications, resolveGitTopLevel, readGitHead, readGitChangedFilesSince, readGitFileChangeTimesSince, verificationFileExists, normalizeVerificationFiles, wakePlaneStatus, indexCommitsForProject, embedUnembeddedCommits, loadPiConfig, ensureProjectRegisteredFromPiDirectory, resolveMuralWire, updateCompactionMarkerAfterPublication, COMPARTMENT_RENDER_EPOCH, encodeCachedM0UpgradeIdentity, decodeCachedM0UpgradeIdentity, DEFAULT_HISTORY_BUDGET_TOKENS, renderCompartmentAtTier, renderDecayedCompartments, extractM0Block, TEMPORAL_MARKER_PATTERN, temporalMarkerPrefix, clearInjectionCache, getVisibleMemoryIds, renderMemoryBlock, DEFAULT_MEMORY_BUDGET_TOKENS, DEFAULT_USER_PROFILE_BUDGET_TOKENS, trimMemoriesToBudgetV2, trimWorkspaceMemoriesToBudgetV2, trimUserMemoriesToBudget, renderMemoryBlockV2, stripMemoryMuralBlock, unifiedSearch, rememberTodowriteToolCallTodos, parseTodos, setTodoSnapshot, registerTodoOverlay, registerTodoStateLifecycle, registerMagicContextTools };