@cortexkit/opencode-magic-context 0.45.0 → 0.46.1

package/dist/v2/{server-v5xgft5v.js → server-e29d7p7c.js}

@@ -1,28 +1,164 @@
 import {
-  toolTemplateError
-} from "./server-remp7e2g.js";
-import {
-  getHarness,
-  getMagicContextStorageDir,
-  importPluginModule,
-  log
-} from "./server-ckpc8pxy.js";
-import {
-  estimateTokens
-} from "./server-rhdgxp1t.js";
-import {
-  shouldEnforcePrivateStoragePermissions
-} from "./server-e44zzy84.js";
+  toolTemplateError,
+  DEFAULT_PROTECTED_TOOLS,
+  mergeProtectedTools
+} from "./server-g0fjrkta.js";
 import {
   modelRefLookupOrder
 } from "./server-avwt563y.js";
 
-// src/features/magic-context/memory/embedding-local.ts
-import { chmodSync, mkdirSync, readdirSync, statSync } from "node:fs";
-import { open, stat, unlink, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { pathToFileURL } from "node:url";
-import { workerData } from "node:worker_threads";
+// src/agents/language-directive.ts
+var ENGLISH_LANGUAGE_NAMES = new Intl.DisplayNames(["en"], {
+  type: "language",
+  fallback: "none"
+});
+function resolveLanguageName(language) {
+  const code = typeof language === "string" ? language.trim().toLowerCase() : "";
+  if (!/^[a-z]{2}$/.test(code))
+    return "";
+  let english;
+  try {
+    english = ENGLISH_LANGUAGE_NAMES.of(code) ?? undefined;
+  } catch {
+    return "";
+  }
+  if (!english)
+    return "";
+  let endonym;
+  try {
+    endonym = new Intl.DisplayNames([code], { type: "language", fallback: "none" }).of(code) ?? undefined;
+  } catch {
+    endonym = undefined;
+  }
+  return endonym && endonym !== english ? `${english} (${endonym})` : english;
+}
+function isValidLanguageCode(language) {
+  return resolveLanguageName(language) !== "";
+}
+function buildContentLanguageDirective(language, options = {}) {
+  const target = resolveLanguageName(language);
+  if (!target)
+    return "";
+  const lines = [
+    "## Output language",
+    "",
+    `Write human-readable prose you author in: ${target}.`,
+    "",
+    "Do not translate or rename structural tokens. Copy required output schemas exactly:",
+    "- XML tag names, XML attribute names, JSON keys, tool names, tool-call argument keys, enum values, booleans/null, and required sentinel strings stay in English exactly as shown.",
+    "- Keep code identifiers, file paths, commands, config keys, CLI flags, URLs, commit hashes, model/provider IDs, stack traces, diagnostics, and transcript role markers such as U:, A:, and TC: verbatim.",
+    "- Localize only free-text prose values/content: summaries, memory text, explanations, titles, observations, and answers — unless the prompt says to preserve original wording.",
+    "",
+    "These literal values must remain English when used:",
+    "PROJECT_RULES, ARCHITECTURE, CONSTRAINTS, CONFIG_VALUES, NAMING;",
+    "causal_incident, trajectory_correction;",
+    "feature, design, docs, release, investigation, bug, refactor, infra;",
+    "memory, observation; true, false; No relevant memories found.",
+    "",
+    "Preserve the required output shape. Do not add commentary outside the requested XML/JSON/tool output."
+  ];
+  if (options.preserveUserQuotes) {
+    lines.push("", `Preserve U: lines and directly quoted user text in their original source language; write the surrounding summary prose in ${target}.`);
+  }
+  if (options.retrospective) {
+    lines.push("", `Write the lesson text in ${target}; paraphrase source text and never quote the user.`);
+  }
+  return lines.join(`
+`);
+}
+function withContentLanguageDirective(systemPrompt, language, options = {}) {
+  const directive = buildContentLanguageDirective(language, options);
+  return directive ? `${systemPrompt}
+
+${directive}` : systemPrompt;
+}
+function buildPrimaryLanguageDirective(language) {
+  const target = resolveLanguageName(language);
+  if (!target)
+    return "";
+  return `Use ${target} for your natural-language replies to the user unless the user explicitly asks for another language. Keep code, identifiers, file paths, commands, logs, and quoted text verbatim.`;
+}
+
+// src/shared/prompt-surface.ts
+function promptSurfaceConfigIdentity(config) {
+  return JSON.stringify({
+    default: config?.default ?? "full",
+    models: Object.entries(config?.models ?? {}).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0),
+    guidanceOverridePath: config?.guidance_override_path ?? null,
+    toolDescriptions: Object.entries(config?.tool_descriptions ?? {}).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)
+  });
+}
+function isValidPromptSurfaceModelKey(key) {
+  if (key.length === 0 || key.trim() !== key)
+    return false;
+  const slash = key.indexOf("/");
+  if (slash < 0)
+    return !key.includes("*");
+  if (slash === 0 || slash === key.length - 1)
+    return false;
+  const provider = key.slice(0, slash);
+  const modelID = key.slice(slash + 1);
+  if (provider.trim() !== provider || modelID.trim() !== modelID || provider.includes("*") || modelID.includes("*") && modelID !== "*") {
+    return false;
+  }
+  if (modelID === "*")
+    return true;
+  return modelID.length > 0 && !modelID.startsWith("/") && !modelID.endsWith("/") && !modelID.includes("//");
+}
+function modelKeyLookupOrder(modelKey) {
+  if (!modelKey)
+    return [];
+  const slash = modelKey.indexOf("/");
+  if (slash <= 0 || slash === modelKey.length - 1)
+    return [];
+  const provider = modelKey.slice(0, slash);
+  let modelID = modelKey.slice(slash + 1);
+  const providerRefs = modelRefLookupOrder(`${provider}/${modelID}`);
+  const candidates = [];
+  while (modelID.length > 0) {
+    for (const providerRef of providerRefs) {
+      const providerSlash = providerRef.indexOf("/");
+      const providerPrefix = providerRef.slice(0, providerSlash);
+      candidates.push({ key: `${providerPrefix}/${modelID}`, source: "exact" });
+    }
+    candidates.push({ key: modelID, source: "bare" });
+    const lastDash = modelID.lastIndexOf("-");
+    if (lastDash <= 0)
+      break;
+    modelID = modelID.slice(0, lastDash);
+  }
+  for (const providerRef of providerRefs) {
+    const providerSlash = providerRef.indexOf("/");
+    const providerPrefix = providerRef.slice(0, providerSlash);
+    candidates.push({ key: `${providerPrefix}/*`, source: "wildcard" });
+  }
+  const seen = new Set;
+  return candidates.filter((candidate) => {
+    if (seen.has(candidate.key))
+      return false;
+    seen.add(candidate.key);
+    return true;
+  });
+}
+function resolveModelConfigValue(values, modelKey) {
+  if (!values)
+    return;
+  for (const candidate of modelKeyLookupOrder(modelKey)) {
+    const value = values[candidate.key];
+    if (value !== undefined) {
+      return { value, source: candidate.source };
+    }
+  }
+  return;
+}
+function resolvePromptSurface(config, modelKey) {
+  const fallback = config?.default ?? "full";
+  const match = resolveModelConfigValue(config?.models, modelKey);
+  if (match) {
+    return { preset: match.value, source: match.source };
+  }
+  return { preset: fallback, source: "default" };
+}
 
 // src/config/schema/magic-context.ts
 import { homedir } from "node:os";
@@ -3293,7 +3429,7 @@ function initializeContext(params) {
     external: params?.external ?? undefined
   };
 }
-function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
+function process(schema, ctx, _params = { path: [], schemaPath: [] }) {
   var _a;
   const def = schema._zod.def;
   const seen = ctx.seen.get(schema);
@@ -3330,7 +3466,7 @@ function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
     if (parent) {
       if (!result.ref)
         result.ref = parent;
-      process2(parent, ctx, params);
+      process(parent, ctx, params);
       ctx.seen.get(parent).isParent = true;
     }
   }
@@ -3613,14 +3749,14 @@ function isTransforming(_schema, _ctx) {
 }
 var createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
   const ctx = initializeContext({ ...params, processors });
-  process2(schema, ctx);
+  process(schema, ctx);
   extractDefs(ctx, schema);
   return finalize(ctx, schema);
 };
 var createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {
   const { libraryOptions, target } = params ?? {};
   const ctx = initializeContext({ ...libraryOptions ?? {}, target, io, processors });
-  process2(schema, ctx);
+  process(schema, ctx);
   extractDefs(ctx, schema);
   return finalize(ctx, schema);
 };
@@ -3770,7 +3906,7 @@ var arrayProcessor = (schema, ctx, _json, params) => {
   if (typeof maximum === "number")
     json.maxItems = maximum;
   json.type = "array";
-  json.items = process2(def.element, ctx, {
+  json.items = process(def.element, ctx, {
     ...params,
     path: [...params.path, "items"]
   });
@@ -3782,7 +3918,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
   json.properties = {};
   const shape = def.shape;
   for (const key in shape) {
-    json.properties[key] = process2(shape[key], ctx, {
+    json.properties[key] = process(shape[key], ctx, {
       ...params,
       path: [...params.path, "properties", key]
     });
@@ -3805,7 +3941,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
     if (ctx.io === "output")
       json.additionalProperties = false;
   } else if (def.catchall) {
-    json.additionalProperties = process2(def.catchall, ctx, {
+    json.additionalProperties = process(def.catchall, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
@@ -3814,7 +3950,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
 var unionProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
   const isExclusive = def.inclusive === false;
-  const options = def.options.map((x, i) => process2(x, ctx, {
+  const options = def.options.map((x, i) => process(x, ctx, {
     ...params,
     path: [...params.path, isExclusive ? "oneOf" : "anyOf", i]
   }));
@@ -3826,11 +3962,11 @@ var unionProcessor = (schema, ctx, json, params) => {
 };
 var intersectionProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
-  const a = process2(def.left, ctx, {
+  const a = process(def.left, ctx, {
     ...params,
     path: [...params.path, "allOf", 0]
   });
-  const b = process2(def.right, ctx, {
+  const b = process(def.right, ctx, {
     ...params,
     path: [...params.path, "allOf", 1]
   });
@@ -3847,11 +3983,11 @@ var tupleProcessor = (schema, ctx, _json, params) => {
   json.type = "array";
   const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
   const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
-  const prefixItems = def.items.map((x, i) => process2(x, ctx, {
+  const prefixItems = def.items.map((x, i) => process(x, ctx, {
     ...params,
     path: [...params.path, prefixPath, i]
   }));
-  const rest = def.rest ? process2(def.rest, ctx, {
+  const rest = def.rest ? process(def.rest, ctx, {
     ...params,
     path: [...params.path, restPath, ...ctx.target === "openapi-3.0" ? [def.items.length] : []]
   }) : null;
@@ -3891,7 +4027,7 @@ var recordProcessor = (schema, ctx, _json, params) => {
   const keyBag = keyType._zod.bag;
   const patterns = keyBag?.patterns;
   if (def.mode === "loose" && patterns && patterns.size > 0) {
-    const valueSchema = process2(def.valueType, ctx, {
+    const valueSchema = process(def.valueType, ctx, {
       ...params,
       path: [...params.path, "patternProperties", "*"]
     });
@@ -3901,12 +4037,12 @@ var recordProcessor = (schema, ctx, _json, params) => {
     }
   } else {
     if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
-      json.propertyNames = process2(def.keyType, ctx, {
+      json.propertyNames = process(def.keyType, ctx, {
         ...params,
         path: [...params.path, "propertyNames"]
       });
     }
-    json.additionalProperties = process2(def.valueType, ctx, {
+    json.additionalProperties = process(def.valueType, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
@@ -3921,7 +4057,7 @@ var recordProcessor = (schema, ctx, _json, params) => {
 };
 var nullableProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
-  const inner = process2(def.innerType, ctx, params);
+  const inner = process(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   if (ctx.target === "openapi-3.0") {
     seen.ref = def.innerType;
@@ -3932,20 +4068,20 @@ var nullableProcessor = (schema, ctx, json, params) => {
 };
 var nonoptionalProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
-  process2(def.innerType, ctx, params);
+  process(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
 var defaultProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
-  process2(def.innerType, ctx, params);
+  process(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   json.default = JSON.parse(JSON.stringify(def.defaultValue));
 };
 var prefaultProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
-  process2(def.innerType, ctx, params);
+  process(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   if (ctx.io === "input")
@@ -3953,7 +4089,7 @@ var prefaultProcessor = (schema, ctx, json, params) => {
 };
 var catchProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
-  process2(def.innerType, ctx, params);
+  process(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   let catchValue;
@@ -3968,20 +4104,20 @@ var pipeProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
   const inIsTransform = def.in._zod.traits.has("$ZodTransform");
   const innerType = ctx.io === "input" ? inIsTransform ? def.out : def.in : def.out;
-  process2(innerType, ctx, params);
+  process(innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = innerType;
 };
 var readonlyProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
-  process2(def.innerType, ctx, params);
+  process(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   json.readOnly = true;
 };
 var optionalProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
-  process2(def.innerType, ctx, params);
+  process(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
@@ -4883,78 +5019,6 @@ function superRefine(fn, params) {
 }
 // ../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/classic/external.js
 config(en_default());
-// src/agents/language-directive.ts
-var ENGLISH_LANGUAGE_NAMES = new Intl.DisplayNames(["en"], {
-  type: "language",
-  fallback: "none"
-});
-function resolveLanguageName(language) {
-  const code = typeof language === "string" ? language.trim().toLowerCase() : "";
-  if (!/^[a-z]{2}$/.test(code))
-    return "";
-  let english;
-  try {
-    english = ENGLISH_LANGUAGE_NAMES.of(code) ?? undefined;
-  } catch {
-    return "";
-  }
-  if (!english)
-    return "";
-  let endonym;
-  try {
-    endonym = new Intl.DisplayNames([code], { type: "language", fallback: "none" }).of(code) ?? undefined;
-  } catch {
-    endonym = undefined;
-  }
-  return endonym && endonym !== english ? `${english} (${endonym})` : english;
-}
-function isValidLanguageCode(language) {
-  return resolveLanguageName(language) !== "";
-}
-function buildContentLanguageDirective(language, options = {}) {
-  const target = resolveLanguageName(language);
-  if (!target)
-    return "";
-  const lines = [
-    "## Output language",
-    "",
-    `Write human-readable prose you author in: ${target}.`,
-    "",
-    "Do not translate or rename structural tokens. Copy required output schemas exactly:",
-    "- XML tag names, XML attribute names, JSON keys, tool names, tool-call argument keys, enum values, booleans/null, and required sentinel strings stay in English exactly as shown.",
-    "- Keep code identifiers, file paths, commands, config keys, CLI flags, URLs, commit hashes, model/provider IDs, stack traces, diagnostics, and transcript role markers such as U:, A:, and TC: verbatim.",
-    "- Localize only free-text prose values/content: summaries, memory text, explanations, titles, observations, and answers — unless the prompt says to preserve original wording.",
-    "",
-    "These literal values must remain English when used:",
-    "PROJECT_RULES, ARCHITECTURE, CONSTRAINTS, CONFIG_VALUES, NAMING;",
-    "causal_incident, trajectory_correction;",
-    "feature, design, docs, release, investigation, bug, refactor, infra;",
-    "memory, observation; true, false; No relevant memories found.",
-    "",
-    "Preserve the required output shape. Do not add commentary outside the requested XML/JSON/tool output."
-  ];
-  if (options.preserveUserQuotes) {
-    lines.push("", `Preserve U: lines and directly quoted user text in their original source language; write the surrounding summary prose in ${target}.`);
-  }
-  if (options.retrospective) {
-    lines.push("", `Write the lesson text in ${target}; paraphrase source text and never quote the user.`);
-  }
-  return lines.join(`
-`);
-}
-function withContentLanguageDirective(systemPrompt, language, options = {}) {
-  const directive = buildContentLanguageDirective(language, options);
-  return directive ? `${systemPrompt}
-
-${directive}` : systemPrompt;
-}
-function buildPrimaryLanguageDirective(language) {
-  const target = resolveLanguageName(language);
-  if (!target)
-    return "";
-  return `Use ${target} for your natural-language replies to the user unless the user explicitly asks for another language. Keep code, identifiers, file paths, commands, logs, and quoted text verbatim.`;
-}
-
 // src/features/magic-context/dreamer/cron.ts
 var FIELDS = [
   { name: "minute", min: 0, max: 59 },
@@ -5105,87 +5169,6 @@ function nextDueAtMs(expression, afterMs, consumedScheduledAtMs, maxSearchMs = M
   return next ? next.getTime() : null;
 }
 
-// src/shared/prompt-surface.ts
-function promptSurfaceConfigIdentity(config) {
-  return JSON.stringify({
-    default: config?.default ?? "full",
-    models: Object.entries(config?.models ?? {}).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0),
-    guidanceOverridePath: config?.guidance_override_path ?? null,
-    toolDescriptions: Object.entries(config?.tool_descriptions ?? {}).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)
-  });
-}
-function isValidPromptSurfaceModelKey(key) {
-  if (key.length === 0 || key.trim() !== key)
-    return false;
-  const slash = key.indexOf("/");
-  if (slash < 0)
-    return !key.includes("*");
-  if (slash === 0 || slash === key.length - 1)
-    return false;
-  const provider = key.slice(0, slash);
-  const modelID = key.slice(slash + 1);
-  if (provider.trim() !== provider || modelID.trim() !== modelID || provider.includes("*") || modelID.includes("*") && modelID !== "*") {
-    return false;
-  }
-  if (modelID === "*")
-    return true;
-  return modelID.length > 0 && !modelID.startsWith("/") && !modelID.endsWith("/") && !modelID.includes("//");
-}
-function modelKeyLookupOrder(modelKey) {
-  if (!modelKey)
-    return [];
-  const slash = modelKey.indexOf("/");
-  if (slash <= 0 || slash === modelKey.length - 1)
-    return [];
-  const provider = modelKey.slice(0, slash);
-  let modelID = modelKey.slice(slash + 1);
-  const providerRefs = modelRefLookupOrder(`${provider}/${modelID}`);
-  const candidates = [];
-  while (modelID.length > 0) {
-    for (const providerRef of providerRefs) {
-      const providerSlash = providerRef.indexOf("/");
-      const providerPrefix = providerRef.slice(0, providerSlash);
-      candidates.push({ key: `${providerPrefix}/${modelID}`, source: "exact" });
-    }
-    candidates.push({ key: modelID, source: "bare" });
-    const lastDash = modelID.lastIndexOf("-");
-    if (lastDash <= 0)
-      break;
-    modelID = modelID.slice(0, lastDash);
-  }
-  for (const providerRef of providerRefs) {
-    const providerSlash = providerRef.indexOf("/");
-    const providerPrefix = providerRef.slice(0, providerSlash);
-    candidates.push({ key: `${providerPrefix}/*`, source: "wildcard" });
-  }
-  const seen = new Set;
-  return candidates.filter((candidate) => {
-    if (seen.has(candidate.key))
-      return false;
-    seen.add(candidate.key);
-    return true;
-  });
-}
-function resolveModelConfigValue(values, modelKey) {
-  if (!values)
-    return;
-  for (const candidate of modelKeyLookupOrder(modelKey)) {
-    const value = values[candidate.key];
-    if (value !== undefined) {
-      return { value, source: candidate.source };
-    }
-  }
-  return;
-}
-function resolvePromptSurface(config, modelKey) {
-  const fallback = config?.default ?? "full";
-  const match = resolveModelConfigValue(config?.models, modelKey);
-  if (match) {
-    return { preset: match.value, source: match.source };
-  }
-  return { preset: fallback, source: "default" };
-}
-
 // src/config/schema/agent-overrides.ts
 var PermissionValueSchema = _enum(["ask", "allow", "deny"]);
 var PermissionSchema = object({
@@ -5465,6 +5448,7 @@ var AgentMetadataSchema = AgentOverrideConfigSchema.pick({
   maxTokens: true
 });
 var DreamerConfigSchema = AgentMetadataSchema.extend({
+  disable: boolean2().optional().describe("Disable this agent"),
   runner: _enum(["broca", "host"]).optional().describe(`Which side runs the dreamer completions the Rust module routes (classify-memories) in Rust transform mode: "host" runs them on this process's carrier, "broca" routes them to the Broca module. When unset, historian.runner applies, and when that is unset too the harness decides the same way it does for the historian. User-level config only.`),
   opencode: DreamerOpenCodeHarnessBlockSchema.optional(),
   pi: DreamerPiHarnessBlockSchema.optional(),
@@ -5613,7 +5597,7 @@ var MagicContextConfigSchema = object({
   smart_notes: object({
     retina_handoff: boolean2().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."),
-  cache_ttl: union([string(), object({ default: string() }).catchall(string())]).default("5m").describe(`How long Magic Context assumes the provider's cached prefix stays valid. This is MC's own deferral gate — it does not change the provider's actual cache lifetime. String (e.g. "5m", "1h", "30s") or per-model object ({ default: "5m", "provider/model": "1h", "provider/*": "never" }); keys resolve most-specific first (exact provider/model, bare model ID, shorter dash-prefixes, then the provider/* wildcard). Explicit per-model entries win; otherwise GPT-5.6 and later (including gpt-6*, through any provider prefix) use a built-in 30m lifetime before the object default or 5m fallback. An unset or global "5m" opts into built-in defaults; any other global string is an explicit policy and wins. Policy is frozen per session, including across restarts; a model switch resolves against that frozen policy. /ctx-status shows the effective value and source. OpenAI documents at least 30 minutes since the latest write or reuse: https://developers.openai.com/api/docs/guides/prompt-caching (Cache lifetime and Summary of model differences). Set to "never" to mean MC never assumes expiry (for lanes kept warm externally by a cache-keep tool) — disables the idle-TTL heuristic so MC never initiates a rebuild based on elapsed time. Provider-side extended TTL is a separate request-level concern (cache_control: { ttl } in the request body).`),
+  cache_ttl: union([string(), object({ default: string() }).catchall(string())]).default("5m").describe(`How long Magic Context assumes the provider's cached prefix stays valid. This is MC's own deferral gate — it does not change the provider's actual cache lifetime. String (e.g. "5m", "1h", "30s") or per-model object ({ default: "5m", "provider/model": "1h", "provider/*": "never" }); keys resolve most-specific first (exact provider/model, bare model ID, shorter dash-prefixes, then the provider/* wildcard, then default). User and project settings, including an explicit "5m" or object default, apply on the next pass. Only built-in defaults are frozen per session, including across restarts: when unset, GPT-5.6 and later (including gpt-6*, through any provider prefix) use 30m, other models use 5m. /ctx-status shows the effective TTL and whether it comes from your config or a frozen built-in default. Editing the TTL does not itself rewrite prompt bytes; a lowered TTL rebuilds only after normal idle expiry. OpenAI documents at least 30 minutes since the latest write or reuse: https://developers.openai.com/api/docs/guides/prompt-caching (Cache lifetime and Summary of model differences). Set to "never" to mean MC never assumes expiry (for lanes kept warm externally by a cache-keep tool) — disables the idle-TTL heuristic so MC never initiates a rebuild based on elapsed time. Provider-side extended TTL is a separate request-level concern (cache_control: { ttl } in the request body).`),
   prompt_surface: PromptSurfaceConfigSchema.default({ default: "full" }).describe("Prompt-surface presets: default is full; models use bare model IDs, provider/model, or provider/* routing keys. Guidance and tool-description overrides are user-level only. OpenCode 1.x, Pi, and OMP register tool descriptions once per process (they follow the default preset). OpenCode 2 rewrites the five ctx_* descriptions per request from the draft model."),
   output_reserve: union([
     number2().min(0),
@@ -5651,8 +5635,8 @@ var MagicContextConfigSchema = object({
     mmap_size_mb: number2().min(0).max(8192).default(0).describe("Memory-mapped I/O size in MiB (PRAGMA mmap_size). 0 disables mmap (SQLite default). Raising it can cut read overhead on large DBs at the cost of address space. (min 0, max 8192, default 0)")
   }).default({ cache_size_mb: 64, mmap_size_mb: 0 }).describe("SQLite connection tuning for Magic Context's own context.db. These are per-connection PRAGMAs applied at open; they do not change the schema or what is stored."),
   storage: object({
-    enforce_private_permissions: boolean2().default(true).describe("When true (default), Magic Context creates and re-tightens its storage directories to owner-only 0700 and storage files to owner-only 0600. Set false only for a deliberate trusted-group deployment whose operator manages directory, database, WAL/SHM, cache, and RPC file permissions externally; Magic Context then never chmods or supplies restrictive creation modes. USER-LEVEL ONLY — ignored in project config for security. On Windows, POSIX chmod modes are already meaningless, so this setting is a no-op.")
-  }).default({ enforce_private_permissions: true }).describe("Storage permission policy. The default keeps session content and memories owner-private. Disabling enforcement is for trusted shared-group storage managed externally; every group member able to read the storage can read all stored session content and memories."),
+    enforce_private_permissions: boolean2().default(true).describe("When true (default), Magic Context creates and re-tightens its TypeScript-mode storage directories to owner-only 0700 and storage files to owner-only 0600. Set false only for a deliberate trusted-group deployment whose operator manages those files externally; in TypeScript mode Magic Context then skips its own creation modes and recursive tightening. In Rust transform mode, ck-mc's store library always keeps the shared data directory owner-only 0700, regardless of this setting. USER-LEVEL ONLY — ignored in project config for security. On Windows, POSIX chmod modes are already meaningless, so this setting is a no-op.")
+  }).default({ enforce_private_permissions: true }).describe("Storage permission policy. The default keeps session content and memories owner-private. Disabling enforcement is for trusted shared-group storage managed externally; TypeScript mode follows that policy, but Rust transform mode always keeps its shared data directory owner-only because ck-mc's store library enforces it."),
   embedding: EmbeddingConfigSchema.default({
     provider: "local",
     model: DEFAULT_LOCAL_EMBEDDING_MODEL,
@@ -5676,7 +5660,8 @@ var MagicContextConfigSchema = object({
     overlay: boolean2().default(true).describe("Pi only: show the persistent todo overlay above the editor while tasks are active.")
   }).default({ enabled: false, overlay: true }).describe("Pi-only todowrite tool and overlay controls. Pi registers tools and widgets at extension boot, so changing this after /cd requires /reload or restart."),
   pi: PiConfigSchema.describe("Pi-only child-process extension controls. This setting is user-level only; project configuration cannot choose which extensions a user's subagent children load."),
-  smart_drops: boolean2().default(false).describe("Content-aware reclaim of provably-superseded tool output, layered on the existing execute-pass auto-drop. When on: superseded todowrite (keep newest 1), spent ctx_reduce (keep newest 3), and zero-value meta (bash_status, bash_kill, ctx_note read/dismiss) outputs are dropped; older edits to a file are compressed to a filePath-preserving marker while the newest edit per file stays full. Only acts on passes already busting the cache, so it never originates a cache bust. Honors the protected-tag reserve. Experimental: opt-in, default off until cache stability is proven; when off the wire is byte-identical to the positional-only reclaim. Requires a restart."),
+  smart_drops: unknown().optional().describe("Deprecated: ignored. Content-aware supersession reclaim is always on, only on passes already rebuilding the cache. Remove this key; it no longer does anything.").meta({ deprecated: true }),
+  protected_tools: record(string(), number2().int().nonnegative()).default({ ...DEFAULT_PROTECTED_TOOLS }).transform((map) => mergeProtectedTools(map)).describe("Keep each tool's newest N still-active results in every automatic drop lane (issue 621). User and project maps merge over defaults {todowrite: 1, ctx_reduce: 3}; 0 turns protection off. Names are case-insensitive and ignore leading mcp_. Holds even at 95% pressure, with no byte cap: large protected outputs can reach refusal sooner. Queued drops, from the agent or historian publication, are held until newer calls displace the result and a later cache-rebuilding pass applies them. The historian's summary is unaffected; the raw result leaves at the next fold. Frozen strips are unaffected. Changes and rotation never originate a bust; dropped results are never restored."),
   caveman_text_compression: object({
     enabled: boolean2().default(false).describe("Apply deterministic caveman-style text compression to old conversation text. Active for primary sessions when enabled; never for subagents. Compresses user/assistant text in oldest-first tiers: ultra (oldest 20%), full, lite, untouched (newest 40%)."),
     min_chars: number2().min(100).max(1e4).default(500).describe("Text parts shorter than this (characters) stay untouched. Min 100, max 10000. Default: 500.")
@@ -5711,6 +5696,7 @@ var MagicContextConfigSchema = object({
   };
 });
 var LIVE_RELOAD_CONFIG_PATHS = [
+  "cache_ttl",
   "mural.model",
   "toast_duration_ms",
   "historian.opencode.model",
@@ -5729,6 +5715,7 @@ var LIVE_RELOAD_CONFIG_PATHS = [
   "commit_cluster_trigger.enabled",
   "commit_cluster_trigger.min_clusters",
   "memory.auto_promote",
+  "dreamer.disable",
   "dreamer.maxTokens",
   "dreamer.opencode.model",
   "dreamer.opencode.fallback_models",
@@ -5781,3336 +5768,4 @@ function deriveDefaultProtectedTokens(usableSoft) {
   return Math.min(64000, Math.max(lowerBound, target));
 }
 
-// src/features/magic-context/memory/embedding-failure.ts
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error ?? "unknown error");
-}
-function nestedMessages(error) {
-  const messages = [errorMessage(error)];
-  if (error && typeof error === "object" && "cause" in error) {
-    const cause = error.cause;
-    if (cause !== undefined)
-      messages.push(...nestedMessages(cause));
-  }
-  return messages;
-}
-function safeErrorDetail(message) {
-  return message.replace(/https?:\/\/[^\s"']+/gi, "<remote URL>").replace(/\/(?:Users|home)\/[^/\s]+/g, "~").replace(/\s+/g, " ").trim().slice(0, 240);
-}
-function hasAny(messages, patterns) {
-  return messages.some((message) => {
-    const lower = message.toLowerCase();
-    return patterns.some((pattern) => lower.includes(pattern));
-  });
-}
-function classifyLocalEmbeddingFailure(error, context = {}) {
-  const primaryMessages = nestedMessages(error);
-  const nativeMessages = context.nativeError === undefined ? [] : nestedMessages(context.nativeError);
-  if (hasAny(primaryMessages, [
-    "mc_embedding_fs_unavailable",
-    "file system cache is not available"
-  ]) || context.usesWasm && hasAny(primaryMessages, ["unable to get model file path or buffer"])) {
-    return {
-      class: "local_fs_unavailable",
-      reason: "the WASM model cache cannot access the Node filesystem",
-      retryable: false
-    };
-  }
-  if (hasAny(primaryMessages, [
-    "failed to fetch",
-    "fetch failed",
-    "network error",
-    "enotfound",
-    "econnreset",
-    "econnrefused",
-    "certificate",
-    "unable to load file",
-    "unauthorized access to file",
-    "forbidden access to file",
-    "not found at"
-  ]) || primaryMessages.some((message) => /\bHTTP\s+[45]\d\d\b/i.test(message))) {
-    return {
-      class: "local_download_failure",
-      reason: `the embedding model download failed: ${safeErrorDetail(primaryMessages[0])}`,
-      retryable: true
-    };
-  }
-  const bindingMessages = [...primaryMessages, ...nativeMessages];
-  if (hasAny(bindingMessages, [
-    "onnxruntime_binding.node",
-    "cannot find package 'onnxruntime-node'",
-    'cannot find package "onnxruntime-node"',
-    "cannot find module 'onnxruntime-node'",
-    'cannot find module "onnxruntime-node"',
-    "could not resolve: onnxruntime-node"
-  ])) {
-    const platform = context.platform ?? process.platform;
-    const arch = context.arch ?? process.arch;
-    return {
-      class: "local_binding_missing",
-      reason: platform === "darwin" && arch === "x64" ? "onnxruntime-node has no darwin/x64 native binding and the WASM fallback could not complete" : `onnxruntime-node has no usable native binding for ${platform}/${arch} and the WASM fallback could not complete`,
-      retryable: false
-    };
-  }
-  return {
-    class: "local_runtime_error",
-    reason: `the local embedding runtime failed: ${safeErrorDetail(primaryMessages[0])}`,
-    retryable: false
-  };
-}
-function dominantEmbeddingFailure(failures) {
-  const counts = new Map;
-  for (const failure of failures) {
-    const key = `${failure.class}\x00${failure.reason}`;
-    const current = counts.get(key);
-    if (current)
-      current.count += 1;
-    else
-      counts.set(key, { failure, count: 1 });
-  }
-  let dominant;
-  for (const candidate of counts.values()) {
-    if (!dominant || candidate.count > dominant.count)
-      dominant = candidate;
-  }
-  return dominant?.failure;
-}
-
-// src/features/magic-context/memory/embedding-model-match.ts
-function parseEmbeddingModel(model) {
-  const lastColon = model.lastIndexOf(":");
-  if (lastColon > model.lastIndexOf("/")) {
-    return { base: model.slice(0, lastColon), tag: model.slice(lastColon + 1) };
-  }
-  return { base: model };
-}
-function normalizeEmbeddingModelId(model) {
-  return parseEmbeddingModel(model.trim().toLowerCase()).base;
-}
-function matchNormalizedEmbeddingModels(a, b) {
-  if (a.length === 0 || b.length === 0)
-    return true;
-  if (a === b)
-    return true;
-  const longer = a.length >= b.length ? a : b;
-  const shorter = a.length >= b.length ? b : a;
-  const isBoundary = (ch) => ch === "-" || ch === "/";
-  if (longer.startsWith(shorter) && isBoundary(longer.charAt(shorter.length)))
-    return true;
-  if (longer.endsWith(shorter) && isBoundary(longer.charAt(longer.length - shorter.length - 1)))
-    return true;
-  return false;
-}
-function embeddingModelsMatch(served, requested) {
-  const servedNormalized = served.trim().toLowerCase();
-  const requestedNormalized = requested.trim().toLowerCase();
-  const servedModel = parseEmbeddingModel(servedNormalized);
-  const requestedModel = parseEmbeddingModel(requestedNormalized);
-  if (servedModel.tag !== undefined && requestedModel.tag !== undefined && servedModel.tag !== requestedModel.tag) {
-    return false;
-  }
-  return matchNormalizedEmbeddingModels(servedModel.base, requestedModel.base);
-}
-var QWEN3_QUERY_INSTRUCTION = `Instruct: Given a web search query, retrieve relevant passages that answer the query
-Query: `;
-var INSTRUCT_WEB_SEARCH_QUERY_PREFIX = QWEN3_QUERY_INSTRUCTION;
-var EMBEDDING_MODEL_PREFIX_FAMILIES = [
-  {
-    family: "qwen3-embedding",
-    basenamePattern: /^qwen3-embedding(?:-|$)/,
-    prefixes: { queryPrefix: QWEN3_QUERY_INSTRUCTION, documentPrefix: "" }
-  },
-  {
-    family: "gte-qwen-instruct",
-    basenamePattern: /^gte-qwen.*-instruct(?:-|$)/,
-    prefixes: { queryPrefix: INSTRUCT_WEB_SEARCH_QUERY_PREFIX, documentPrefix: "" }
-  },
-  {
-    family: "e5-instruct",
-    basenamePattern: /^(?:multilingual-)?e5-.*-instruct(?:-|$)/,
-    prefixes: { queryPrefix: INSTRUCT_WEB_SEARCH_QUERY_PREFIX, documentPrefix: "" }
-  },
-  {
-    family: "nomic-embed-text",
-    basenamePattern: /^nomic-embed-text(?:-|$)/,
-    prefixes: { queryPrefix: "search_query: ", documentPrefix: "search_document: " }
-  }
-];
-function modelBasename(model) {
-  const normalized = normalizeEmbeddingModelId(model);
-  return normalized.slice(normalized.lastIndexOf("/") + 1);
-}
-function resolveEmbeddingTextPrefixes(model, queryInstruction, documentPrefix) {
-  const family = EMBEDDING_MODEL_PREFIX_FAMILIES.find(({ basenamePattern }) => basenamePattern.test(modelBasename(model)));
-  return {
-    queryPrefix: queryInstruction === false ? "" : queryInstruction !== undefined ? queryInstruction : family?.prefixes.queryPrefix ?? "",
-    documentPrefix: documentPrefix ?? family?.prefixes.documentPrefix ?? ""
-  };
-}
-
-// src/features/magic-context/memory/embedding-synapse.ts
-import { createHash } from "node:crypto";
-
-// ../../node_modules/.bun/@cortexkit+subc-client@0.11.1/node_modules/@cortexkit/subc-client/dist/client.js
-import { promises as fs2 } from "node:fs";
-import { debuglog } from "node:util";
-
-// ../../node_modules/.bun/@cortexkit+subc-client@0.11.1/node_modules/@cortexkit/subc-client/dist/auth.js
-import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
-
-// ../../node_modules/.bun/@cortexkit+subc-client@0.11.1/node_modules/@cortexkit/subc-client/dist/socket.js
-import net from "node:net";
-
-// ../../node_modules/.bun/@cortexkit+subc-client@0.11.1/node_modules/@cortexkit/subc-client/dist/envelope.js
-var PROTOCOL_VERSION = 2;
-var HEADER_LEN = 21;
-var FROZEN_PREFIX_LEN = 5;
-var MAX_FRAME_BODY_LEN = 64 * 1024 * 1024;
-var FrameType;
-(function(FrameType) {
-  FrameType[FrameType["Request"] = 0] = "Request";
-  FrameType[FrameType["Response"] = 1] = "Response";
-  FrameType[FrameType["Push"] = 2] = "Push";
-  FrameType[FrameType["StreamData"] = 3] = "StreamData";
-  FrameType[FrameType["StreamEnd"] = 4] = "StreamEnd";
-  FrameType[FrameType["Error"] = 5] = "Error";
-  FrameType[FrameType["Cancel"] = 6] = "Cancel";
-  FrameType[FrameType["Ping"] = 7] = "Ping";
-  FrameType[FrameType["Pong"] = 8] = "Pong";
-  FrameType[FrameType["Hello"] = 9] = "Hello";
-  FrameType[FrameType["HelloAck"] = 10] = "HelloAck";
-  FrameType[FrameType["Goodbye"] = 11] = "Goodbye";
-})(FrameType || (FrameType = {}));
-var FRAME_TYPE_MAX = FrameType.Goodbye;
-function isPureHeader(ty) {
-  return ty === FrameType.Cancel || ty === FrameType.Ping || ty === FrameType.Pong || ty === FrameType.Goodbye;
-}
-var Priority;
-(function(Priority) {
-  Priority[Priority["Passive"] = 0] = "Passive";
-  Priority[Priority["Interactive"] = 1] = "Interactive";
-  Priority[Priority["Background"] = 2] = "Background";
-})(Priority || (Priority = {}));
-var AdmissionClass;
-(function(AdmissionClass) {
-  AdmissionClass[AdmissionClass["Normal"] = 0] = "Normal";
-  AdmissionClass[AdmissionClass["Expedite"] = 1] = "Expedite";
-  AdmissionClass[AdmissionClass["Sheddable"] = 2] = "Sheddable";
-})(AdmissionClass || (AdmissionClass = {}));
-var FLAG_BINARY = 1;
-var FLAG_PRIORITY_MASK = 6;
-var FLAG_PRIORITY_SHIFT = 1;
-var FLAG_LAST = 8;
-var FLAG_ADMISSION_MASK = 48;
-var FLAG_ADMISSION_SHIFT = 4;
-var FLAG_RESERVED_MASK = 128;
-function buildFlags(binary, priority, last, admissionClass = AdmissionClass.Normal) {
-  let flags = 0;
-  if (binary)
-    flags |= FLAG_BINARY;
-  flags |= priority << FLAG_PRIORITY_SHIFT;
-  if (last)
-    flags |= FLAG_LAST;
-  flags |= admissionClass << FLAG_ADMISSION_SHIFT;
-  return flags;
-}
-function hasBinary(flags) {
-  return (flags & FLAG_BINARY) !== 0;
-}
-function encodeHeader(header) {
-  const buffer = new Uint8Array(HEADER_LEN);
-  const view = new DataView(buffer.buffer);
-  view.setUint32(0, header.len, true);
-  buffer[4] = header.ver;
-  buffer[5] = header.ty;
-  buffer[6] = header.flags;
-  view.setUint16(7, header.channel, true);
-  view.setUint32(9, header.epoch, true);
-  view.setBigUint64(13, header.corr, true);
-  return buffer;
-}
-
-class DecodeError extends Error {
-  code;
-  constructor(message, code) {
-    super(message);
-    this.code = code;
-    this.name = "DecodeError";
-  }
-}
-function validateHeaderFields(header) {
-  const len = header.len >>> 0;
-  const ver = header.ver >>> 0 & 255;
-  const typeByte = header.ty >>> 0 & 255;
-  const flags = header.flags >>> 0 & 255;
-  const channel = header.channel >>> 0 & 65535;
-  const epoch = header.epoch >>> 0;
-  BigInt.asUintN(64, header.corr);
-  if (ver !== PROTOCOL_VERSION)
-    throw new DecodeError(`unsupported envelope version ${ver}`, "unsupported_version");
-  if (typeByte > FRAME_TYPE_MAX)
-    throw new DecodeError(`unknown frame type byte ${typeByte}`, "unknown_frame_type");
-  const ty = typeByte;
-  if ((flags & FLAG_RESERVED_MASK) !== 0) {
-    throw new DecodeError(`reserved flag bits set in flags 0b${flags.toString(2).padStart(8, "0")}`, "reserved_flag_bits");
-  }
-  if ((flags & FLAG_PRIORITY_MASK) >> FLAG_PRIORITY_SHIFT === 3) {
-    throw new DecodeError(`reserved priority bits set in flags 0b${flags.toString(2).padStart(8, "0")}`, "reserved_priority_bits");
-  }
-  const admission = (flags & FLAG_ADMISSION_MASK) >> FLAG_ADMISSION_SHIFT;
-  if (admission === 3) {
-    throw new DecodeError(`reserved admission class set in flags 0b${flags.toString(2).padStart(8, "0")}`, "reserved_admission_class");
-  }
-  if (admission === AdmissionClass.Sheddable && ty !== FrameType.Push && ty !== FrameType.StreamData) {
-    throw new DecodeError(`SHEDDABLE admission class is illegal on ${FrameType[ty]} in flags 0b${flags.toString(2).padStart(8, "0")}`, "sheddable_illegal_frame_type");
-  }
-  if (channel === 0 && epoch !== 0) {
-    throw new DecodeError(`control channel carried nonzero epoch ${epoch}`, "nonzero_epoch_on_control_channel");
-  }
-  if (isPureHeader(ty) && len !== 0) {
-    throw new DecodeError(`pure-header frame ${FrameType[ty]} declared non-zero body length ${len}`, "pure_header_frame_with_body");
-  }
-}
-function decodeHeader(bytes) {
-  if (bytes.length < FROZEN_PREFIX_LEN) {
-    throw new DecodeError(`header shorter than frozen prefix: have ${bytes.length} bytes`, "too_short_for_prefix");
-  }
-  const ver = bytes[4];
-  if (ver !== PROTOCOL_VERSION)
-    throw new DecodeError(`unsupported envelope version ${ver}`, "unsupported_version");
-  if (bytes.length < HEADER_LEN) {
-    throw new DecodeError(`header too short for version: have ${bytes.length} bytes, need ${HEADER_LEN}`, "too_short_for_header");
-  }
-  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  const len = view.getUint32(0, true);
-  const typeByte = bytes[5];
-  if (typeByte > FRAME_TYPE_MAX)
-    throw new DecodeError(`unknown frame type byte ${typeByte}`, "unknown_frame_type");
-  const ty = typeByte;
-  const flags = bytes[6];
-  if ((flags & FLAG_RESERVED_MASK) !== 0) {
-    throw new DecodeError(`reserved flag bits set in flags 0b${flags.toString(2).padStart(8, "0")}`, "reserved_flag_bits");
-  }
-  if ((flags & FLAG_PRIORITY_MASK) >> FLAG_PRIORITY_SHIFT === 3) {
-    throw new DecodeError(`reserved priority bits set in flags 0b${flags.toString(2).padStart(8, "0")}`, "reserved_priority_bits");
-  }
-  const admission = (flags & FLAG_ADMISSION_MASK) >> FLAG_ADMISSION_SHIFT;
-  if (admission === 3) {
-    throw new DecodeError(`reserved admission class set in flags 0b${flags.toString(2).padStart(8, "0")}`, "reserved_admission_class");
-  }
-  if (admission === AdmissionClass.Sheddable && ty !== FrameType.Push && ty !== FrameType.StreamData) {
-    throw new DecodeError(`SHEDDABLE admission class is illegal on ${FrameType[ty]} in flags 0b${flags.toString(2).padStart(8, "0")}`, "sheddable_illegal_frame_type");
-  }
-  const channel = view.getUint16(7, true);
-  const epoch = view.getUint32(9, true);
-  if (channel === 0 && epoch !== 0) {
-    throw new DecodeError(`control channel carried nonzero epoch ${epoch}`, "nonzero_epoch_on_control_channel");
-  }
-  if (isPureHeader(ty) && len !== 0) {
-    throw new DecodeError(`pure-header frame ${FrameType[ty]} declared non-zero body length ${len}`, "pure_header_frame_with_body");
-  }
-  return { len, ver, ty, flags, channel, epoch, corr: view.getBigUint64(13, true) };
-}
-function buildFrame(ty, flags, channel, epoch, corr, body) {
-  return buildFrameWithVersion(PROTOCOL_VERSION, ty, flags, channel, epoch, corr, body);
-}
-function buildFrameWithVersion(ver, ty, flags, channel, epoch, corr, body) {
-  if (body.length > MAX_FRAME_BODY_LEN) {
-    throw new DecodeError(`frame body ${body.length} exceeds max ${MAX_FRAME_BODY_LEN}`, "frame_body_too_large");
-  }
-  const header = { len: body.length, ver, ty, flags, channel, epoch, corr };
-  validateHeaderFields(header);
-  return { header, body };
-}
-function encodeFrame(frame) {
-  if (frame.header.len !== frame.body.length) {
-    throw new DecodeError(`frame header length ${frame.header.len} does not match body length ${frame.body.length}`, "frame_length_mismatch");
-  }
-  const header = encodeHeader(frame.header);
-  const output = new Uint8Array(header.length + frame.body.length);
-  output.set(header, 0);
-  output.set(frame.body, header.length);
-  return output;
-}
-
-// ../../node_modules/.bun/@cortexkit+subc-client@0.11.1/node_modules/@cortexkit/subc-client/dist/socket.js
-class SocketClosedError extends Error {
-}
-
-class SocketTimeoutError extends Error {
-}
-
-class SocketWriteNotQueuedError extends Error {
-  cause;
-  constructor(message, cause) {
-    super(message);
-    this.cause = cause;
-  }
-}
-
-class SocketWriteQueuedError extends Error {
-  cause;
-  constructor(message, cause) {
-    super(message);
-    this.cause = cause;
-  }
-}
-function toWriteBuffer(bytes) {
-  return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-}
-var WRITE_BORROWED = Symbol("subc.socket.writeBorrowed");
-var WRITE_TRACKED_BORROWED = Symbol("subc.socket.writeTrackedBorrowed");
-function writeBorrowed(socket, bytes, deadlineMs) {
-  const borrowed = socket[WRITE_BORROWED];
-  return borrowed ? borrowed.call(socket, bytes, deadlineMs) : socket.write(bytes, deadlineMs);
-}
-function writeTrackedBorrowed(socket, bytes, deadlineMs) {
-  const borrowed = socket[WRITE_TRACKED_BORROWED];
-  return borrowed ? borrowed.call(socket, bytes, deadlineMs) : socket.writeTracked(bytes, deadlineMs);
-}
-
-class SubcSocket {
-  sock;
-  chunks = [];
-  buffered = 0;
-  waiter = null;
-  closedErr = null;
-  bufferedBytes() {
-    return this.buffered;
-  }
-  constructor(sock) {
-    this.sock = sock;
-    sock.on("data", (chunk) => {
-      this.chunks.push(chunk);
-      this.buffered += chunk.length;
-      this.tryServe();
-    });
-    const fail = (err) => {
-      if (!this.closedErr)
-        this.closedErr = err;
-      this.tryServe();
-    };
-    sock.on("error", (err) => fail(err instanceof Error ? err : new Error(String(err))));
-    sock.on("end", () => fail(new SocketClosedError("subc closed the connection")));
-    sock.on("close", () => fail(new SocketClosedError("subc connection closed")));
-  }
-  localPort() {
-    return this.sock.localPort ?? null;
-  }
-  static connect(host, port, deadlineMs) {
-    return new Promise((resolve, reject) => {
-      const sock = net.connect({ host, port });
-      sock.setNoDelay(true);
-      const timer = setTimeout(() => {
-        sock.destroy();
-        reject(new SocketTimeoutError(`timed out connecting to ${host}:${port}`));
-      }, Math.max(0, deadlineMs - Date.now()));
-      sock.once("connect", () => {
-        clearTimeout(timer);
-        resolve(new SubcSocket(sock));
-      });
-      sock.once("error", (err) => {
-        clearTimeout(timer);
-        reject(err);
-      });
-    });
-  }
-  async readFrame(headerDeadlineMs, bodyDeadline, onHeader) {
-    const prefix = await this.readExact(FROZEN_PREFIX_LEN, headerDeadlineMs);
-    const version = prefix[4];
-    if (version !== PROTOCOL_VERSION)
-      throw new DecodeError(`unsupported envelope version ${version}`, "unsupported_version");
-    const remainder = await this.readExact(HEADER_LEN - FROZEN_PREFIX_LEN, headerDeadlineMs);
-    const headerBytes = new Uint8Array(HEADER_LEN);
-    headerBytes.set(prefix);
-    headerBytes.set(remainder, FROZEN_PREFIX_LEN);
-    const header = decodeHeader(headerBytes);
-    if (header.len > MAX_FRAME_BODY_LEN) {
-      throw new DecodeError(`frame body ${header.len} exceeds max ${MAX_FRAME_BODY_LEN}`, "frame_body_too_large");
-    }
-    onHeader?.();
-    const bodyDeadlineMs = typeof bodyDeadline === "number" ? bodyDeadline : Date.now() + bodyDeadline.afterHeaderMs;
-    const body = header.len === 0 ? new Uint8Array(0) : await this.readExact(header.len, bodyDeadlineMs);
-    return { header, body };
-  }
-  readExact(n, deadlineMs) {
-    if (this.waiter) {
-      return Promise.reject(new Error("concurrent readExact is not supported"));
-    }
-    if (n === 0)
-      return Promise.resolve(new Uint8Array(0));
-    return new Promise((resolve, reject) => {
-      let timer = null;
-      if (Number.isFinite(deadlineMs)) {
-        const remaining = deadlineMs - Date.now();
-        if (remaining <= 0) {
-          reject(new SocketTimeoutError(`timed out waiting for ${n} bytes`));
-          return;
-        }
-        timer = setTimeout(() => {
-          this.waiter = null;
-          reject(new SocketTimeoutError(`timed out waiting for ${n} bytes`));
-        }, remaining);
-      }
-      this.waiter = { need: n, resolve, reject, timer };
-      this.tryServe();
-    });
-  }
-  async write(bytes, deadlineMs) {
-    await this.writeBuffer(Buffer.from(bytes), deadlineMs);
-  }
-  writeTracked(bytes, deadlineMs) {
-    return this.writeTrackedBuffer(Buffer.from(bytes), deadlineMs);
-  }
-  async[WRITE_BORROWED](bytes, deadlineMs) {
-    await this.writeBuffer(toWriteBuffer(bytes), deadlineMs);
-  }
-  [WRITE_TRACKED_BORROWED](bytes, deadlineMs) {
-    return this.writeTrackedBuffer(toWriteBuffer(bytes), deadlineMs);
-  }
-  async writeBuffer(buffer, deadlineMs) {
-    try {
-      await this.writeTrackedBuffer(buffer, deadlineMs).completed;
-    } catch (err) {
-      if (err instanceof SocketWriteNotQueuedError || err instanceof SocketWriteQueuedError) {
-        throw err.cause ?? err;
-      }
-      throw err;
-    }
-  }
-  writeTrackedBuffer(buffer, deadlineMs) {
-    if (this.closedErr) {
-      return {
-        queued: false,
-        completed: Promise.reject(new SocketWriteNotQueuedError("subc socket was closed before bytes could be queued", this.closedErr))
-      };
-    }
-    let queued = false;
-    let settled = false;
-    let timer = null;
-    const completed = new Promise((resolve, reject) => {
-      const settle = (run) => {
-        if (settled)
-          return;
-        settled = true;
-        if (timer)
-          clearTimeout(timer);
-        run();
-      };
-      const remaining = deadlineMs - Date.now();
-      if (remaining <= 0) {
-        settle(() => reject(new SocketWriteNotQueuedError("timed out before bytes could be queued to subc", new SocketTimeoutError("timed out writing to subc"))));
-        return;
-      }
-      timer = setTimeout(() => {
-        const timeout = new SocketTimeoutError("timed out writing to subc");
-        settle(() => reject(queued ? new SocketWriteQueuedError("timed out after bytes were handed to the subc socket", timeout) : new SocketWriteNotQueuedError("timed out before bytes could be queued to subc", timeout)));
-      }, remaining);
-      try {
-        this.sock.write(buffer, (err) => {
-          settle(() => {
-            if (err) {
-              reject(new SocketWriteQueuedError("subc socket reported a write error after bytes were handed to the socket", err instanceof Error ? err : new Error(String(err))));
-            } else {
-              resolve();
-            }
-          });
-        });
-        queued = true;
-      } catch (err) {
-        settle(() => reject(new SocketWriteNotQueuedError("subc socket write threw before bytes could be queued", err instanceof Error ? err : new Error(String(err)))));
-      }
-    });
-    return { queued, completed };
-  }
-  close() {
-    this.sock.destroy();
-  }
-  tryServe() {
-    const w = this.waiter;
-    if (!w)
-      return;
-    if (this.buffered >= w.need) {
-      const out = this.take(w.need);
-      this.waiter = null;
-      if (w.timer)
-        clearTimeout(w.timer);
-      w.resolve(out);
-      return;
-    }
-    if (this.closedErr) {
-      this.waiter = null;
-      if (w.timer)
-        clearTimeout(w.timer);
-      w.reject(this.closedErr);
-    }
-  }
-  take(n) {
-    const out = Buffer.allocUnsafe(n);
-    let off = 0;
-    while (off < n) {
-      const head = this.chunks[0];
-      const want = n - off;
-      if (head.length <= want) {
-        head.copy(out, off);
-        off += head.length;
-        this.chunks.shift();
-      } else {
-        head.copy(out, off, 0, want);
-        this.chunks[0] = head.subarray(want);
-        off += want;
-      }
-    }
-    this.buffered -= n;
-    return out;
-  }
-}
-
-// ../../node_modules/.bun/@cortexkit+subc-client@0.11.1/node_modules/@cortexkit/subc-client/dist/auth.js
-var NONCE_LEN = 32;
-var MAX_AUTH_MESSAGE_LEN = 4096;
-var SERVER_PROOF_DOMAIN = "subc-server-v1";
-var CLIENT_AUTH_DOMAIN = "subc-client-v1";
-var DEFAULT_CLIENT_ROLE = "client";
-
-class AuthError extends Error {
-}
-function computeProof(key, domain, clientNonce, serverNonce, daemonId) {
-  const mac = createHmac("sha256", Buffer.from(key));
-  mac.update(Buffer.from(domain, "utf8"));
-  mac.update(Buffer.from(clientNonce));
-  mac.update(Buffer.from(serverNonce));
-  mac.update(Buffer.from(daemonId));
-  return new Uint8Array(mac.digest());
-}
-function constantTimeEq(a, b) {
-  if (a.length !== b.length)
-    return false;
-  return timingSafeEqual(Buffer.from(a), Buffer.from(b));
-}
-async function writeMessage(sock, value, deadlineMs) {
-  const json = Buffer.from(JSON.stringify(value), "utf8");
-  if (json.length > MAX_AUTH_MESSAGE_LEN) {
-    throw new AuthError(`auth message too large: ${json.length} > ${MAX_AUTH_MESSAGE_LEN}`);
-  }
-  const lenPrefix = new Uint8Array(4);
-  new DataView(lenPrefix.buffer).setUint32(0, json.length, true);
-  await writeBorrowed(sock, lenPrefix, deadlineMs);
-  await writeBorrowed(sock, json, deadlineMs);
-}
-async function readMessage(sock, deadlineMs) {
-  const lenBytes = await sock.readExact(4, deadlineMs);
-  const len = new DataView(lenBytes.buffer, lenBytes.byteOffset, 4).getUint32(0, true);
-  if (len > MAX_AUTH_MESSAGE_LEN) {
-    throw new AuthError(`auth message too large: ${len} > ${MAX_AUTH_MESSAGE_LEN}`);
-  }
-  const body = len === 0 ? new Uint8Array(0) : await sock.readExact(len, deadlineMs);
-  try {
-    return JSON.parse(Buffer.from(body).toString("utf8"));
-  } catch (err) {
-    throw new AuthError(`auth message JSON decode failed: ${String(err)}`);
-  }
-}
-function authBytes(value, field) {
-  if (!Array.isArray(value)) {
-    throw new AuthError(`auth field '${field}' must be a byte array`);
-  }
-  for (const byte of value) {
-    if (typeof byte !== "number" || !Number.isInteger(byte) || byte < 0 || byte > 255) {
-      throw new AuthError(`auth field '${field}' has invalid byte ${String(byte)}`);
-    }
-  }
-  return Uint8Array.from(value);
-}
-async function authenticateClient(sock, conn, deadlineMs) {
-  const clientNonce = new Uint8Array(randomBytes(NONCE_LEN));
-  await writeMessage(sock, { client_nonce: Array.from(clientNonce), role: DEFAULT_CLIENT_ROLE }, deadlineMs);
-  const proof = await readMessage(sock, deadlineMs);
-  const serverNonce = authBytes(proof.server_nonce, "server_nonce");
-  const daemonId = authBytes(proof.daemon_id, "daemon_id");
-  const serverProof = authBytes(proof.server_proof, "server_proof");
-  const expected = computeProof(conn.key, SERVER_PROOF_DOMAIN, clientNonce, serverNonce, daemonId);
-  if (!constantTimeEq(expected, serverProof)) {
-    throw new AuthError("server proof mismatch — wrong key or impostor daemon");
-  }
-  if (!constantTimeEq(daemonId, conn.daemonId)) {
-    throw new AuthError("daemon id mismatch — connection file points at a different daemon");
-  }
-  const clientAuth = computeProof(conn.key, CLIENT_AUTH_DOMAIN, clientNonce, serverNonce, daemonId);
-  await writeMessage(sock, { client_auth: Array.from(clientAuth) }, deadlineMs);
-}
-
-// ../../node_modules/.bun/@cortexkit+subc-client@0.11.1/node_modules/@cortexkit/subc-client/dist/connection-file.js
-import { promises as fs } from "node:fs";
-var SCHEMA_VERSION = 1;
-var MIN_KEY_LEN = 32;
-var DAEMON_ID_LEN = 16;
-
-class ConnectionFileError extends Error {
-}
-function toBytes(value, field) {
-  if (!Array.isArray(value)) {
-    throw new ConnectionFileError(`connection file field '${field}' must be a JSON array of bytes`);
-  }
-  for (const byte of value) {
-    if (typeof byte !== "number" || !Number.isInteger(byte) || byte < 0 || byte > 255) {
-      throw new ConnectionFileError(`connection file field '${field}' has invalid byte ${String(byte)}`);
-    }
-  }
-  return Uint8Array.from(value);
-}
-function validate(info) {
-  if (info.schema !== SCHEMA_VERSION) {
-    throw new ConnectionFileError(`unsupported connection file schema ${info.schema}; expected ${SCHEMA_VERSION}`);
-  }
-  if (info.endpoints.length === 0) {
-    throw new ConnectionFileError("connection file must include at least one endpoint");
-  }
-  if (info.key.length < MIN_KEY_LEN) {
-    throw new ConnectionFileError(`connection file key is too short: ${info.key.length} bytes, need at least ${MIN_KEY_LEN}`);
-  }
-  if (info.daemonId.length !== DAEMON_ID_LEN) {
-    throw new ConnectionFileError(`connection file daemon_id must be ${DAEMON_ID_LEN} bytes, got ${info.daemonId.length}`);
-  }
-}
-async function verifyOwnerOnly(path) {
-  if (process.platform === "win32")
-    return;
-  const stat = await fs.stat(path);
-  const mode = stat.mode & 511;
-  if ((mode & 63) !== 0) {
-    throw new ConnectionFileError(`connection file ${path} has insecure permissions 0o${mode.toString(8)}; expected owner-only 0600`);
-  }
-}
-async function readConnectionFile(path) {
-  await verifyOwnerOnly(path);
-  const raw = await fs.readFile(path, "utf8");
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch (err) {
-    throw new ConnectionFileError(`connection file JSON read failed for ${path}: ${String(err)}`);
-  }
-  const wireVersion = parsed.wire_version;
-  if (wireVersion !== undefined && wireVersion !== PROTOCOL_VERSION) {
-    throw new ConnectionFileError(`connection file wire_version ${String(wireVersion)} but this client speaks ${PROTOCOL_VERSION}; the client library must be upgraded`);
-  }
-  const endpointsRaw = parsed.endpoints;
-  if (!Array.isArray(endpointsRaw)) {
-    throw new ConnectionFileError("connection file 'endpoints' must be an array");
-  }
-  const endpoints = endpointsRaw.map((e) => {
-    const ep = e;
-    if (typeof ep.host !== "string" || typeof ep.port !== "number") {
-      throw new ConnectionFileError("connection file endpoint must be { host: string, port: number }");
-    }
-    return { host: ep.host, port: ep.port };
-  });
-  const info = {
-    schema: parsed.schema,
-    endpoints,
-    key: toBytes(parsed.key, "key"),
-    daemonId: toBytes(parsed.daemon_id, "daemon_id"),
-    pid: parsed.pid,
-    daemonVer: parsed.daemon_ver ?? ""
-  };
-  validate(info);
-  return info;
-}
-
-// ../../node_modules/.bun/@cortexkit+subc-client@0.11.1/node_modules/@cortexkit/subc-client/dist/route-handle.js
-var connectionToken = new WeakMap;
-
-class RouteHandle {
-  channel;
-  epoch;
-  constructor(channel, epoch, token) {
-    if (!Number.isInteger(channel) || channel <= 0 || channel > 65535) {
-      throw new RangeError(`route channel must be an integer in 1..65535, got ${channel}`);
-    }
-    if (!Number.isInteger(epoch) || epoch <= 0 || epoch > 4294967295) {
-      throw new RangeError(`route epoch must be an integer in 1..4294967295, got ${epoch}`);
-    }
-    this.channel = channel;
-    this.epoch = epoch;
-    connectionToken.set(this, token);
-    Object.freeze(this);
-  }
-  static create(channel, epoch, token) {
-    return new RouteHandle(channel, epoch, token);
-  }
-}
-function createRouteHandle(channel, epoch, token) {
-  const factory = RouteHandle;
-  return factory.create(channel, epoch, token);
-}
-
-class StaleRouteHandleError extends Error {
-  handle;
-  code = "stale_route_handle";
-  constructor(handle) {
-    super(`route handle (${handle.channel}, ${handle.epoch}) is not live on the current connection`);
-    this.handle = handle;
-    this.name = "StaleRouteHandleError";
-  }
-}
-function newConnectionToken() {
-  return Object.freeze({});
-}
-function belongsToConnection(handle, token) {
-  return connectionToken.get(handle) === token;
-}
-function sameRouteHandle(left, right) {
-  return left === right;
-}
-
-// ../../node_modules/.bun/@cortexkit+subc-client@0.11.1/node_modules/@cortexkit/subc-client/dist/client.js
-var debug = debuglog("subc-client");
-var DEFAULT_HANDSHAKE_TIMEOUT_MS = 1e4;
-var DEFAULT_REQUEST_TIMEOUT_MS = 30000;
-var TIMEOUT_ARBITRATION_GRACE_MS = 50;
-var LIVENESS_PROBE_WINDOW_MS = 2000;
-var REQUEST_DEADLINE_MARKER = "request_deadline";
-var DEADLINE_NO_DROP_CODE = "deadline_exceeded_no_drop_observed";
-var ROUTE_OPEN_RETRY_DEADLINE_MS = 30000;
-var BODY_READ_TIMEOUT_MS = 30000;
-var EMPTY_BODY = new Uint8Array(0);
-var DEFAULT_MANAGED_TARGET_KIND = "management_surface";
-var SUBC_MODULE_ID_ENV = "SUBC_MODULE_ID";
-var SUBC_LAUNCH_NONCE_ENV = "SUBC_LAUNCH_NONCE";
-var DEFAULT_RECONNECT_BACKOFF = {
-  baseMs: 100,
-  capMs: 2000,
-  maxAttempts: 6
-};
-
-class SubcCallError extends Error {
-  kind;
-  code;
-  cause;
-  constructor(kind, message, code, cause) {
-    super(message);
-    this.kind = kind;
-    this.code = code;
-    this.cause = cause;
-    this.name = "SubcCallError";
-  }
-  get detail() {
-    return this.cause instanceof SubcError ? this.cause.detail : undefined;
-  }
-}
-
-class SubcError extends Error {
-  code;
-  detail;
-  constructor(message, code, detail) {
-    super(message);
-    this.code = code;
-    this.detail = detail;
-  }
-}
-function requireBinaryBody(body) {
-  if (body instanceof Uint8Array)
-    return body;
-  const type = body === null ? "null" : Array.isArray(body) ? "array" : typeof body;
-  throw new SubcError(`binary request body must be a Uint8Array; got ${type}`, "binary_body_required");
-}
-class SubcClient {
-  sock;
-  currentConn;
-  opts;
-  nextCorr = 1n;
-  pending = new Map;
-  lateResponses = new Map;
-  routes = new Map;
-  liveRoutes = new Map;
-  connectionToken = newConnectionToken();
-  ingressEpochDropCount = 0;
-  closedErr = null;
-  closeStarted = false;
-  reconnecting = null;
-  generation = 1;
-  readerActive = false;
-  constructor(sock, currentConn, opts) {
-    this.sock = sock;
-    this.currentConn = currentConn;
-    this.opts = opts;
-    this.readLoop(sock, this.generation);
-  }
-  get conn() {
-    return this.currentConn;
-  }
-  static async connect(opts) {
-    const normalized = normalizeConnectOptions(opts);
-    const opened = await SubcClient.openConnection(normalized);
-    return new SubcClient(opened.sock, opened.conn, normalized);
-  }
-  async catalogList(moduleId) {
-    const body = this.encode(moduleId === undefined ? { op: "catalog.list" } : { op: "catalog.list", module_id: moduleId });
-    const reply = await this.controlRpc(body);
-    const parsed = this.parseJson(reply);
-    return parsed.modules ?? [];
-  }
-  async resolveProvider(capability) {
-    const claimants = await this.resolveProviders(capability);
-    if (claimants.length === 0) {
-      throw new SubcError(`no catalog claimant for capability ${capability}`, "capability_unprovided");
-    }
-    if (claimants.length > 1) {
-      throw new SubcError(`multiple catalog claimants for capability ${capability}: ${claimants.join(", ")}`, "capability_ambiguous");
-    }
-    return claimants[0];
-  }
-  async resolveProviders(capability) {
-    if (!isValidCapabilityIdentifier(capability)) {
-      throw new SubcError(`malformed capability identifier ${JSON.stringify(capability)}`, "invalid_capability_identifier");
-    }
-    const modules = await this.catalogList();
-    return modules.filter((module) => module.capabilities?.provides.includes(capability) ?? false).map((module) => module.module_id).sort();
-  }
-  async routeOpen(target, identity, opts = {}) {
-    const consumerIdentity = routeOpenConsumerIdentity(opts);
-    const consumerCapabilities = opts.consumerCapabilities;
-    const body = this.encode({
-      op: "route.open",
-      target,
-      identity,
-      ...consumerIdentity ? { consumer_identity: consumerIdentity } : {},
-      ...consumerCapabilities !== undefined ? { consumer_capabilities: consumerCapabilities } : {}
-    });
-    let installed = null;
-    const install = (frame) => {
-      if (frame.header.ty !== FrameType.Response)
-        return true;
-      const parsed = this.parseJson(frame);
-      if (typeof parsed.route_channel !== "number" || typeof parsed.route_epoch !== "number") {
-        throw new SubcError(`route.open returned no route handle: ${JSON.stringify(parsed)}`);
-      }
-      installed = this.installRoute(parsed.route_channel, parsed.route_epoch);
-      return true;
-    };
-    const closeLateRoute = (frame) => {
-      if (frame.header.ty !== FrameType.Response)
-        return;
-      try {
-        const parsed = this.parseJson(frame);
-        if (typeof parsed.route_channel !== "number" || typeof parsed.route_epoch !== "number")
-          return;
-        const lateHandle = this.installRoute(parsed.route_channel, parsed.route_epoch);
-        this.failHandle(lateHandle, new SubcError("late route.open was closed", "route_closed"));
-        this.liveRoutes.delete(lateHandle.channel);
-        this.sendRouteGoodbye(lateHandle, true);
-      } catch {
-        this.closeConnectionAfterCleanupFailure();
-      }
-    };
-    await this.controlRpc(body, install, closeLateRoute);
-    if (!installed)
-      throw new SubcError("route.open response was not installed");
-    return installed;
-  }
-  async request(handle, body, opts = {}) {
-    this.assertLiveHandle(handle);
-    const binary = opts.binary ?? false;
-    const bytes = binary ? requireBinaryBody(body) : body instanceof Uint8Array ? body : this.encode(body);
-    const priority = opts.priority ?? Priority.Interactive;
-    const admission = opts.admissionClass ?? AdmissionClass.Normal;
-    const reply = await this.send(handle, bytes, priority, admission, opts.timeoutMs, opts.onProgress, undefined, undefined, binary);
-    return this.decodeReply(reply);
-  }
-  async call(moduleId, method, params, opts = {}) {
-    if (opts.binary) {
-      throw new SubcError("call() builds a JSON body and cannot send a binary request; use callBinary(moduleId, body, opts) with a Uint8Array", "binary_call_requires_call_binary");
-    }
-    const body = params === undefined ? { method } : { method, params };
-    return await this.managedCall(moduleId, body, opts);
-  }
-  async callBinary(moduleId, body, opts = {}) {
-    const bytes = requireBinaryBody(body);
-    return this.managedCall(moduleId, bytes, { ...opts, binary: true });
-  }
-  async managedCall(moduleId, body, opts) {
-    let retriedUnknownChannel = false;
-    for (;; ) {
-      const routeHandle = await this.cachedRouteHandle(moduleId, opts);
-      try {
-        return await this.managedRequest(routeHandle, body, opts);
-      } catch (err) {
-        if (!(err instanceof SubcCallError))
-          throw this.terminalCallError("managed call failed", err);
-        const deadBindCode = err.code === "unknown_channel" || err.code === "stale_route_epoch";
-        if (deadBindCode && !retriedUnknownChannel && !this.closeStarted) {
-          retriedUnknownChannel = true;
-          this.evictRouteHandle(routeHandle);
-          continue;
-        }
-        if (deadBindCode && retriedUnknownChannel) {
-          this.evictRouteHandle(routeHandle);
-        }
-        if (err.kind === "not_sent") {
-          try {
-            await this.reconnectAfterDrop(err);
-          } catch (reconnectErr) {
-            throw this.notSentRecoveryError("managed call was not sent", reconnectErr);
-          }
-          continue;
-        }
-        if (err.kind === "outcome_unknown" && err.code !== DEADLINE_NO_DROP_CODE) {
-          this.scheduleReconnectAfterDrop(err);
-        } else if (err.kind === "outcome_unknown" && err.code === DEADLINE_NO_DROP_CODE) {
-          this.probeLivenessAfterDeadline();
-        }
-        throw err;
-      }
-    }
-  }
-  subscribe(handle, body, onEvent, opts = {}) {
-    this.assertLiveHandle(handle);
-    const bytes = body instanceof Uint8Array ? body : this.encode(body);
-    const priority = opts.priority ?? Priority.Interactive;
-    const admission = opts.admissionClass ?? AdmissionClass.Normal;
-    const corr = this.allocateCorr();
-    const key = pendingKey(handle, corr);
-    let subscriptionPending = null;
-    let resolveClosed = null;
-    const closed = new Promise((resolve, reject) => {
-      if (this.closedErr) {
-        reject(this.closedErr);
-        return;
-      }
-      resolveClosed = resolve;
-      subscriptionPending = {
-        handle,
-        resolve: () => resolve(),
-        reject,
-        onProgress: onEvent,
-        timer: null,
-        subscription: true
-      };
-      this.pending.set(key, subscriptionPending);
-      const frame = buildFrame(FrameType.Request, buildFlags(false, priority, false, admission), handle.channel, handle.epoch, corr, bytes);
-      writeBorrowed(this.sock, encodeFrame(frame), Date.now() + DEFAULT_REQUEST_TIMEOUT_MS).catch((err) => {
-        const pending = this.pending.get(key);
-        if (pending)
-          this.rejectPending(key, pending, err instanceof Error ? err : new SubcError(String(err)));
-      });
-    });
-    let cancelled = false;
-    const unsubscribe = () => {
-      if (cancelled)
-        return;
-      cancelled = true;
-      if (subscriptionPending && resolveClosed)
-        this.settle(key, subscriptionPending, resolveClosed);
-      if (this.isLiveHandle(handle))
-        this.cancel(handle, corr, priority);
-    };
-    return { unsubscribe, closed };
-  }
-  cancel(handle, corr, priority = Priority.Interactive) {
-    this.assertLiveHandle(handle);
-    const cancel = buildFrame(FrameType.Cancel, buildFlags(false, priority, false), handle.channel, handle.epoch, corr, EMPTY_BODY);
-    writeBorrowed(this.sock, encodeFrame(cancel), Date.now() + DEFAULT_REQUEST_TIMEOUT_MS).catch(() => {
-      return;
-    });
-  }
-  async routePoll(handle, kind) {
-    this.assertLiveHandle(handle);
-    const body = this.encode({
-      op: "route.poll",
-      route_channel: handle.channel,
-      route_epoch: handle.epoch,
-      kind
-    });
-    const reply = await this.controlRpc(body, (frame) => {
-      if (frame.header.ty !== FrameType.Response)
-        return true;
-      const parsed = this.parseJson(frame);
-      return parsed.route_channel === handle.channel && parsed.route_epoch === handle.epoch;
-    });
-    return this.parseJson(reply);
-  }
-  async closeRoute(handle, opts = {}) {
-    this.assertLiveHandle(handle);
-    for (const [key, cached] of this.routes) {
-      if (cached.handle && sameRouteHandle(cached.handle, handle)) {
-        cached.closed = true;
-        cached.handle = null;
-        this.routes.delete(key);
-      }
-    }
-    if (opts.drain)
-      await this.drainUnaryOnHandle(handle);
-    this.failHandle(handle, new SubcError("route closed by closeRoute", "route_closed"));
-    if (this.liveRoutes.get(handle.channel) === handle)
-      this.liveRoutes.delete(handle.channel);
-    this.sendRouteGoodbye(handle);
-  }
-  async closeManagedRoute(target, identity, opts = {}) {
-    const key = routeCacheKey(target, identity, routeOpenConsumerIdentity(opts));
-    const cached = this.routes.get(key);
-    if (!cached)
-      return;
-    cached.closed = true;
-    this.routes.delete(key);
-    const handle = cached.handle;
-    cached.handle = null;
-    if (handle)
-      await this.closeRoute(handle, opts);
-  }
-  async closeRouteChannel(handle, opts = {}) {
-    await this.closeRoute(handle, opts);
-  }
-  close() {
-    this.closeStarted = true;
-    this.fail(new SubcError("client closed"));
-    this.sock.close();
-  }
-  drainUnaryOnHandle(handle) {
-    const waiters = [];
-    for (const pending of this.pending.values()) {
-      if (pending.handle === handle && !pending.subscription) {
-        waiters.push(new Promise((resolve) => {
-          const previous = pending.onSettle;
-          pending.onSettle = () => {
-            previous?.();
-            resolve();
-          };
-        }));
-      }
-    }
-    return Promise.all(waiters).then(() => {
-      return;
-    });
-  }
-  sendRouteGoodbye(handle, closeOnQueueFailure = false) {
-    this.assertLiveConnection(handle);
-    if (this.closedErr) {
-      if (closeOnQueueFailure)
-        this.closeConnectionAfterCleanupFailure();
-      return;
-    }
-    const goodbye = buildFrame(FrameType.Goodbye, buildFlags(false, Priority.Interactive, false), handle.channel, handle.epoch, 0n, EMPTY_BODY);
-    const write = writeTrackedBorrowed(this.sock, encodeFrame(goodbye), Date.now() + DEFAULT_REQUEST_TIMEOUT_MS);
-    if (!write.queued && closeOnQueueFailure)
-      this.closeConnectionAfterCleanupFailure();
-    write.completed.catch(() => {
-      if (closeOnQueueFailure && !write.queued)
-        this.closeConnectionAfterCleanupFailure();
-    });
-  }
-  static async openConnection(opts) {
-    const conn = await readConnectionFile(opts.connectionFile);
-    const deadline = Date.now() + (opts.handshakeTimeoutMs ?? DEFAULT_HANDSHAKE_TIMEOUT_MS);
-    const endpoint = conn.endpoints[0];
-    const sock = await SubcSocket.connect(endpoint.host, endpoint.port, deadline);
-    try {
-      await authenticateClient(sock, conn, deadline);
-    } catch (err) {
-      sock.close();
-      throw err;
-    }
-    return { sock, conn };
-  }
-  async controlRpc(body, acceptFrame, onLateResponse) {
-    return this.send(null, body, Priority.Interactive, AdmissionClass.Normal, undefined, undefined, acceptFrame, onLateResponse);
-  }
-  send(handle, body, priority, admission, timeoutMs, onProgress, acceptFrame, onLateResponse, binary = false) {
-    if (handle)
-      this.assertLiveHandle(handle);
-    if (this.closedErr)
-      return Promise.reject(this.closedErr);
-    let corr;
-    try {
-      corr = this.allocateCorr();
-    } catch (error) {
-      return Promise.reject(error);
-    }
-    const key = pendingKey(handle, corr);
-    const channel = handle?.channel ?? 0;
-    const epoch = handle?.epoch ?? 0;
-    const frame = buildFrame(FrameType.Request, buildFlags(binary, priority, false, admission), channel, epoch, corr, body);
-    return new Promise((resolve, reject) => {
-      const ms = timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
-      const pending = {
-        handle,
-        resolve,
-        reject,
-        onProgress,
-        timer: null,
-        acceptFrame,
-        onLateResponse
-      };
-      pending.timer = setTimeout(() => this.arbitrateTimeout(key, pending, channel, corr, ms), ms);
-      this.pending.set(key, pending);
-      writeBorrowed(this.sock, encodeFrame(frame), Date.now() + ms).catch((error) => {
-        const current = this.pending.get(key);
-        if (current)
-          this.rejectPending(key, current, error instanceof Error ? error : new SubcError(String(error)));
-      });
-    });
-  }
-  arbitrateTimeout(key, pending, channel, corr, ms) {
-    const settleAsTimeout = () => {
-      if (pending.onLateResponse)
-        this.lateResponses.set(key, pending.onLateResponse);
-      this.rejectPending(key, pending, new SubcError(this.timeoutMessage(channel, corr, ms), REQUEST_DEADLINE_MARKER));
-    };
-    const graceDeadline = Date.now() + this.opts.timeoutArbitrationGraceMs;
-    const arbitrate = () => {
-      if (this.pending.get(key) !== pending)
-        return;
-      const readerDraining = this.readerActive || this.sock.bufferedBytes() > 0;
-      if (readerDraining && Date.now() < graceDeadline) {
-        setImmediate(arbitrate);
-        return;
-      }
-      settleAsTimeout();
-    };
-    setImmediate(arbitrate);
-  }
-  async managedRequest(handle, body, opts) {
-    const binary = opts.binary ?? false;
-    const bytes = binary ? requireBinaryBody(body) : body instanceof Uint8Array ? body : this.encode(body);
-    const priority = opts.priority ?? Priority.Interactive;
-    const admission = opts.admissionClass ?? AdmissionClass.Normal;
-    try {
-      const reply = await this.sendManaged(handle, bytes, priority, admission, opts.timeoutMs, opts.onProgress, binary);
-      return this.decodeReply(reply);
-    } catch (error) {
-      if (error instanceof SubcCallError)
-        throw error;
-      throw this.terminalCallError("managed call failed", error);
-    }
-  }
-  sendManaged(handle, body, priority, admission, timeoutMs, onProgress, binary = false) {
-    try {
-      this.assertLiveHandle(handle);
-    } catch (error) {
-      return Promise.reject(this.notSentCallError("request used a stale route handle", error));
-    }
-    if (this.closedErr) {
-      return Promise.reject(this.notSentCallError("request was not sent because the subc connection was already closed", this.closedErr));
-    }
-    let corr;
-    try {
-      corr = this.allocateCorr();
-    } catch (error) {
-      return Promise.reject(this.notSentCallError("request correlation allocator was exhausted", error));
-    }
-    const key = pendingKey(handle, corr);
-    const frame = buildFrame(FrameType.Request, buildFlags(binary, priority, false, admission), handle.channel, handle.epoch, corr, body);
-    let handedToSocket = false;
-    const classifyFailure = (error) => {
-      if (!handedToSocket)
-        return this.notSentCallError("request bytes were not queued to the subc socket", error);
-      if (error instanceof SubcError && error.code === REQUEST_DEADLINE_MARKER) {
-        return new SubcCallError("outcome_unknown", `managed call deadline exceeded after request bytes were queued to the local socket; no terminal response was observed; outcome unknown${causeMessage(error)}`, DEADLINE_NO_DROP_CODE, error);
-      }
-      return this.outcomeUnknownCallError("connection dropped before the managed call returned a response", error);
-    };
-    return new Promise((resolve, reject) => {
-      const ms = timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
-      const pending = {
-        handle,
-        resolve,
-        reject,
-        onProgress,
-        timer: null,
-        classifyFailure
-      };
-      pending.timer = setTimeout(() => this.arbitrateTimeout(key, pending, handle.channel, corr, ms), ms);
-      this.pending.set(key, pending);
-      const write = writeTrackedBorrowed(this.sock, encodeFrame(frame), Date.now() + ms);
-      handedToSocket = write.queued;
-      write.completed.catch((error) => {
-        const current = this.pending.get(key);
-        if (current)
-          this.rejectPending(key, current, error instanceof Error ? error : new SubcError(String(error)));
-      });
-    });
-  }
-  async cachedRouteHandle(moduleId, opts) {
-    const identity = opts.identity ?? this.opts.identity;
-    if (!identity) {
-      throw new SubcCallError("terminal", "managed call requires a BindIdentity in SubcClient.connect({ identity }) or call(..., { identity })", "missing_identity");
-    }
-    const target = { kind: opts.targetKind ?? this.opts.targetKind, module_id: moduleId };
-    const consumerIdentity = routeOpenConsumerIdentity(opts);
-    const key = routeCacheKey(target, identity, consumerIdentity);
-    let cached = this.routes.get(key);
-    if (!cached) {
-      cached = {
-        key,
-        moduleId,
-        target,
-        identity,
-        consumerIdentity,
-        handle: null,
-        opening: null
-      };
-      this.routes.set(key, cached);
-    }
-    if (cached.handle && this.isLiveHandle(cached.handle))
-      return cached.handle;
-    if (!cached.opening) {
-      cached.opening = this.openCachedRoute(cached).finally(() => {
-        cached.opening = null;
-      });
-    }
-    return cached.opening;
-  }
-  async openCachedRoute(cached) {
-    const routeRetryDeadline = Date.now() + this.opts.routeOpenRetryDeadlineMs;
-    let routeRetryDelay = this.opts.reconnectBackoff.baseMs;
-    let routeRetryAttempt = 0;
-    for (;; ) {
-      if (cached.closed)
-        throw this.routeClosedDuringOpen();
-      try {
-        await this.ensureConnectedForManaged();
-      } catch (error) {
-        throw this.notSentRecoveryError("route.open could not run because reconnect failed", error);
-      }
-      if (cached.handle && this.isLiveHandle(cached.handle))
-        return cached.handle;
-      try {
-        const handle = await this.routeOpen(cached.target, cached.identity, {
-          consumerIdentity: cached.consumerIdentity ?? null
-        });
-        if (cached.closed) {
-          this.liveRoutes.delete(handle.channel);
-          this.sendRouteGoodbye(handle);
-          throw this.routeClosedDuringOpen();
-        }
-        cached.handle = handle;
-        return handle;
-      } catch (error) {
-        if (error instanceof SubcCallError && error.code === "route_closed")
-          throw error;
-        if (!this.closeStarted && isConsumerReconnectTransient(error)) {
-          try {
-            await this.reconnectAfterDrop(error);
-          } catch (reconnectError) {
-            throw this.notSentRecoveryError("route.open was not sent and reconnect failed", reconnectError);
-          }
-          continue;
-        }
-        if (!this.closeStarted && error instanceof SubcError && isRetryableRouteOpenCode(error.code)) {
-          routeRetryAttempt += 1;
-          if (Date.now() < routeRetryDeadline) {
-            await this.opts.sleep(routeRetryDelay);
-            routeRetryDelay = Math.min(routeRetryDelay * 2, this.opts.reconnectBackoff.capMs);
-            continue;
-          }
-          throw this.notSentCallError(`route.open failed for module ${cached.moduleId}: ${error.code} (retry deadline exhausted after ${routeRetryAttempt} attempts)`, error);
-        }
-        throw this.terminalCallError(`route.open failed for module ${cached.moduleId}`, error);
-      }
-    }
-  }
-  lastInboundAtMs = 0;
-  livenessProbe = null;
-  hasControlPending() {
-    for (const pending of this.pending.values()) {
-      if (pending.handle === null)
-        return true;
-    }
-    return false;
-  }
-  probeLivenessAfterDeadline() {
-    if (this.livenessProbe || this.closeStarted || this.closedErr)
-      return;
-    if (this.hasControlPending())
-      return;
-    const sock = this.sock;
-    const generation = this.generation;
-    let corr;
-    try {
-      corr = this.allocateCorr();
-    } catch {
-      return;
-    }
-    const t0 = Date.now();
-    const ping = buildFrame(FrameType.Ping, buildFlags(false, Priority.Interactive, false, AdmissionClass.Normal), 0, 0, corr, new Uint8Array);
-    const probe = (async () => {
-      await writeBorrowed(sock, encodeFrame(ping), t0 + this.opts.livenessProbeWindowMs).catch(() => {});
-      await this.opts.sleep(this.opts.livenessProbeWindowMs);
-      if (this.sock !== sock || this.generation !== generation || this.closeStarted)
-        return;
-      if (this.lastInboundAtMs >= t0)
-        return;
-      if (this.hasControlPending())
-        return;
-      this.fail(new SocketClosedError(`liveness probe convicted a half-open socket: no inbound frame for ${this.opts.livenessProbeWindowMs}ms after a channel-0 Ping (deadline-no-drop settles preceded this); closing so the next call reconnects`));
-      sock.close();
-    })().finally(() => {
-      this.livenessProbe = null;
-    });
-    this.livenessProbe = probe;
-  }
-  async ensureConnectedForManaged() {
-    if (this.closeStarted)
-      throw new SubcError("client closed");
-    if (this.reconnecting)
-      await this.reconnecting;
-    if (this.closedErr)
-      await this.reconnectAfterDrop(this.closedErr);
-  }
-  scheduleReconnectAfterDrop(err) {
-    if (this.closeStarted || this.reconnecting)
-      return;
-    this.reconnectAfterDrop(err).catch(() => {});
-  }
-  reconnectAfterDrop(trigger) {
-    if (this.closeStarted)
-      return Promise.reject(new SubcError("client closed"));
-    if (this.reconnecting)
-      return this.reconnecting;
-    const promise = this.reconnectWithRetry(trigger).finally(() => {
-      if (this.reconnecting === promise)
-        this.reconnecting = null;
-    });
-    this.reconnecting = promise;
-    return promise;
-  }
-  async reconnectWithRetry(_trigger) {
-    let attempt = 0;
-    let delay = this.opts.reconnectBackoff.baseMs;
-    for (;; ) {
-      if (this.closeStarted)
-        throw new SubcError("client closed");
-      attempt += 1;
-      try {
-        const opened = await SubcClient.openConnection(this.opts);
-        if (this.closeStarted) {
-          opened.sock.close();
-          throw new SubcError("client closed");
-        }
-        this.replaceConnection(opened);
-        await this.reopenCachedRoutes();
-        return;
-      } catch (err) {
-        if (!isConsumerReconnectTransient(err) || attempt >= this.opts.reconnectBackoff.maxAttempts) {
-          if (err instanceof AuthError && attempt > 1) {
-            throw new AuthError(`reconnect gave up after ${attempt} attempts: ${err.message} — the connection file and the daemon's key disagree persistently ` + `(daemon restarting in a loop, split connection-file paths, or a genuinely foreign daemon on this port); ` + `check the daemon, then restart this host app`);
-          }
-          throw err;
-        }
-        await this.opts.sleep(delay);
-        delay = Math.min(delay * 2, this.opts.reconnectBackoff.capMs);
-      }
-    }
-  }
-  replaceConnection(opened) {
-    this.sock.close();
-    this.sock = opened.sock;
-    this.currentConn = opened.conn;
-    this.closedErr = null;
-    this.generation += 1;
-    this.connectionToken = newConnectionToken();
-    this.liveRoutes.clear();
-    this.lateResponses.clear();
-    this.nextCorr = 1n;
-    this.readLoop(opened.sock, this.generation);
-  }
-  async reopenCachedRoutes() {
-    const routeKeys = [...this.routes.keys()];
-    for (const key of routeKeys) {
-      const cached = this.routes.get(key);
-      if (cached)
-        cached.handle = null;
-    }
-    for (const key of routeKeys) {
-      const cached = this.routes.get(key);
-      if (!cached || cached.closed)
-        continue;
-      try {
-        const handle = await this.routeOpen(cached.target, cached.identity, {
-          consumerIdentity: cached.consumerIdentity ?? null
-        });
-        if (cached.closed) {
-          this.liveRoutes.delete(handle.channel);
-          this.sendRouteGoodbye(handle);
-          continue;
-        }
-        cached.handle = handle;
-      } catch (error) {
-        if (isRouteOpenRefusal(error)) {
-          this.routes.delete(key);
-          continue;
-        }
-        throw error;
-      }
-    }
-  }
-  timeoutMessage(channel, corr, ms) {
-    const port = this.sock.localPort();
-    const where = port === null ? "channel" : `local_port=${port} channel`;
-    return `request on ${where} ${channel} corr ${corr} timed out after ${ms}ms`;
-  }
-  routeClosedDuringOpen() {
-    return new SubcCallError("not_sent", "route was closed before route.open completed", "route_closed");
-  }
-  async readLoop(sock, generation) {
-    try {
-      for (;; ) {
-        this.readerActive = false;
-        const frame = await sock.readFrame(Number.POSITIVE_INFINITY, { afterHeaderMs: BODY_READ_TIMEOUT_MS }, () => {
-          this.readerActive = true;
-        });
-        try {
-          if (this.sock === sock && this.generation === generation)
-            this.dispatch(frame);
-        } finally {
-          this.readerActive = false;
-        }
-      }
-    } catch (error) {
-      if (this.sock === sock && this.generation === generation) {
-        this.fail(error instanceof Error ? error : new SubcError(String(error)));
-      }
-    }
-  }
-  dispatch(frame) {
-    this.lastInboundAtMs = Date.now();
-    if (frame.header.channel === 0 && frame.header.ty === FrameType.Push) {
-      const observer = this.opts.onControlPush;
-      if (observer) {
-        let parsed = null;
-        try {
-          const body = this.parseJson(frame);
-          if (body && typeof body.op === "string")
-            parsed = { op: body.op, body };
-        } catch {}
-        if (parsed) {
-          try {
-            observer(parsed);
-          } catch {}
-        }
-      }
-      return;
-    }
-    let handle = null;
-    if (frame.header.channel !== 0) {
-      handle = this.liveRoutes.get(frame.header.channel) ?? null;
-      if (!handle || handle.epoch !== frame.header.epoch) {
-        this.ingressEpochDropCount += 1;
-        return;
-      }
-    }
-    const key = pendingKey(handle, frame.header.corr);
-    const pending = this.pending.get(key);
-    if (pending) {
-      if (pending.acceptFrame && !pending.acceptFrame(frame))
-        return;
-      switch (frame.header.ty) {
-        case FrameType.Push:
-        case FrameType.StreamData:
-          try {
-            pending.onProgress?.(frame.body);
-          } catch {}
-          return;
-        case FrameType.Response:
-        case FrameType.StreamEnd:
-          this.settle(key, pending, () => pending.resolve(frame));
-          return;
-        case FrameType.Error:
-          this.settle(key, pending, () => pending.reject(this.errorFromFrame(frame)));
-          return;
-        default:
-          return;
-      }
-    }
-    const late = this.lateResponses.get(key);
-    if (late && (frame.header.ty === FrameType.Response || frame.header.ty === FrameType.Error)) {
-      this.lateResponses.delete(key);
-      late(frame);
-      return;
-    }
-    if (frame.header.ty === FrameType.Goodbye && handle) {
-      this.failHandle(handle, new SubcError("route closed by subc (GOODBYE)", "route_closed"));
-      if (this.liveRoutes.get(handle.channel) === handle)
-        this.liveRoutes.delete(handle.channel);
-      this.evictRouteHandle(handle);
-      return;
-    }
-    if (frame.header.ty === FrameType.Response || frame.header.ty === FrameType.Error || frame.header.ty === FrameType.StreamEnd) {
-      debug("dropped terminal frame with no waiter: type=%d channel=%d epoch=%d corr=%s port=%s", frame.header.ty, frame.header.channel, frame.header.epoch, frame.header.corr, this.sock.localPort() ?? "?");
-    }
-  }
-  settle(key, pending, run) {
-    if (this.pending.get(key) !== pending)
-      return false;
-    this.pending.delete(key);
-    if (pending.timer)
-      clearTimeout(pending.timer);
-    run();
-    pending.onSettle?.();
-    return true;
-  }
-  rejectPending(key, pending, err) {
-    this.settle(key, pending, () => pending.reject(pending.classifyFailure?.(err) ?? err));
-  }
-  errorFromFrame(frame) {
-    try {
-      const parsed = JSON.parse(Buffer.from(frame.body).toString("utf8"));
-      return new SubcError(parsed.message ?? "subc error", parsed.code, parsed.detail);
-    } catch {
-      return new SubcError(Buffer.from(frame.body).toString("utf8") || "subc error");
-    }
-  }
-  evictRouteHandle(handle) {
-    for (const cached of this.routes.values()) {
-      if (cached.handle && sameRouteHandle(cached.handle, handle))
-        cached.handle = null;
-    }
-  }
-  failHandle(handle, error) {
-    for (const [key, pending] of this.pending) {
-      if (pending.handle && sameRouteHandle(pending.handle, handle))
-        this.rejectPending(key, pending, error);
-    }
-  }
-  fail(err) {
-    if (!this.closedErr)
-      this.closedErr = err;
-    for (const [key, pending] of this.pending) {
-      this.rejectPending(key, pending, err);
-    }
-  }
-  notSentCallError(message, cause) {
-    return new SubcCallError("not_sent", `${message}${causeMessage(cause)}`, errorCode(cause), cause);
-  }
-  outcomeUnknownCallError(message, cause) {
-    return new SubcCallError("outcome_unknown", `${message}${causeMessage(cause)}`, errorCode(cause), cause);
-  }
-  terminalCallError(message, cause) {
-    if (cause instanceof SubcCallError)
-      return cause;
-    return new SubcCallError("terminal", `${message}${causeMessage(cause)}`, errorCode(cause), cause);
-  }
-  notSentRecoveryError(message, cause) {
-    if (cause instanceof SubcCallError)
-      return cause;
-    if (isConsumerReconnectTransient(cause))
-      return this.notSentCallError(message, cause);
-    return this.terminalCallError(message, cause);
-  }
-  get droppedIngressFrames() {
-    return this.ingressEpochDropCount;
-  }
-  installRoute(channel, epoch) {
-    const handle = createRouteHandle(channel, epoch, this.connectionToken);
-    this.liveRoutes.set(channel, handle);
-    return handle;
-  }
-  isLiveHandle(handle) {
-    return belongsToConnection(handle, this.connectionToken) && this.liveRoutes.get(handle.channel) === handle;
-  }
-  assertLiveConnection(handle) {
-    if (!belongsToConnection(handle, this.connectionToken))
-      throw new StaleRouteHandleError(handle);
-  }
-  assertLiveHandle(handle) {
-    if (!this.isLiveHandle(handle))
-      throw new StaleRouteHandleError(handle);
-  }
-  allocateCorr() {
-    const maximum = 0xffffffffffffffffn;
-    if (this.nextCorr > maximum) {
-      const error = new SubcError("channel-0 correlation id allocator exhausted", "corr_exhausted");
-      this.fail(error);
-      this.sock.close();
-      this.scheduleReconnectAfterDrop(error);
-      throw error;
-    }
-    const corr = this.nextCorr;
-    this.nextCorr += 1n;
-    return corr;
-  }
-  closeConnectionAfterCleanupFailure() {
-    const error = new SubcError("late route cleanup could not be queued", "late_route_cleanup_failed");
-    this.fail(error);
-    this.sock.close();
-    this.scheduleReconnectAfterDrop(error);
-  }
-  encode(value) {
-    return Buffer.from(JSON.stringify(value), "utf8");
-  }
-  decodeReply(frame) {
-    return hasBinary(frame.header.flags) ? frame.body : this.parseJson(frame);
-  }
-  parseJson(frame) {
-    const b = frame.body;
-    return JSON.parse(Buffer.from(b.buffer, b.byteOffset, b.byteLength).toString("utf8"));
-  }
-}
-function isConsumerReconnectTransient(err) {
-  if (err instanceof SocketClosedError || err instanceof SocketTimeoutError)
-    return true;
-  if (err instanceof SocketWriteNotQueuedError || err instanceof SocketWriteQueuedError)
-    return true;
-  if (err instanceof SubcCallError)
-    return err.kind === "not_sent" || err.kind === "outcome_unknown";
-  if (err instanceof AuthError)
-    return true;
-  if (err instanceof SubcError || err instanceof ConnectionFileError)
-    return false;
-  const code = errorCode(err);
-  return code === "ECONNREFUSED" || code === "ECONNRESET" || code === "EPIPE" || code === "ETIMEDOUT" || code === "ENOENT";
-}
-function isRouteOpenRefusal(err) {
-  return err instanceof SubcError && typeof err.code === "string";
-}
-function isRetryableRouteOpenCode(code) {
-  if (code === "capability_forbidden")
-    return false;
-  return code === "unknown_module" || code === "module_reloading" || code === "module_warming" || code === "target_unavailable" || code === "module_timeout";
-}
-async function connectionFileExists(path) {
-  try {
-    await fs2.access(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function normalizeConnectOptions(opts) {
-  return {
-    connectionFile: opts.connectionFile,
-    handshakeTimeoutMs: opts.handshakeTimeoutMs,
-    identity: opts.identity,
-    targetKind: opts.targetKind ?? DEFAULT_MANAGED_TARGET_KIND,
-    reconnectBackoff: opts.reconnectBackoff ?? DEFAULT_RECONNECT_BACKOFF,
-    sleep: opts.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms))),
-    routeOpenRetryDeadlineMs: opts.routeOpenRetryDeadlineMs ?? ROUTE_OPEN_RETRY_DEADLINE_MS,
-    timeoutArbitrationGraceMs: opts.timeoutArbitrationGraceMs ?? TIMEOUT_ARBITRATION_GRACE_MS,
-    livenessProbeWindowMs: opts.livenessProbeWindowMs ?? LIVENESS_PROBE_WINDOW_MS,
-    onControlPush: opts.onControlPush
-  };
-}
-function isValidCapabilityIdentifier(identifier) {
-  if (/\s/u.test(identifier))
-    return false;
-  const separator = identifier.indexOf("/v");
-  if (separator <= 0 || identifier.indexOf("/v", separator + 1) !== -1)
-    return false;
-  const name = identifier.slice(0, separator);
-  const version = identifier.slice(separator + 2);
-  if (new TextEncoder().encode(name).byteLength > 64 || version.length === 0)
-    return false;
-  if (!/^[a-z][a-z0-9-]*[a-z0-9]$/u.test(name) && !/^[a-z]$/u.test(name))
-    return false;
-  if (name.includes("--"))
-    return false;
-  if (!/^\d+$/u.test(version) || version.length > 1 && version.startsWith("0"))
-    return false;
-  const numericVersion = Number(version);
-  return Number.isSafeInteger(numericVersion) && numericVersion >= 1 && numericVersion <= 4294967295;
-}
-function routeCacheKey(target, identity, consumerIdentity) {
-  const consumerPart = consumerIdentity ? `${consumerIdentity.module_id}\x00${consumerIdentity.launch_nonce}` : "";
-  return `${target.kind}\x00${target.module_id}\x00${identity.project_root}\x00${identity.harness}\x00${identity.session}\x00${consumerPart}`;
-}
-function routeOpenConsumerIdentity(opts = {}) {
-  if (opts.consumerIdentity !== undefined)
-    return opts.consumerIdentity ?? undefined;
-  const moduleId = process.env[SUBC_MODULE_ID_ENV];
-  const launchNonce = process.env[SUBC_LAUNCH_NONCE_ENV];
-  if (!moduleId || !launchNonce)
-    return;
-  return { module_id: moduleId, launch_nonce: launchNonce };
-}
-function errorCode(err) {
-  if (typeof err === "object" && err !== null && "code" in err) {
-    const code = err.code;
-    if (typeof code === "string")
-      return code;
-  }
-  return;
-}
-function causeMessage(cause) {
-  if (cause === undefined)
-    return "";
-  return `: ${cause instanceof Error ? cause.message : String(cause)}`;
-}
-function pendingKey(handle, corr) {
-  return handle ? `${handle.channel}:${handle.epoch}:${corr}` : `0:0:${corr}`;
-}
-// src/features/magic-context/memory/embedding-synapse.ts
-var SYNAPSE_DEFAULT_MODEL = "gte-modernbert-base-f16";
-var SYNAPSE_DEFAULT_QUERY_TIMEOUT_MS = 3000;
-var SYNAPSE_DEFAULT_BATCH_TIMEOUT_MS = 120000;
-var SYNAPSE_CERTIFICATION_REFUSAL_REASONS = new Set([
-  "not_certified",
-  "probe_required",
-  "migration_required"
-]);
-var embeddingRowMetadata = new WeakMap;
-function isSynapseEmbeddingTruncated(vector) {
-  return embeddingRowMetadata.get(vector)?.truncated === true;
-}
-function toSynapseLaneDescriptor(metadata) {
-  const tokenBudget = metadata.recommended_token_budget;
-  return {
-    lane: metadata.model,
-    ...metadata.device_class ? { device_class: metadata.device_class } : {},
-    max_tokens: metadata.max_tokens,
-    max_tokens_source: metadata.max_tokens_source,
-    ...metadata.bucket_ladder ? { bucket_ladder: [...metadata.bucket_ladder] } : {},
-    ...metadata.dims ? { dims: metadata.dims } : {},
-    ...metadata.dtype ? { dtype: metadata.dtype } : {},
-    ...typeof metadata.certified === "boolean" ? { certified: metadata.certified } : {},
-    ...metadata.warm_load_cost_hint_ms !== undefined ? { warm_load_cost_hint_ms: metadata.warm_load_cost_hint_ms } : {},
-    ...metadata.recommended_batch ? {
-      recommended_batch: {
-        rows: metadata.recommended_batch,
-        ...tokenBudget !== undefined ? { token_budget: tokenBudget } : {}
-      }
-    } : {},
-    warm: metadata.max_tokens_source === "runtime_bucket" || metadata.max_tokens_source === "worker_bucket"
-  };
-}
-function formatSynapseLaneDescriptor(descriptor) {
-  const certified = descriptor.certified === undefined ? "unknown" : String(descriptor.certified);
-  return `lane=${descriptor.lane}; device_class=${descriptor.device_class ?? "unknown"}; ` + `max_tokens=${descriptor.max_tokens} (${descriptor.max_tokens_source}); ` + `certified=${certified}; warm=${descriptor.warm ? "yes" : "no"}; ` + `warm_load_cost_hint_ms=${descriptor.warm_load_cost_hint_ms ?? "unknown"}`;
-}
-
-class SynapseEmbeddingError extends Error {
-  code;
-  retryAfterMs;
-  permanent;
-  refusalReason;
-  constructor(code, message, options) {
-    super(message, options?.cause === undefined ? undefined : { cause: options.cause });
-    this.name = "SynapseEmbeddingError";
-    this.code = code;
-    this.permanent = options?.permanent ?? isPermanentSynapseCode(code);
-    this.retryAfterMs = options?.retryAfterMs ?? (this.permanent ? undefined : 100);
-    this.refusalReason = options?.refusalReason;
-  }
-}
-function isPermanentSynapseCode(code) {
-  return code === "artifact_invalid" || code === "substitution_rejected" || code === "not_certified" || code === "probe_required" || code === "idempotency_conflict" || code === "schema_violation" || code === "certification_refused" || code === "needs_reauth";
-}
-function asRecord(value) {
-  return value !== null && typeof value === "object" ? value : null;
-}
-function responseBody(value) {
-  const record = asRecord(value);
-  const result = asRecord(record?.result);
-  const payload = asRecord(result?.payload ?? record?.payload);
-  return {
-    ...record ?? {},
-    ...result ?? {},
-    ...payload ?? {}
-  };
-}
-function readRetryAfter(value) {
-  const record = asRecord(value);
-  const candidate = record?.retry_after_ms ?? record?.retryAfterMs;
-  if (typeof candidate !== "number" || !Number.isFinite(candidate) || candidate < 0)
-    return;
-  return Math.ceil(candidate);
-}
-function readErrorCode(value) {
-  const record = asRecord(value);
-  if (typeof record?.code === "string")
-    return record.code;
-  if (value instanceof Error && "code" in value && typeof value.code === "string") {
-    return value.code;
-  }
-  return;
-}
-function readCertificationRefusalReason(value) {
-  if (!(value instanceof SubcCallError))
-    return;
-  const detail = value.detail;
-  if (typeof detail === "string")
-    return detail;
-  const record = asRecord(detail);
-  return typeof record?.reason === "string" ? record.reason : undefined;
-}
-function classifyError(value) {
-  if (value instanceof SynapseEmbeddingError)
-    return value;
-  const code = readErrorCode(value) ?? (value instanceof Error ? value.name : "transport");
-  const normalized = code.toLowerCase();
-  const refusalReason = readCertificationRefusalReason(value);
-  let mapped = "transport";
-  if (normalized.includes("queue_full"))
-    mapped = "queue_full";
-  else if (normalized.includes("model_loading"))
-    mapped = "model_loading";
-  else if (normalized.includes("timeout") || normalized.includes("deadline"))
-    mapped = "timeout";
-  else if (normalized.includes("artifact_invalid"))
-    mapped = "artifact_invalid";
-  else if (normalized.includes("substitution"))
-    mapped = "substitution_rejected";
-  else if (normalized === "certification_refused")
-    mapped = "certification_refused";
-  else if (normalized.includes("not_certified"))
-    mapped = "not_certified";
-  else if (normalized.includes("probe_required"))
-    mapped = "probe_required";
-  else if (normalized.includes("idempotency_conflict"))
-    mapped = "idempotency_conflict";
-  else if (normalized.includes("needs_reauth"))
-    mapped = "needs_reauth";
-  else if (normalized.includes("schema"))
-    mapped = "schema_violation";
-  else if (normalized.includes("module_restarted") || normalized.includes("module restarted"))
-    mapped = "module_restarted";
-  const message = value instanceof Error ? value.message : String(value);
-  return new SynapseEmbeddingError(mapped, message, {
-    retryAfterMs: readRetryAfter(value) ?? (isPermanentSynapseCode(mapped) ? undefined : 100),
-    cause: value,
-    refusalReason
-  });
-}
-function embeddingFailureFor(error) {
-  const typedReason = error.refusalReason;
-  if (typedReason !== undefined && SYNAPSE_CERTIFICATION_REFUSAL_REASONS.has(typedReason) || error.code === "not_certified" || error.code === "probe_required") {
-    return {
-      class: "certification_refusal",
-      reason: `SYNAPSE certification refused embedding: ${typedReason ?? error.code}`,
-      retryable: false
-    };
-  }
-  if (error.code === "certification_refused") {
-    return {
-      class: "certification_refusal",
-      reason: `SYNAPSE certification refused embedding: ${typedReason ?? "unknown reason"}`,
-      retryable: false
-    };
-  }
-  if (typedReason === "needs_reauth" || typedReason === "needs_reauth_expired") {
-    return {
-      class: "credential_required",
-      reason: "SYNAPSE requires reauthentication",
-      retryable: false
-    };
-  }
-  if (error.code === "substitution_rejected") {
-    return { class: "substitution_rejected", reason: error.message, retryable: false };
-  }
-  if (error.code === "schema_violation" || error.code === "artifact_invalid") {
-    return { class: "invalid_envelope", reason: error.message, retryable: false };
-  }
-  return { class: "transport_error", reason: error.message, retryable: !error.permanent };
-}
-function wait(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function sha256(value) {
-  return createHash("sha256").update(value).digest("hex");
-}
-function stableJson(value) {
-  if (Array.isArray(value))
-    return `[${value.map(stableJson).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 JSON.stringify(value);
-}
-function getSynapseLaneIdentity(model, fingerprint) {
-  return `synapse:v1:${sha256(stableJson({ model, fingerprint }))}`;
-}
-function getSynapseBatchRequestKey(args) {
-  return sha256(stableJson({
-    op: "embed.batch",
-    model: args.model,
-    required_fingerprint: args.fingerprint,
-    required_epoch: args.tableEpoch,
-    allow_equivalent: false,
-    accept_declared: false,
-    ids: args.items.map((item) => item.id),
-    content_sha256: args.items.map((item) => item.contentSha256),
-    ...args.purpose === "query" ? { purpose: args.purpose } : {}
-  }));
-}
-function hashContent(text) {
-  return sha256(text);
-}
-function extractCatalogEntries(value) {
-  const body = responseBody(value);
-  const raw = Array.isArray(body.models) ? body.models : Array.isArray(body.entries) ? body.entries : Array.isArray(value) ? value : [];
-  const envelopeEpoch = typeof body.table_epoch === "number" && Number.isInteger(body.table_epoch) ? body.table_epoch : undefined;
-  const maxTokenSources = new Set([
-    "runtime_bucket",
-    "worker_bucket",
-    "catalog",
-    "catalog_unloaded"
-  ]);
-  return raw.flatMap((entry) => {
-    const record = asRecord(entry);
-    if (!record)
-      return [];
-    const model = typeof record.model === "string" && record.model.length > 0 ? record.model : typeof record.model_id === "string" ? record.model_id : "";
-    const fingerprint = typeof record.fingerprint === "string" && record.fingerprint.length > 0 ? record.fingerprint : Array.isArray(record.fingerprints) && typeof record.fingerprints[0] === "string" ? record.fingerprints[0] : "";
-    const entryEpoch = record.table_epoch ?? record.tableEpoch;
-    const tableEpoch = typeof entryEpoch === "number" && Number.isInteger(entryEpoch) ? entryEpoch : envelopeEpoch;
-    const maxTokens = record.max_tokens;
-    const maxTokensSource = record.max_tokens_source;
-    if (model.length === 0 || fingerprint.length === 0 || typeof tableEpoch !== "number" || !Number.isInteger(tableEpoch) || typeof maxTokens !== "number" || !Number.isInteger(maxTokens) || maxTokens <= 0 || typeof maxTokensSource !== "string" || !maxTokenSources.has(maxTokensSource)) {
-      return [];
-    }
-    const dims = record.dims ?? record.dimensions;
-    const rawBatch = record.recommended_batch ?? record.recommendedBatch;
-    const batchRecord = asRecord(rawBatch);
-    const recommendedBatch = typeof rawBatch === "number" ? rawBatch : batchRecord ? batchRecord.rows : undefined;
-    const recommendedTokenBudget = batchRecord ? batchRecord.token_budget : undefined;
-    const bucketLadder = Array.isArray(record.bucket_ladder) ? record.bucket_ladder.filter((bucket) => typeof bucket === "number" && Number.isInteger(bucket) && bucket > 0) : undefined;
-    const state = typeof record.state === "string" ? record.state : undefined;
-    const warmLoadCostHint = record.warm_load_cost_hint_ms;
-    return [
-      {
-        model,
-        fingerprint,
-        table_epoch: tableEpoch,
-        max_tokens: maxTokens,
-        max_tokens_source: maxTokensSource,
-        ...bucketLadder && bucketLadder.length > 0 ? { bucket_ladder: [...new Set(bucketLadder)].sort((a, b) => a - b) } : {},
-        ...typeof dims === "number" && Number.isInteger(dims) && dims > 0 ? { dims } : {},
-        ...typeof record.dtype === "string" && record.dtype.length > 0 ? { dtype: record.dtype } : {},
-        ...typeof record.device_class === "string" && record.device_class.length > 0 ? { device_class: record.device_class } : {},
-        ...typeof recommendedBatch === "number" && recommendedBatch > 0 ? { recommended_batch: Math.floor(recommendedBatch) } : {},
-        ...typeof recommendedTokenBudget === "number" && recommendedTokenBudget > 0 ? { recommended_token_budget: Math.floor(recommendedTokenBudget) } : {},
-        ...record.provenance !== undefined ? { provenance: record.provenance } : {},
-        ...typeof record.certified === "boolean" ? { certified: record.certified } : {},
-        ...typeof warmLoadCostHint === "number" && Number.isFinite(warmLoadCostHint) && warmLoadCostHint >= 0 ? { warm_load_cost_hint_ms: warmLoadCostHint } : {},
-        ...typeof record.status === "string" ? { status: record.status } : state ? { status: state } : {}
-      }
-    ];
-  });
-}
-function extractVector(value) {
-  const body = responseBody(value);
-  const item = Array.isArray(body.vectors) ? asRecord(body.vectors[0]) : null;
-  const raw = item?.vector;
-  if (!item || !Array.isArray(raw) || raw.some((component) => typeof component !== "number" || !Number.isFinite(component))) {
-    return null;
-  }
-  const disclosure = Array.isArray(body.truncation_disclosures) ? asRecord(body.truncation_disclosures[0]) : null;
-  return { vector: Float32Array.from(raw), item, disclosure, metadata: body };
-}
-function extractBatchItems(value) {
-  const body = responseBody(value);
-  const raw = Array.isArray(body.vectors) ? body.vectors : Array.isArray(body.items) ? body.items : Array.isArray(body.results) ? body.results : [];
-  return raw.flatMap((item) => {
-    const record = asRecord(item);
-    return record ? [record] : [];
-  });
-}
-function extractTruncationDisclosures(value) {
-  const body = responseBody(value);
-  if (!Array.isArray(body.truncation_disclosures))
-    return [];
-  return body.truncation_disclosures.map((disclosure) => asRecord(disclosure));
-}
-function validateWireRow(item, disclosure, expected) {
-  const submittedSha256 = item.submitted_sha256;
-  const contentSha256 = item.content_sha256;
-  const expectedSubmittedSha256 = hashContent(expected.text);
-  if (typeof submittedSha256 !== "string") {
-    throw new SynapseEmbeddingError("schema_violation", `Synapse item ${expected.id} omitted submitted_sha256`);
-  }
-  if (submittedSha256 !== expectedSubmittedSha256) {
-    throw new SynapseEmbeddingError("schema_violation", `Synapse submitted hash mismatch for item ${expected.id}`);
-  }
-  if (typeof contentSha256 !== "string") {
-    throw new SynapseEmbeddingError("schema_violation", `Synapse item ${expected.id} omitted content_sha256`);
-  }
-  const hashesDiffer = contentSha256 !== submittedSha256;
-  const disclosedTruncation = disclosure?.truncated === true;
-  const effectiveTokens = disclosure?.effective_tokens;
-  if (disclosure && (typeof disclosure.truncated !== "boolean" || typeof effectiveTokens !== "number" || !Number.isInteger(effectiveTokens) || effectiveTokens < 0)) {
-    throw new SynapseEmbeddingError("schema_violation", `Synapse item ${expected.id} returned an invalid truncation disclosure`);
-  }
-  if (hashesDiffer) {
-    if (!disclosedTruncation || typeof effectiveTokens !== "number" || !Number.isInteger(effectiveTokens) || effectiveTokens < 0) {
-      throw new SynapseEmbeddingError("schema_violation", `Synapse item ${expected.id} changed content without a valid truncation disclosure`);
-    }
-  } else if (disclosedTruncation) {
-    throw new SynapseEmbeddingError("schema_violation", `Synapse item ${expected.id} disclosed truncation but returned matching hashes`);
-  }
-  return {
-    truncated: hashesDiffer,
-    submittedSha256,
-    contentSha256,
-    ...typeof effectiveTokens === "number" && Number.isInteger(effectiveTokens) && effectiveTokens >= 0 ? { effectiveTokens } : {}
-  };
-}
-var sharedClient = null;
-var sharedClientFile = null;
-var sharedClientPromise = null;
-var factoryClients = new WeakMap;
-async function getSharedClient(options) {
-  if (options.clientFactory) {
-    let promise = factoryClients.get(options.clientFactory);
-    if (!promise) {
-      promise = options.clientFactory();
-      factoryClients.set(options.clientFactory, promise);
-    }
-    return promise;
-  }
-  if (sharedClient && sharedClientFile === options.connectionFile)
-    return sharedClient;
-  if (sharedClientPromise && sharedClientFile === options.connectionFile)
-    return sharedClientPromise;
-  sharedClientFile = options.connectionFile;
-  sharedClientPromise = SubcClient.connect({ connectionFile: options.connectionFile }).then((client) => {
-    sharedClient = client;
-    return client;
-  });
-  return sharedClientPromise;
-}
-
-class SynapseEmbeddingProvider {
-  modelId;
-  metadata;
-  get maxInputTokens() {
-    return this.metadata?.max_tokens;
-  }
-  options;
-  client = null;
-  initialized = false;
-  initializing = null;
-  permanentFailure = false;
-  lastFailureReason = null;
-  batchLimit = 16;
-  tokenBudget = null;
-  constructor(options) {
-    this.options = options;
-    const model = options.model || SYNAPSE_DEFAULT_MODEL;
-    const fingerprint = options.fingerprint ?? "";
-    const descriptor = options.descriptor;
-    this.metadata = options.metadata ? {
-      ...options.metadata,
-      bucket_ladder: options.metadata.bucket_ladder ? [...options.metadata.bucket_ladder] : undefined
-    } : fingerprint && Number.isInteger(options.tableEpoch) && descriptor ? {
-      model,
-      fingerprint,
-      table_epoch: options.tableEpoch,
-      max_tokens: descriptor.max_tokens,
-      max_tokens_source: descriptor.max_tokens_source,
-      ...descriptor.bucket_ladder ? { bucket_ladder: [...descriptor.bucket_ladder] } : {},
-      ...options.dims ?? descriptor.dims ? { dims: options.dims ?? descriptor.dims } : {},
-      ...descriptor.dtype ? { dtype: descriptor.dtype } : {},
-      ...descriptor.device_class ? { device_class: descriptor.device_class } : {},
-      ...options.recommendedBatch ?? descriptor.recommended_batch?.rows ? {
-        recommended_batch: Math.max(1, Math.floor(options.recommendedBatch ?? descriptor.recommended_batch?.rows))
-      } : {},
-      ...options.recommendedTokenBudget ?? descriptor.recommended_batch?.token_budget ? {
-        recommended_token_budget: Math.max(1, Math.floor(options.recommendedTokenBudget ?? descriptor.recommended_batch?.token_budget))
-      } : {},
-      ...options.provenance !== undefined ? { provenance: options.provenance } : {},
-      ...typeof descriptor.certified === "boolean" ? { certified: descriptor.certified } : {},
-      ...descriptor.warm_load_cost_hint_ms !== undefined ? { warm_load_cost_hint_ms: descriptor.warm_load_cost_hint_ms } : {},
-      laneIdentity: getSynapseLaneIdentity(model, fingerprint)
-    } : null;
-    this.modelId = this.metadata?.laneIdentity ?? "synapse:v1:pending";
-    this.batchLimit = this.metadata?.recommended_batch ?? 16;
-    this.tokenBudget = this.metadata?.recommended_token_budget ?? null;
-  }
-  nextPage(items, start) {
-    const hardEnd = Math.min(items.length, start + this.batchLimit);
-    if (this.tokenBudget === null)
-      return items.slice(start, hardEnd);
-    let end = start;
-    let tokens = 0;
-    while (end < hardEnd) {
-      tokens += estimateTokens(items[end].text);
-      if (tokens > this.tokenBudget && end > start)
-        break;
-      end += 1;
-    }
-    return items.slice(start, Math.max(end, start + 1));
-  }
-  static async discover(options) {
-    const provider = new SynapseEmbeddingProvider(options);
-    if (!await provider.initialize() || !provider.metadata) {
-      throw new SynapseEmbeddingError("not_certified", "Synapse lane is not ready");
-    }
-    return provider.metadata;
-  }
-  async initialize() {
-    if (this.initialized)
-      return true;
-    if (this.permanentFailure)
-      return false;
-    if (this.initializing)
-      return this.initializing;
-    this.initializing = (async () => {
-      try {
-        if (!this.options.clientFactory && !await connectionFileExists(this.options.connectionFile)) {
-          throw new SynapseEmbeddingError("transport", `Synapse connection file is unavailable: ${this.options.connectionFile}`);
-        }
-        this.client = await getSharedClient(this.options);
-        if (!this.metadata) {
-          const discovered = await this.callWithRetry("models.list", {}, this.options.queryTimeoutMs ?? SYNAPSE_DEFAULT_QUERY_TIMEOUT_MS, false);
-          const entries = extractCatalogEntries(discovered);
-          const requested = this.options.model?.trim() || SYNAPSE_DEFAULT_MODEL;
-          const entry = entries.find((candidate) => candidate.model === requested);
-          if (!entry) {
-            throw new SynapseEmbeddingError("artifact_invalid", `Synapse models.list did not return requested model ${requested}`);
-          }
-          if (entry.certified === false || entry.status === "not_certified") {
-            throw new SynapseEmbeddingError("not_certified", `Synapse model ${entry.model} is not certified`);
-          }
-          const metadata = {
-            ...entry,
-            laneIdentity: getSynapseLaneIdentity(entry.model, entry.fingerprint)
-          };
-          this.metadata = metadata;
-          this.modelId = metadata.laneIdentity;
-          this.batchLimit = metadata.recommended_batch ?? this.batchLimit;
-          this.tokenBudget = metadata.recommended_token_budget ?? this.tokenBudget;
-        }
-        this.initialized = true;
-        this.recordSuccess();
-        return true;
-      } catch (error) {
-        const classified = classifyError(error);
-        this.recordFailure(classified);
-        if (classified.permanent) {
-          this.permanentFailure = true;
-          log(`[magic-context] Synapse lane disabled: ${classified.code}: ${classified.message}`);
-        } else {
-          log(`[magic-context] Synapse lane unavailable: ${classified.message}`);
-        }
-        this.initialized = false;
-        return false;
-      } finally {
-        this.initializing = null;
-      }
-    })();
-    return this.initializing;
-  }
-  async embed(text, signal, purpose = "passage") {
-    if (!await this.initialize() || signal?.aborted || !this.metadata)
-      return null;
-    if (estimateTokens(text) > this.metadata.max_tokens)
-      return null;
-    try {
-      const id = "query";
-      const value = await this.callWithRetry("embed.query", this.requestConstraints({
-        id,
-        text,
-        purpose,
-        deadline_ms: this.options.queryTimeoutMs ?? SYNAPSE_DEFAULT_QUERY_TIMEOUT_MS
-      }), this.options.queryTimeoutMs ?? SYNAPSE_DEFAULT_QUERY_TIMEOUT_MS, true, signal);
-      const extracted = extractVector(value);
-      if (!extracted) {
-        throw new SynapseEmbeddingError("schema_violation", "Synapse query returned no vector row");
-      }
-      if (extracted.item.id !== id) {
-        throw new SynapseEmbeddingError("schema_violation", `Synapse query returned unexpected item ${String(extracted.item.id)}`);
-      }
-      const rowMetadata = validateWireRow(extracted.item, extracted.disclosure, { id, text });
-      this.validateResponse(extracted.metadata, extracted.vector.length);
-      embeddingRowMetadata.set(extracted.vector, rowMetadata);
-      this.recordSuccess();
-      return extracted.vector;
-    } catch (error) {
-      this.logCallFailure(error, "embed.query");
-      return null;
-    }
-  }
-  async embedBatch(texts, signal, purpose = "passage") {
-    if (texts.length === 0)
-      return [];
-    const items = texts.map((text, index) => ({
-      id: `item:${index}`,
-      text,
-      contentSha256: hashContent(text)
-    }));
-    const map = await this.embedItems(items, signal, purpose);
-    return items.map((item) => map.get(item.id) ?? null);
-  }
-  async embedItems(items, signal, purpose = "passage") {
-    const output = new Map;
-    if (items.length === 0 || !await this.initialize() || !this.metadata || signal?.aborted) {
-      return output;
-    }
-    const maxTokens = this.metadata.max_tokens;
-    const eligibleItems = items.filter((item) => estimateTokens(item.text) <= maxTokens).map((item) => ({ ...item, contentSha256: hashContent(item.text) }));
-    for (let start = 0;start < eligibleItems.length; ) {
-      if (signal?.aborted || this.permanentFailure)
-        break;
-      const page = this.nextPage(eligibleItems, start);
-      start += page.length;
-      try {
-        const requestKey = this.requestKey(page, purpose);
-        let body = {};
-        let restarted = false;
-        for (;; ) {
-          try {
-            body = await this.callWithRetry("embed.batch", this.batchRequest(page, requestKey, purpose), this.options.batchTimeoutMs ?? SYNAPSE_DEFAULT_BATCH_TIMEOUT_MS, true, signal);
-            const first = responseBody(body);
-            const jobId = typeof first.job_id === "string" ? first.job_id : null;
-            if (jobId)
-              body = await this.pollBatch(jobId, requestKey, signal);
-            break;
-          } catch (error) {
-            const classified = classifyError(error);
-            if (classified.code !== "module_restarted" || restarted)
-              throw classified;
-            restarted = true;
-          }
-        }
-        const batchEnvelope = responseBody(body);
-        const disclosures = extractTruncationDisclosures(body);
-        for (const [index, item] of extractBatchItems(body).entries()) {
-          const id = typeof item.id === "string" ? item.id : "";
-          const vector = item.vector ?? item.embedding;
-          if (!id || !Array.isArray(vector) || vector.some((component) => typeof component !== "number" || !Number.isFinite(component))) {
-            throw new SynapseEmbeddingError("schema_violation", "Synapse batch item is malformed");
-          }
-          const expected = page.find((candidate) => candidate.id === id);
-          if (!expected) {
-            throw new SynapseEmbeddingError("schema_violation", `Synapse returned unknown item ${id}`);
-          }
-          const rowMetadata = validateWireRow(item, disclosures[index] ?? null, expected);
-          const vectorArray = Float32Array.from(vector);
-          this.validateResponse({ ...batchEnvelope, ...item }, vectorArray.length);
-          embeddingRowMetadata.set(vectorArray, rowMetadata);
-          output.set(id, vectorArray);
-          this.recordSuccess();
-        }
-      } catch (error) {
-        const classified = classifyError(error);
-        this.logCallFailure(classified, "embed.batch");
-        if (classified.code === "idempotency_conflict" || classified.code === "schema_violation") {
-          throw classified;
-        }
-        if (classified.permanent) {
-          this.permanentFailure = true;
-          this.initialized = false;
-          break;
-        }
-      }
-    }
-    return output;
-  }
-  async dispose() {
-    this.initialized = false;
-    this.client = null;
-  }
-  isLoaded() {
-    return this.initialized;
-  }
-  getLastFailureReason() {
-    return this.lastFailureReason;
-  }
-  requestConstraints(extra) {
-    const metadata = this.metadata;
-    if (!metadata)
-      return extra;
-    return {
-      ...extra,
-      model: metadata.model,
-      required_fingerprint: metadata.fingerprint,
-      required_epoch: metadata.table_epoch,
-      allow_equivalent: false,
-      accept_declared: false
-    };
-  }
-  batchRequest(items, requestKey, purpose) {
-    return this.requestConstraints({
-      items: items.map((item) => ({
-        id: item.id,
-        text: item.text,
-        content_sha256: item.contentSha256
-      })),
-      request_key: requestKey,
-      purpose
-    });
-  }
-  requestKey(items, purpose) {
-    if (!this.metadata)
-      throw new SynapseEmbeddingError("transport", "Synapse metadata is unavailable");
-    return getSynapseBatchRequestKey({
-      model: this.metadata.model,
-      fingerprint: this.metadata.fingerprint,
-      tableEpoch: this.metadata.table_epoch,
-      items,
-      purpose
-    });
-  }
-  async pollBatch(jobId, requestKey, signal) {
-    let cursor = null;
-    const allItems = [];
-    const allDisclosures = [];
-    for (;; ) {
-      if (signal?.aborted)
-        return {};
-      const body = await this.callWithRetry("embed.result", this.requestConstraints({
-        job_id: jobId,
-        cursor,
-        request_key: requestKey
-      }), this.options.batchTimeoutMs ?? SYNAPSE_DEFAULT_BATCH_TIMEOUT_MS, true, signal);
-      const parsed = responseBody(body);
-      const items = extractBatchItems(body);
-      const disclosures = extractTruncationDisclosures(body);
-      allItems.push(...items);
-      allDisclosures.push(...items.map((_, index) => disclosures[index] ?? null));
-      const nextCursor = parsed.next_cursor ?? parsed.cursor;
-      const done = parsed.done === true || parsed.complete === true || nextCursor === undefined || nextCursor === null;
-      if (done) {
-        return {
-          ...parsed,
-          vectors: allItems,
-          truncation_disclosures: allDisclosures
-        };
-      }
-      cursor = nextCursor;
-    }
-  }
-  async callWithRetry(method, params, timeoutMs, retryEmbeddings, signal) {
-    let attempt = 0;
-    for (;; ) {
-      if (signal?.aborted)
-        throw new SynapseEmbeddingError("transport", "Synapse request aborted");
-      try {
-        if (!this.client)
-          throw new SynapseEmbeddingError("transport", "Synapse client is unavailable");
-        return await this.client.call(this.options.moduleId ?? "synapse", method, params, {
-          timeoutMs,
-          targetKind: "management_surface",
-          identity: {
-            project_root: this.options.projectRoot,
-            harness: getHarness(),
-            session: this.options.session
-          }
-        });
-      } catch (error) {
-        const classified = classifyError(error);
-        if (classified.code === "idempotency_conflict")
-          throw classified;
-        const outcomeUnknown = error instanceof SubcCallError && error.kind === "outcome_unknown";
-        const retryable = !classified.permanent && (retryEmbeddings || !outcomeUnknown);
-        if (!retryable || attempt >= 3)
-          throw classified;
-        const delay = classified.retryAfterMs ?? Math.min(2000, 100 * 2 ** attempt);
-        attempt += 1;
-        await wait(delay);
-      }
-    }
-  }
-  validateResponse(body, dims) {
-    const metadata = this.metadata;
-    if (!metadata) {
-      throw new SynapseEmbeddingError("artifact_invalid", "Synapse lane metadata missing");
-    }
-    if (metadata.dims === undefined) {
-      const envelopeDims = body.dims;
-      if (typeof envelopeDims === "number" && envelopeDims !== dims) {
-        throw new SynapseEmbeddingError("artifact_invalid", `Synapse envelope declares ${envelopeDims} dimensions but the vector has ${dims}`);
-      }
-      metadata.dims = dims;
-    }
-    if (dims !== metadata.dims) {
-      throw new SynapseEmbeddingError("artifact_invalid", `Synapse returned ${dims} dimensions, expected ${metadata.dims}`);
-    }
-    const fingerprint = body.fingerprint ?? body.served_fingerprint;
-    if (typeof fingerprint !== "string") {
-      throw new SynapseEmbeddingError("artifact_invalid", "Synapse response omitted the served fingerprint");
-    }
-    if (fingerprint !== metadata.fingerprint) {
-      throw new SynapseEmbeddingError("substitution_rejected", `Synapse fingerprint changed from ${metadata.fingerprint} to ${fingerprint}`);
-    }
-    const epoch = body.table_epoch ?? body.tableEpoch;
-    if (typeof epoch !== "number") {
-      throw new SynapseEmbeddingError("artifact_invalid", "Synapse response omitted the served table epoch");
-    }
-    if (epoch !== metadata.table_epoch) {
-      throw new SynapseEmbeddingError("substitution_rejected", `Synapse table epoch changed from ${metadata.table_epoch} to ${epoch}`);
-    }
-  }
-  logCallFailure(error, operation) {
-    const classified = classifyError(error);
-    this.recordFailure(classified);
-    if (classified.permanent)
-      this.permanentFailure = true;
-    const suffix = classified.retryAfterMs === undefined ? "" : ` retry_after_ms=${classified.retryAfterMs}`;
-    log(`[magic-context] Synapse ${operation} failed: ${classified.code}${suffix}: ${classified.message}`);
-  }
-  recordFailure(error) {
-    this.lastFailureReason = embeddingFailureFor(error);
-  }
-  recordSuccess() {
-    this.lastFailureReason = null;
-  }
-}
-
-// src/features/magic-context/memory/normalize-hash.ts
-import { createHash as createHash2 } from "node:crypto";
-function normalizeMemoryContent(content) {
-  return content.toLowerCase().replace(/\s+/g, " ").trim();
-}
-function computeNormalizedHash(content) {
-  const normalized = normalizeMemoryContent(content);
-  return createHash2("md5").update(normalized).digest("hex");
-}
-
-// src/features/magic-context/memory/embedding-identity.ts
-function normalizeEndpoint(endpoint) {
-  return endpoint?.trim().replace(/\/+$/, "") ?? "";
-}
-var LOCAL_EMBEDDING_RUNTIME_FINGERPRINT = "transformers@4.3.0;onnxruntime-node@1.30.0;onnxruntime-web@1.26.0-dev.20260416-b7804b056c";
-function getEmbeddingProviderIdentity(config) {
-  if (config.provider === "off") {
-    return "embedding-provider:off";
-  }
-  if (config.provider === "synapse") {
-    const resolved = config;
-    if (!resolved.model || !resolved.synapse_fingerprint)
-      return "synapse:v1:pending";
-    return getSynapseLaneIdentity(resolved.model, resolved.synapse_fingerprint);
-  }
-  if (config.provider !== "local" && config.provider !== "openai-compatible") {
-    throw new Error("Unknown embedding provider");
-  }
-  const truncate = config.provider === "openai-compatible" ? config.truncate?.trim() : undefined;
-  const documentPrefix = config.provider === "openai-compatible" ? resolveEmbeddingTextPrefixes(config.model, config.query_instruction, config.document_prefix).documentPrefix : "";
-  const localDtype = config.provider === "local" && config.local_dtype && config.local_dtype !== "fp32" ? config.local_dtype : undefined;
-  const identityInput = config.provider === "openai-compatible" ? {
-    provider: "openai-compatible",
-    model: config.model.trim(),
-    endpoint: normalizeEndpoint(config.endpoint),
-    apiKeyPresent: Boolean(config.api_key?.trim()),
-    inputType: config.input_type?.trim() || "",
-    ...documentPrefix ? { documentPrefix } : {},
-    ...truncate ? { truncate } : {}
-  } : {
-    provider: "local",
-    model: config.model?.trim() || DEFAULT_LOCAL_EMBEDDING_MODEL,
-    endpoint: "",
-    apiKeyPresent: false,
-    runtimeFingerprint: LOCAL_EMBEDDING_RUNTIME_FINGERPRINT,
-    ...localDtype ? { localDtype } : {}
-  };
-  return `embedding-provider:${computeNormalizedHash(JSON.stringify(identityInput))}`;
-}
-
-// src/features/magic-context/memory/embedding-worker-client.ts
-import { Worker } from "node:worker_threads";
-class EmbeddingWorkerClient {
-  data;
-  entry;
-  timeoutMs;
-  worker = null;
-  nextId = 1;
-  pending = new Map;
-  disposed = false;
-  constructor(data, entry = new URL(new URL(import.meta.url).pathname.endsWith(".ts") ? "./embedding-worker.ts" : "./embedding-worker.js", import.meta.url), timeoutMs = 5 * 60000) {
-    this.data = data;
-    this.entry = entry;
-    this.timeoutMs = timeoutMs;
-  }
-  start() {
-    if (this.disposed)
-      throw new Error("embedding worker disposed");
-    if (this.worker)
-      return this.worker;
-    const worker = new Worker(this.entry, { workerData: this.data });
-    this.worker = worker;
-    worker.unref();
-    worker.on("message", (reply) => {
-      if (this.worker !== worker)
-        return;
-      const request = this.pending.get(reply.id);
-      if (!request)
-        return;
-      clearTimeout(request.timer);
-      this.pending.delete(reply.id);
-      if (reply.error)
-        request.reject(new Error(reply.error));
-      else
-        request.resolve(reply);
-      if (this.pending.size === 0)
-        worker.unref();
-    });
-    const fail = (error) => {
-      if (this.worker !== worker)
-        return;
-      this.worker = null;
-      for (const request of this.pending.values()) {
-        clearTimeout(request.timer);
-        request.reject(error);
-      }
-      this.pending.clear();
-      log("[magic-context] embedding worker exited unexpectedly:", error);
-      worker.terminate();
-    };
-    worker.on("error", fail);
-    worker.on("exit", (code) => fail(new Error(`embedding worker exited (${code})`)));
-    return worker;
-  }
-  isRunning() {
-    return this.worker !== null;
-  }
-  request(texts, signal) {
-    if (signal?.aborted)
-      return Promise.reject(new Error("embedding request aborted"));
-    return new Promise((resolve, reject) => {
-      const worker = this.start();
-      const id = this.nextId++;
-      const timer = setTimeout(() => {
-        this.stop(new Error("embedding worker request timed out"));
-      }, this.timeoutMs);
-      const abort = () => {
-        clearTimeout(timer);
-        this.pending.delete(id);
-        signal?.removeEventListener("abort", abort);
-        reject(new Error("embedding request aborted"));
-        if (this.pending.size === 0)
-          worker.unref();
-      };
-      signal?.addEventListener("abort", abort, { once: true });
-      const cleanup = () => signal?.removeEventListener("abort", abort);
-      this.pending.set(id, {
-        timer,
-        resolve: (reply) => {
-          cleanup();
-          resolve(reply);
-        },
-        reject: (error) => {
-          cleanup();
-          reject(error);
-        }
-      });
-      worker.ref();
-      try {
-        worker.postMessage({ id, texts });
-      } catch (error) {
-        this.stop(error instanceof Error ? error : new Error(String(error)));
-      }
-    });
-  }
-  async stop(error) {
-    const worker = this.worker;
-    this.worker = null;
-    for (const request of this.pending.values()) {
-      clearTimeout(request.timer);
-      request.reject(error);
-    }
-    this.pending.clear();
-    await worker?.terminate();
-  }
-  async dispose() {
-    this.disposed = true;
-    await this.stop(new Error("embedding worker disposed"));
-  }
-}
-
-// src/features/magic-context/memory/transformers-remote-host.ts
-var DEFAULT_TRANSFORMERS_REMOTE_HOST = "https://huggingface.co/";
-function readHuggingFaceEndpoint() {
-  return globalThis.process?.env?.HF_ENDPOINT;
-}
-function configureTransformersRemoteHost(env, endpoint = readHuggingFaceEndpoint()) {
-  const normalized = endpoint?.trim().replace(/\/+$/, "");
-  env.remoteHost = normalized ? `${normalized}/` : DEFAULT_TRANSFORMERS_REMOTE_HOST;
-}
-
-// src/features/magic-context/memory/embedding-local.ts
-var BUN_NAPI_TEARDOWN_FIX_VERSION = [1, 4, 0];
-function currentLocalEmbeddingHost() {
-  const bun = globalThis.Bun;
-  const hasProcess = typeof process !== "undefined";
-  const bunVersion = hasProcess && typeof process.versions?.bun === "string" ? process.versions.bun : undefined;
-  return {
-    isElectron: hasProcess && Boolean(process.versions?.electron),
-    isBun: Boolean(bun) || Boolean(bunVersion),
-    bunVersion,
-    hasNodeFilesystem: hasProcess && (typeof process.versions?.node === "string" || typeof bunVersion === "string")
-  };
-}
-function bunHasNapiTeardownFix(version) {
-  const match = version?.match(/^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/);
-  if (!match || match[4])
-    return false;
-  const parsed = [Number(match[1]), Number(match[2]), Number(match[3])];
-  return parsed.some((part) => !Number.isSafeInteger(part)) ? false : parsed[0] > BUN_NAPI_TEARDOWN_FIX_VERSION[0] || parsed[0] === BUN_NAPI_TEARDOWN_FIX_VERSION[0] && (parsed[1] > BUN_NAPI_TEARDOWN_FIX_VERSION[1] || parsed[1] === BUN_NAPI_TEARDOWN_FIX_VERSION[1] && parsed[2] >= BUN_NAPI_TEARDOWN_FIX_VERSION[2]);
-}
-function resolveLocalEmbeddingRuntime(preference = "auto", host = currentLocalEmbeddingHost()) {
-  if (preference === "native" || preference === "wasm")
-    return preference;
-  if (host.isElectron)
-    return "electron";
-  if (host.isBun && !bunHasNapiTeardownFix(host.bunVersion))
-    return "wasm";
-  return "native";
-}
-function resolveLocalEmbeddingWorkerRuntime(preference = "auto", host = currentLocalEmbeddingHost()) {
-  if (host.isBun && !bunHasNapiTeardownFix(host.bunVersion) && preference === "native")
-    return "wasm";
-  return resolveLocalEmbeddingRuntime(preference, host);
-}
-var LOCK_POLL_MS = 150;
-var STALE_LOCK_MS = 3 * 60000;
-var MAX_LOCK_WAIT_MS = 5 * 60000;
-async function acquireModelLoadLock(lockPath) {
-  const waitStart = Date.now();
-  while (true) {
-    try {
-      const handle = await open(lockPath, "wx");
-      try {
-        await handle.writeFile(`pid=${process.pid} started=${Date.now()}
-`);
-      } catch {}
-      await handle.close();
-      return async () => {
-        try {
-          await unlink(lockPath);
-        } catch {}
-      };
-    } catch (error) {
-      const code = error.code;
-      if (code !== "EEXIST" && code !== "EPERM") {
-        throw error;
-      }
-      try {
-        const info = await stat(lockPath);
-        if (Date.now() - info.mtimeMs > STALE_LOCK_MS) {
-          log(`[magic-context] embedding-load lock stale (>${STALE_LOCK_MS}ms), taking over`);
-          try {
-            await unlink(lockPath);
-          } catch {}
-          continue;
-        }
-      } catch {
-        continue;
-      }
-      if (Date.now() - waitStart > MAX_LOCK_WAIT_MS) {
-        throw new Error(`[magic-context] embedding-load lock wait exceeded ${MAX_LOCK_WAIT_MS}ms; another process is still loading the model. Skipping this init attempt to avoid an unsynchronized native load.`);
-      }
-      await new Promise((resolve) => setTimeout(resolve, LOCK_POLL_MS));
-    }
-  }
-}
-function startLockHeartbeat(lockPath) {
-  const HEARTBEAT_MS = Math.floor(STALE_LOCK_MS / 3);
-  const timer = setInterval(() => {
-    writeFile(lockPath, `pid=${process.pid} alive=${Date.now()}
-`).catch(() => {});
-  }, HEARTBEAT_MS);
-  timer.unref?.();
-  return () => clearInterval(timer);
-}
-var ONNX_RUNTIME_WEB_SPECIFIER = "onnxruntime-web";
-var useInThreadTestRuntime = false;
-var workerFactoryForTests;
-var localEmbeddingRuntimeMode = "native";
-var localEmbeddingProcessFailure = null;
-var wasmRuntimeInjected = false;
-var localEmbeddingHostForRuntime = currentLocalEmbeddingHost;
-var resolveWasmOrtForRuntime = () => {
-  try {
-    return typeof import.meta.resolve === "function" ? import.meta.resolve(ONNX_RUNTIME_WEB_SPECIFIER) : undefined;
-  } catch {
-    return;
-  }
-};
-var importWasmOrtModule = async (specifier) => await import(specifier);
-var importWasmOrtModuleForRuntime = importWasmOrtModule;
-var importWasmOrtForRuntime = async () => {
-  const { createRequire: createRequireFn } = await import("node:module");
-  const requireFn = createRequireFn(import.meta.url);
-  const ortEntry = requireFn.resolve(ONNX_RUNTIME_WEB_SPECIFIER);
-  const ortSpecifier = resolveWasmOrtForRuntime() ?? ONNX_RUNTIME_WEB_SPECIFIER;
-  return {
-    module: await importWasmOrtModuleForRuntime(ortSpecifier),
-    entryPath: ortEntry
-  };
-};
-var importTransformersForRuntime = async () => {
-  return await importPluginModule(() => import("./transformers.node-hj754h7s.js"));
-};
-var importTransformersWasmFallbackForRuntime = async () => {
-  const webEntry = new URL(new URL(import.meta.url).pathname.endsWith(".ts") ? "../../../../dist/transformers-web.js" : "./transformers-web.js", import.meta.url).href;
-  return await importPluginModule(() => import(webEntry));
-};
-var importTransformersNodeWasmFallbackForRuntime = async () => {
-  const nodeWasmEntry = new URL(new URL(import.meta.url).pathname.endsWith(".ts") ? "../../../../dist/transformers-node-wasm.js" : "./transformers-node-wasm.js", import.meta.url).href;
-  return await importPluginModule(() => import(nodeWasmEntry));
-};
-var modelCacheDirForRuntime = () => workerData?.magicContextEmbeddingWorker && typeof workerData.modelCacheDir === "string" ? workerData.modelCacheDir : join(getMagicContextStorageDir(), "models");
-var logForRuntime = log;
-var injectWasmOrtForRuntime = injectWasmOrt;
-var loadedLocalEmbeddingRuntimes = new Map;
-var nextLocalEmbeddingRuntimeId = 1;
-function directoryBytes(path) {
-  let total = 0;
-  try {
-    for (const entry of readdirSync(path, { withFileTypes: true })) {
-      const entryPath = join(path, entry.name);
-      if (entry.isDirectory()) {
-        const childBytes = directoryBytes(entryPath);
-        if (childBytes === null)
-          return null;
-        total += childBytes;
-      } else if (entry.isFile()) {
-        total += statSync(entryPath).size;
-      }
-    }
-    return total;
-  } catch (error) {
-    return error.code === "ENOENT" ? 0 : null;
-  }
-}
-function getLocalEmbeddingNativeMemoryStats() {
-  const loaded = [...loadedLocalEmbeddingRuntimes.values()];
-  return {
-    loaded: loaded.length > 0,
-    providerCount: loaded.length,
-    models: [...new Set(loaded.map((entry) => entry.model))].sort(),
-    runtimes: [...new Set(loaded.map((entry) => entry.runtime))].sort(),
-    modelCacheBytes: loaded.length > 0 ? directoryBytes(modelCacheDirForRuntime()) : 0,
-    rssDeltaAtLoad: loaded.reduce((sum, entry) => sum + entry.rssDeltaAtLoad, 0),
-    externalDeltaAtLoad: loaded.reduce((sum, entry) => sum + entry.externalDeltaAtLoad, 0),
-    arrayBuffersDeltaAtLoad: loaded.reduce((sum, entry) => sum + entry.arrayBuffersDeltaAtLoad, 0)
-  };
-}
-async function ensureWasmOrtInjected() {
-  if (wasmRuntimeInjected)
-    return true;
-  if (!await injectWasmOrtForRuntime())
-    return false;
-  wasmRuntimeInjected = true;
-  return true;
-}
-async function injectWasmOrt() {
-  if (wasmRuntimeInjected)
-    return true;
-  try {
-    const { module: ortWeb, entryPath } = await importWasmOrtForRuntime();
-    if (ortWeb.env?.wasm) {
-      ortWeb.env.wasm.numThreads = 1;
-      ortWeb.env.wasm.wasmPaths = `${pathToFileURL(dirname(entryPath)).href}/`;
-    }
-    globalThis[Symbol.for("onnxruntime")] = ortWeb;
-    wasmRuntimeInjected = true;
-    return true;
-  } catch (error) {
-    log("[magic-context] failed to inject onnxruntime-web:", error instanceof Error ? error.message : String(error));
-    return false;
-  }
-}
-function likelyMuslHint() {
-  if (process.platform !== "linux" || typeof process.report?.getReport !== "function")
-    return "";
-  try {
-    const report = process.report.getReport();
-    return typeof report.header?.glibcVersionRuntime === "string" ? "" : " Linux process report has no glibc runtime version (musl likely).";
-  } catch {
-    return "";
-  }
-}
-function localEmbeddingRuntimeIsDisabled() {
-  return localEmbeddingRuntimeMode === "disabled";
-}
-
-class LocalEmbeddingFallbackError extends Error {
-  nativeError;
-  constructor(nativeError, wasmError) {
-    super("the native local embedding runtime and its WASM fallback both failed", {
-      cause: wasmError
-    });
-    this.name = "LocalEmbeddingFallbackError";
-    this.nativeError = nativeError;
-  }
-}
-
-class LocalEmbeddingFsUnavailableError extends Error {
-  code = "MC_EMBEDDING_FS_UNAVAILABLE";
-  constructor() {
-    super("MC_EMBEDDING_FS_UNAVAILABLE: Node WASM bundle has no filesystem cache");
-    this.name = "LocalEmbeddingFsUnavailableError";
-  }
-}
-async function importWasmTransformersForHost() {
-  const host = localEmbeddingHostForRuntime();
-  if (host.isElectron) {
-    return importTransformersForRuntime();
-  }
-  return host.hasNodeFilesystem ? importTransformersNodeWasmFallbackForRuntime() : importTransformersWasmFallbackForRuntime();
-}
-function disableLocalEmbeddingsAfterRuntimeFailure(detail) {
-  localEmbeddingRuntimeMode = "disabled";
-  logForRuntime(`[magic-context] local embeddings are disabled because both the onnxruntime-node native binding and the onnxruntime-web (WASM) fallback failed to load. Native failure: ${detail}. Run \`npx @cortexkit/magic-context@latest doctor\` for diagnostics; reinstalling repairs missing package files but cannot add a native binding that upstream does not ship. Alternatively, configure an \`openai-compatible\` embedding HTTP endpoint. Existing memories are unaffected.`);
-}
-async function loadTransformersForLocalEmbedding(runtimePreference) {
-  if (localEmbeddingRuntimeMode === "disabled") {
-    throw new Error("local embedding runtime is disabled");
-  }
-  const resolvedRuntime = resolveLocalEmbeddingRuntime(runtimePreference, localEmbeddingHostForRuntime());
-  if (resolvedRuntime === "wasm") {
-    if (!await ensureWasmOrtInjected()) {
-      disableLocalEmbeddingsAfterRuntimeFailure("the selected WASM runtime is unavailable");
-      throw new Error("onnxruntime-web failed to load");
-    }
-    return { module: await importWasmTransformersForHost(), usesWasm: true };
-  }
-  if (localEmbeddingRuntimeMode === "wasm") {
-    if (!await ensureWasmOrtInjected()) {
-      disableLocalEmbeddingsAfterRuntimeFailure("the previously selected WASM runtime is unavailable");
-      throw new Error("onnxruntime-web failed to load");
-    }
-    try {
-      return { module: await importWasmTransformersForHost(), usesWasm: true };
-    } catch (wasmError) {
-      disableLocalEmbeddingsAfterRuntimeFailure("the previously selected WASM runtime failed to load");
-      throw wasmError;
-    }
-  }
-  const electron = resolvedRuntime === "electron";
-  if (electron) {
-    const wasInjected = wasmRuntimeInjected;
-    if (await ensureWasmOrtInjected()) {
-      if (!wasInjected) {
-        logForRuntime("[magic-context] Electron detected — using onnxruntime-web (WASM) for embeddings (bypasses onnxruntime-node native load)");
-      }
-      return { module: await importTransformersForRuntime(), usesWasm: true };
-    }
-  }
-  try {
-    return { module: await importTransformersForRuntime(), usesWasm: false };
-  } catch (nativeError) {
-    if (!isNativeRuntimeMissingError(nativeError) || electron) {
-      throw nativeError;
-    }
-    if (!await ensureWasmOrtInjected()) {
-      disableLocalEmbeddingsAfterRuntimeFailure(nativeError instanceof Error ? nativeError.message : String(nativeError));
-      throw nativeError;
-    }
-    localEmbeddingRuntimeMode = "wasm";
-    try {
-      const module = await importWasmTransformersForHost();
-      logForRuntime("[magic-context] onnxruntime-node failed to load; using onnxruntime-web (WASM) for local embeddings. WASM inference is slower than native; a remote `openai-compatible` provider may be faster." + likelyMuslHint());
-      return { module, usesWasm: true };
-    } catch (wasmError) {
-      disableLocalEmbeddingsAfterRuntimeFailure(nativeError instanceof Error ? nativeError.message : String(nativeError));
-      throw new LocalEmbeddingFallbackError(nativeError, wasmError);
-    }
-  }
-}
-var DEFAULT_LOCAL_DTYPE = "fp32";
-async function withQuietConsole(fn) {
-  const origWarn = console.warn;
-  const origError = console.error;
-  const redirect = (...args) => {
-    const message = args.map((a) => typeof a === "string" ? a : String(a)).join(" ");
-    log(`[transformers] ${message}`);
-  };
-  console.warn = redirect;
-  console.error = redirect;
-  try {
-    return await fn();
-  } finally {
-    console.warn = origWarn;
-    console.error = origError;
-  }
-}
-function isNativeRuntimeMissingError(error) {
-  const message = error instanceof Error ? error.message : String(error ?? "");
-  const lower = message.toLowerCase();
-  const code = error?.code;
-  const name = error?.name;
-  if (code === "ERR_DLOPEN_FAILED" && lower.includes("onnxruntime")) {
-    return true;
-  }
-  if (lower.includes('could not load the "sharp" module'))
-    return true;
-  const mentionsNativeRuntime = lower.includes("onnxruntime-node") || lower.includes("onnxruntime_binding");
-  if (!mentionsNativeRuntime)
-    return false;
-  return code === "ERR_MODULE_NOT_FOUND" || name === "ResolveMessage" || lower.includes("cannot find package") || lower.includes("cannot find module") || lower.includes("err_module_not_found");
-}
-function isTransientLoadError(error) {
-  const message = error instanceof Error ? error.message : String(error ?? "");
-  if (!message)
-    return false;
-  const lower = message.toLowerCase();
-  return lower.includes("protobuf parsing failed") || lower.includes("unable to get model file path or buffer") || lower.includes("ebusy") || lower.includes("resource busy") || lower.includes("resource temporarily unavailable");
-}
-function isArrayLikeNumber(value) {
-  if (typeof value !== "object" || value === null || !("length" in value)) {
-    return false;
-  }
-  const arr = value;
-  if (typeof arr.length !== "number") {
-    return false;
-  }
-  return arr.length === 0 || typeof arr[0] === "number";
-}
-function toFloat32Array(values) {
-  return values instanceof Float32Array ? new Float32Array(values) : Float32Array.from(Array.from(values));
-}
-function extractBatchEmbeddings(result, expectedCount) {
-  const { data } = result;
-  if (Array.isArray(data) && data.length === expectedCount && data.every((entry) => typeof entry !== "number" && isArrayLikeNumber(entry))) {
-    return data.map((entry) => toFloat32Array(entry));
-  }
-  if (!isArrayLikeNumber(data)) {
-    log("[magic-context] embedding batch returned unexpected data shape");
-    return Array.from({ length: expectedCount }, () => null);
-  }
-  const flatData = toFloat32Array(data);
-  const dimension = result.dims?.at(-1) ?? flatData.length / expectedCount;
-  if (!Number.isInteger(dimension) || dimension <= 0 || flatData.length !== expectedCount * dimension) {
-    log("[magic-context] embedding batch returned invalid dimensions");
-    return Array.from({ length: expectedCount }, () => null);
-  }
-  const embeddings = [];
-  for (let index = 0;index < expectedCount; index++) {
-    embeddings.push(flatData.slice(index * dimension, (index + 1) * dimension));
-  }
-  return embeddings;
-}
-
-class LocalEmbeddingProvider {
-  modelId;
-  maxInputTokens;
-  memoryStatsId = nextLocalEmbeddingRuntimeId++;
-  model;
-  dtype;
-  runtimePreference;
-  pipeline = null;
-  workerClient;
-  workerLoaded = false;
-  initPromise = null;
-  lastFailureReason = null;
-  usesWasm = false;
-  inFlight = 0;
-  disposing = false;
-  disposePromise = null;
-  inFlightWaiters = [];
-  constructor(model = DEFAULT_LOCAL_EMBEDDING_MODEL, maxInputTokens = 512, dtype = DEFAULT_LOCAL_DTYPE, runtimePreference = "auto") {
-    this.model = model;
-    this.maxInputTokens = maxInputTokens;
-    this.dtype = dtype || DEFAULT_LOCAL_DTYPE;
-    this.runtimePreference = runtimePreference;
-    this.workerClient = !workerData?.magicContextEmbeddingWorker && !useInThreadTestRuntime ? (workerFactoryForTests ?? ((data) => new EmbeddingWorkerClient(data)))({
-      magicContextEmbeddingWorker: true,
-      modelCacheDir: modelCacheDirForRuntime(),
-      enforcePrivateStoragePermissions: shouldEnforcePrivateStoragePermissions(),
-      harness: getHarness(),
-      model,
-      maxInputTokens,
-      dtype: this.dtype,
-      runtimePreference
-    }) : null;
-    this.modelId = getEmbeddingProviderIdentity({
-      provider: "local",
-      model,
-      local_runtime: runtimePreference,
-      ...dtype && dtype !== DEFAULT_LOCAL_DTYPE ? { local_dtype: dtype } : {}
-    });
-  }
-  async initialize() {
-    if (this.workerClient && !this.disposing) {
-      if (this.workerLoaded && this.workerClient.isRunning())
-        return true;
-      try {
-        const reply = await this.workerClient.request();
-        this.recordWorkerReply(reply);
-        return reply.loaded;
-      } catch (error) {
-        this.recordWorkerFailure(error);
-        return false;
-      }
-    }
-    if (this.disposing) {
-      return false;
-    }
-    if (this.pipeline) {
-      return true;
-    }
-    if (localEmbeddingRuntimeMode === "disabled") {
-      this.lastFailureReason = localEmbeddingProcessFailure ?? classifyLocalEmbeddingFailure(new Error("local embedding runtime is disabled"));
-      return false;
-    }
-    if (this.initPromise) {
-      await this.initPromise;
-      return this.pipeline !== null;
-    }
-    const memoryBeforeLoad = process.memoryUsage();
-    this.initPromise = (async () => {
-      try {
-        if (this.disposing) {
-          return;
-        }
-        const { module: transformersModule, usesWasm } = await loadTransformersForLocalEmbedding(this.runtimePreference);
-        this.usesWasm = usesWasm;
-        const env = transformersModule.env;
-        configureTransformersRemoteHost(env);
-        const LogLevel = transformersModule.LogLevel;
-        if (LogLevel && "ERROR" in LogLevel) {
-          env.logLevel = LogLevel.ERROR;
-        }
-        const host = localEmbeddingHostForRuntime();
-        if (usesWasm && host.hasNodeFilesystem && !host.isElectron && (env.useFS !== true || env.useFSCache !== true)) {
-          throw new LocalEmbeddingFsUnavailableError;
-        }
-        const modelCacheDir = modelCacheDirForRuntime();
-        try {
-          if (shouldEnforcePrivateStoragePermissions()) {
-            mkdirSync(modelCacheDir, { recursive: true, mode: 448 });
-            if (process.platform !== "win32") {
-              try {
-                chmodSync(modelCacheDir, 448);
-              } catch {}
-            }
-          } else {
-            mkdirSync(modelCacheDir, { recursive: true });
-          }
-          env.cacheDir = modelCacheDir;
-        } catch {
-          log("[magic-context] could not create model cache dir, using library default");
-        }
-        const createPipeline = transformersModule.pipeline;
-        const lockPath = join(modelCacheDir, ".load.lock");
-        const releaseLock = await acquireModelLoadLock(lockPath);
-        const stopHeartbeat = startLockHeartbeat(lockPath);
-        try {
-          const MAX_ATTEMPTS = 3;
-          let lastError;
-          for (let attempt = 1;attempt <= MAX_ATTEMPTS; attempt++) {
-            try {
-              const pipeline = await withQuietConsole(() => createPipeline("feature-extraction", this.model, {
-                dtype: this.dtype,
-                ...usesWasm ? { device: "auto" } : {}
-              }));
-              if (this.disposing) {
-                await pipeline.dispose?.();
-                this.pipeline = null;
-              } else {
-                this.pipeline = pipeline;
-              }
-              lastError = undefined;
-              break;
-            } catch (error) {
-              lastError = error;
-              if (!isTransientLoadError(error) || attempt === MAX_ATTEMPTS) {
-                break;
-              }
-              const delayMs = 300 * attempt + Math.floor(Math.random() * 200);
-              log(`[magic-context] embedding model load attempt ${attempt}/${MAX_ATTEMPTS} failed transiently, retrying in ${delayMs}ms`);
-              await new Promise((resolve) => setTimeout(resolve, delayMs));
-            }
-          }
-          if (this.pipeline) {
-            this.lastFailureReason = null;
-            localEmbeddingProcessFailure = null;
-            const memoryAfterLoad = process.memoryUsage();
-            loadedLocalEmbeddingRuntimes.set(this.memoryStatsId, {
-              model: this.model,
-              runtime: this.usesWasm ? "wasm" : "native",
-              rssDeltaAtLoad: memoryAfterLoad.rss - memoryBeforeLoad.rss,
-              externalDeltaAtLoad: memoryAfterLoad.external - memoryBeforeLoad.external,
-              arrayBuffersDeltaAtLoad: memoryAfterLoad.arrayBuffers - memoryBeforeLoad.arrayBuffers
-            });
-            log(`[magic-context] embedding model loaded: ${this.model}`);
-          } else if (this.disposing) {
-            return;
-          } else {
-            throw lastError ?? new Error("unknown embedding load failure");
-          }
-        } finally {
-          stopHeartbeat();
-          await releaseLock();
-        }
-      } catch (error) {
-        const nativeError = error instanceof LocalEmbeddingFallbackError ? error.nativeError : undefined;
-        const failure = classifyLocalEmbeddingFailure(error, {
-          platform: process.platform,
-          arch: process.arch,
-          usesWasm: this.usesWasm,
-          nativeError
-        });
-        this.lastFailureReason = failure;
-        localEmbeddingProcessFailure = failure;
-        if (!localEmbeddingRuntimeIsDisabled() && isNativeRuntimeMissingError(error)) {
-          disableLocalEmbeddingsAfterRuntimeFailure(error instanceof Error ? error.message : String(error));
-        }
-        logForRuntime(`[magic-context] embedding model failed to load (${failure.class}: ${failure.reason}):`, error);
-        this.pipeline = null;
-      } finally {
-        this.initPromise = null;
-      }
-    })();
-    await this.initPromise;
-    return this.pipeline !== null;
-  }
-  waitForInFlightToDrain() {
-    if (this.inFlight === 0) {
-      return Promise.resolve();
-    }
-    return new Promise((resolve) => {
-      this.inFlightWaiters.push(resolve);
-    });
-  }
-  finishInFlight() {
-    this.inFlight = Math.max(0, this.inFlight - 1);
-    if (this.inFlight !== 0)
-      return;
-    const waiters = this.inFlightWaiters.splice(0);
-    for (const waiter of waiters) {
-      waiter();
-    }
-  }
-  async embed(text, signal, _purpose) {
-    if (this.workerClient)
-      return (await this.embedBatch([text], signal, _purpose))[0] ?? null;
-    if (signal?.aborted)
-      return null;
-    if (this.disposing)
-      return null;
-    this.inFlight += 1;
-    try {
-      if (!await this.initialize()) {
-        return null;
-      }
-      const pipeline = this.pipeline;
-      if (!pipeline) {
-        return null;
-      }
-      const result = await withQuietConsole(() => pipeline(text, {
-        pooling: "mean",
-        normalize: true
-      }));
-      const embedding = extractBatchEmbeddings(result, 1)[0] ?? null;
-      if (!embedding) {
-        this.lastFailureReason = classifyLocalEmbeddingFailure(new Error("local embedding pipeline returned no vector"), { usesWasm: this.usesWasm });
-      } else {
-        this.lastFailureReason = null;
-      }
-      return embedding;
-    } catch (error) {
-      const failure = classifyLocalEmbeddingFailure(error, { usesWasm: this.usesWasm });
-      this.lastFailureReason = failure;
-      logForRuntime(`[magic-context] embedding failed (${failure.class}: ${failure.reason}):`, error);
-      return null;
-    } finally {
-      this.finishInFlight();
-    }
-  }
-  async embedBatch(texts, signal, _purpose) {
-    if (this.workerClient) {
-      if (!texts.length)
-        return [];
-      if (signal?.aborted || this.disposing)
-        return texts.map(() => null);
-      try {
-        const reply = await this.workerClient.request(texts, signal);
-        this.recordWorkerReply(reply);
-        return reply.vectors ?? texts.map(() => null);
-      } catch (error) {
-        this.recordWorkerFailure(error);
-        return texts.map(() => null);
-      }
-    }
-    if (texts.length === 0) {
-      return [];
-    }
-    if (signal?.aborted) {
-      return Array.from({ length: texts.length }, () => null);
-    }
-    if (this.disposing) {
-      return Array.from({ length: texts.length }, () => null);
-    }
-    this.inFlight += 1;
-    try {
-      if (!await this.initialize()) {
-        return Array.from({ length: texts.length }, () => null);
-      }
-      const pipeline = this.pipeline;
-      if (!pipeline) {
-        return Array.from({ length: texts.length }, () => null);
-      }
-      const result = await withQuietConsole(() => pipeline(texts, {
-        pooling: "mean",
-        normalize: true
-      }));
-      const embeddings = extractBatchEmbeddings(result, texts.length);
-      if (embeddings.every((embedding) => embedding === null)) {
-        this.lastFailureReason = classifyLocalEmbeddingFailure(new Error("local embedding pipeline returned no vectors"), { usesWasm: this.usesWasm });
-      } else {
-        this.lastFailureReason = null;
-      }
-      return embeddings;
-    } catch (error) {
-      const failure = classifyLocalEmbeddingFailure(error, { usesWasm: this.usesWasm });
-      this.lastFailureReason = failure;
-      logForRuntime(`[magic-context] embedding batch failed (${failure.class}: ${failure.reason}):`, error);
-      return Array.from({ length: texts.length }, () => null);
-    } finally {
-      this.finishInFlight();
-    }
-  }
-  recordWorkerReply(reply) {
-    this.workerLoaded = reply.loaded;
-    this.lastFailureReason = reply.failure ?? null;
-    if (reply.loaded && reply.stats) {
-      loadedLocalEmbeddingRuntimes.set(this.memoryStatsId, {
-        model: this.model,
-        runtime: reply.stats.runtimes[0] ?? "wasm",
-        rssDeltaAtLoad: reply.stats.rssDeltaAtLoad,
-        externalDeltaAtLoad: reply.stats.externalDeltaAtLoad,
-        arrayBuffersDeltaAtLoad: reply.stats.arrayBuffersDeltaAtLoad
-      });
-    } else
-      loadedLocalEmbeddingRuntimes.delete(this.memoryStatsId);
-  }
-  recordWorkerFailure(error) {
-    loadedLocalEmbeddingRuntimes.delete(this.memoryStatsId);
-    this.workerLoaded = false;
-    this.lastFailureReason = classifyLocalEmbeddingFailure(error);
-    logForRuntime("[magic-context] embedding worker failed:", error);
-  }
-  async dispose() {
-    if (this.workerClient) {
-      this.disposing = true;
-      this.workerLoaded = false;
-      loadedLocalEmbeddingRuntimes.delete(this.memoryStatsId);
-      await this.workerClient.dispose();
-      return;
-    }
-    if (this.disposePromise) {
-      return this.disposePromise;
-    }
-    this.disposing = true;
-    this.disposePromise = (async () => {
-      if (this.initPromise) {
-        await this.initPromise;
-      }
-      await this.waitForInFlightToDrain();
-      const pipelineToDispose = this.pipeline;
-      this.pipeline = null;
-      this.initPromise = null;
-      loadedLocalEmbeddingRuntimes.delete(this.memoryStatsId);
-      if (!pipelineToDispose) {
-        return;
-      }
-      try {
-        await pipelineToDispose.dispose?.();
-      } catch (error) {
-        log("[magic-context] embedding model dispose failed:", error);
-      }
-    })();
-    return this.disposePromise;
-  }
-  isLoaded() {
-    return this.workerClient ? this.workerLoaded && this.workerClient.isRunning() : this.pipeline !== null;
-  }
-  getLastFailureReason() {
-    return this.lastFailureReason;
-  }
-}
-
-export { string, unknown, array, object, union, tuple, record, withContentLanguageDirective, buildPrimaryLanguageDirective, parseCron, nextOccurrence, nextDueAtMs, promptSurfaceConfigIdentity, resolveModelConfigValue, resolvePromptSurface, DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE, DEFAULT_HISTORIAN_TIMEOUT_MS, PROTECTED_TOKENS_MIN, DEFAULT_LOCAL_EMBEDDING_MODEL, PER_HARNESS_MIGRATION_INVENTORY, PER_HARNESS_MODEL_KEYS, ConfigProfilesSchema, DREAM_TASK_PROMOTION_DEFAULTS, MagicContextConfigSchema, LIVE_RELOAD_CONFIG_PATHS, deriveDefaultProtectedTokens, Priority, AdmissionClass, SocketClosedError, SocketTimeoutError, StaleRouteHandleError, SubcClient, isConsumerReconnectTransient, connectionFileExists, SYNAPSE_DEFAULT_MODEL, isSynapseEmbeddingTruncated, toSynapseLaneDescriptor, formatSynapseLaneDescriptor, getSynapseBatchRequestKey, SynapseEmbeddingProvider, dominantEmbeddingFailure, embeddingModelsMatch, resolveEmbeddingTextPrefixes, computeNormalizedHash, getEmbeddingProviderIdentity, resolveLocalEmbeddingWorkerRuntime, getLocalEmbeddingNativeMemoryStats, LocalEmbeddingProvider };
+export { string, unknown, array, object, union, tuple, record, withContentLanguageDirective, buildPrimaryLanguageDirective, parseCron, nextOccurrence, nextDueAtMs, promptSurfaceConfigIdentity, resolveModelConfigValue, resolvePromptSurface, DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE, DEFAULT_HISTORIAN_TIMEOUT_MS, PROTECTED_TOKENS_MIN, DEFAULT_LOCAL_EMBEDDING_MODEL, PER_HARNESS_MIGRATION_INVENTORY, PER_HARNESS_MODEL_KEYS, ConfigProfilesSchema, DREAM_TASK_PROMOTION_DEFAULTS, MagicContextConfigSchema, LIVE_RELOAD_CONFIG_PATHS, deriveDefaultProtectedTokens };