@cortexkit/opencode-magic-context 0.47.0 → 0.48.0

package/dist/{index-m5fe6jch.js → index-bhvjj0ys.js}

@@ -1,19 +1,22 @@
 import {
-  toolTemplateError,
-  DEFAULT_PROTECTED_TOOLS,
-  mergeProtectedTools
-} from "./index-rrbbspwh.js";
+  toolTemplateError
+} from "./index-mfkzp7qj.js";
+import {
+  getSynapseLaneIdentity
+} from "./index-72nhv486.js";
+import {
+  getHarness2
+} from "./index-pavzsdc6.js";
 import {
-  getHarness,
   getMagicContextStorageDir
-} from "./index-q6hef7fh.js";
+} from "./index-0sahzkwr.js";
 import {
   importPluginModule,
-  log
-} from "./index-hybnrwq0.js";
+  log2
+} from "./index-8j7gqj40.js";
 import {
-  estimateTokens
-} from "./index-5eqk6z3s.js";
+  computeNormalizedHash
+} from "./index-2bvekkfy.js";
 import {
   shouldEnforcePrivateStoragePermissions,
   ensureStorageDirectorySync,
@@ -21,6 +24,10 @@ import {
   writeStorageFileHandleAsync,
   createStorageFileHandleAsync
 } from "./index-1bc61ans.js";
+import {
+  DEFAULT_PROTECTED_TOOLS,
+  mergeProtectedTools
+} from "./index-d9vfe7xq.js";
 import {
   modelRefLookupOrder
 } from "./index-avwt563y.js";
@@ -97,13 +104,6 @@ function buildPrimaryLanguageDirective(language) {
   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/memory/embedding-local.ts
-import { readdirSync, statSync } from "node:fs";
-import { stat, unlink } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { pathToFileURL } from "node:url";
-import { workerData } from "node:worker_threads";
-
 // src/config/schema/magic-context.ts
 import { homedir } from "node:os";
 
@@ -5610,7 +5610,7 @@ var MagicContextConfigSchema = object({
   allow_home_project: boolean2().default(false).describe("Allow Magic Context sessions launched from the exact canonical home directory. A non-git home uses its deterministic dir: identity; a home repository uses its git: identity. USER-LEVEL ONLY: project config is ignored. The home identity is excluded from registry seed exports, never resolves descendants by containment, and cannot join a workspace."),
   mural: object({
     enabled: boolean2().default(false),
-    model: string().trim().min(1).optional().describe("Model for the compress-cues task that compresses each memory into a mural cue. The mural image itself is rendered deterministically (no author model).")
+    model: unknown().optional().describe("Deprecated: ignored. compress-cues now uses the dreamer model for each harness, like every other dreamer task; override it with dreamer.opencode.tasks.compress-cues.model (or the pi/omp equivalent). Remove this key; it no longer does anything.").meta({ deprecated: true })
   }).default({ enabled: false }).describe("Experimental mural: a single deterministically-rendered image of project memories that did not fit the context budget. Cues are compressed per-memory by the compress-cues dreamer task."),
   transform_mode: _enum(["ts", "rust"]).default("ts").describe('Experimental: routes the entire Magic Context runtime for the project through the ck-mc Rust module over subc (requires user-level `subc` config); "ts" is the current TypeScript pipeline.'),
   auto_update: boolean2().optional().describe("Enable automatic npm self-update checks for the OpenCode plugin. Security: USER-only in config loader, so hostile project configs cannot suppress updates."),
@@ -5620,8 +5620,9 @@ var MagicContextConfigSchema = object({
   historian: HistorianConfigSchema.describe("Historian metadata plus independent strict OpenCode, Pi, and OMP execution blocks. Retained metadata stays at historian; model, fallback_models, variant, and thinking_level belong only in historian.opencode, historian.pi, or historian.omp."),
   dreamer: DreamerConfigSchema.optional().describe("Dreamer metadata and scheduling plus independent strict OpenCode, Pi, and OMP execution blocks. schedule and promotion_threshold stay at dreamer.tasks; model, fallback_models, variant, thinking_level, and timeout_minutes belong only in the matching harness block."),
   smart_notes: object({
+    enabled: boolean2().default(true).describe("Enable smart-note authoring and condition evaluation. User-level only: tool definitions are process-wide. Changes require a host restart and rebuild each session's cached prompt once. Pending notes remain stored and unchecked; already-ready notes still surface."),
     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."),
+  }).default({ enabled: true, 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, 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([
@@ -5726,7 +5727,6 @@ var MagicContextConfigSchema = object({
 });
 var LIVE_RELOAD_CONFIG_PATHS = [
   "cache_ttl",
-  "mural.model",
   "toast_duration_ms",
   "historian.opencode.model",
   "historian.opencode.fallback_models",
@@ -5797,6 +5797,125 @@ function deriveDefaultProtectedTokens(usableSoft) {
   return Math.min(64000, Math.max(lowerBound, target));
 }
 
+// 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-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-local.ts
+import { readdirSync, statSync } from "node:fs";
+import { stat, unlink } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { workerData } from "node:worker_threads";
+
 // src/features/magic-context/memory/embedding-failure.ts
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error ?? "unknown error");
@@ -5892,2426 +6011,6 @@ function dominantEmbeddingFailure(failures) {
   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 {
@@ -8359,7 +6058,7 @@ class EmbeddingWorkerClient {
         request.reject(error);
       }
       this.pending.clear();
-      log("[magic-context] embedding worker exited unexpectedly:", error);
+      log2("[magic-context] embedding worker exited unexpectedly:", error);
       worker.terminate();
     };
     worker.on("error", fail);
@@ -8493,7 +6192,7 @@ async function acquireModelLoadLock(lockPath) {
       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`);
+          log2(`[magic-context] embedding-load lock stale (>${STALE_LOCK_MS}ms), taking over`);
           try {
             await unlink(lockPath);
           } catch {}
@@ -8556,7 +6255,7 @@ var importTransformersNodeWasmFallbackForRuntime = async () => {
   return await importPluginModule(() => import(nodeWasmEntry));
 };
 var modelCacheDirForRuntime = () => workerData?.magicContextEmbeddingWorker && typeof workerData.modelCacheDir === "string" ? workerData.modelCacheDir : join(getMagicContextStorageDir(), "models");
-var logForRuntime = log;
+var logForRuntime = log2;
 var injectWasmOrtForRuntime = injectWasmOrt;
 var loadedLocalEmbeddingRuntimes = new Map;
 var nextLocalEmbeddingRuntimeId = 1;
@@ -8613,7 +6312,7 @@ async function injectWasmOrt() {
     wasmRuntimeInjected = true;
     return true;
   } catch (error) {
-    log("[magic-context] failed to inject onnxruntime-web:", error instanceof Error ? error.message : String(error));
+    log2("[magic-context] failed to inject onnxruntime-web:", error instanceof Error ? error.message : String(error));
     return false;
   }
 }
@@ -8721,7 +6420,7 @@ async function withQuietConsole(fn) {
   const origError = console.error;
   const redirect = (...args) => {
     const message = args.map((a) => typeof a === "string" ? a : String(a)).join(" ");
-    log(`[transformers] ${message}`);
+    log2(`[transformers] ${message}`);
   };
   console.warn = redirect;
   console.error = redirect;
@@ -8773,13 +6472,13 @@ function extractBatchEmbeddings(result, expectedCount) {
     return data.map((entry) => toFloat32Array(entry));
   }
   if (!isArrayLikeNumber(data)) {
-    log("[magic-context] embedding batch returned unexpected data shape");
+    log2("[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");
+    log2("[magic-context] embedding batch returned invalid dimensions");
     return Array.from({ length: expectedCount }, () => null);
   }
   const embeddings = [];
@@ -8815,7 +6514,7 @@ class LocalEmbeddingProvider {
       magicContextEmbeddingWorker: true,
       modelCacheDir: modelCacheDirForRuntime(),
       enforcePrivateStoragePermissions: shouldEnforcePrivateStoragePermissions(),
-      harness: getHarness(),
+      harness: getHarness2(),
       model,
       maxInputTokens,
       dtype: this.dtype,
@@ -8878,7 +6577,7 @@ class LocalEmbeddingProvider {
           ensureStorageDirectorySync(modelCacheDir);
           env.cacheDir = modelCacheDir;
         } catch {
-          log("[magic-context] could not create model cache dir, using library default");
+          log2("[magic-context] could not create model cache dir, using library default");
         }
         const createPipeline = transformersModule.pipeline;
         const lockPath = join(modelCacheDir, ".load.lock");
@@ -8907,7 +6606,7 @@ class LocalEmbeddingProvider {
                 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`);
+              log2(`[magic-context] embedding model load attempt ${attempt}/${MAX_ATTEMPTS} failed transiently, retrying in ${delayMs}ms`);
               await new Promise((resolve) => setTimeout(resolve, delayMs));
             }
           }
@@ -8922,7 +6621,7 @@ class LocalEmbeddingProvider {
               externalDeltaAtLoad: memoryAfterLoad.external - memoryBeforeLoad.external,
               arrayBuffersDeltaAtLoad: memoryAfterLoad.arrayBuffers - memoryBeforeLoad.arrayBuffers
             });
-            log(`[magic-context] embedding model loaded: ${this.model}`);
+            log2(`[magic-context] embedding model loaded: ${this.model}`);
           } else if (this.disposing) {
             return;
           } else {
@@ -9107,7 +6806,7 @@ class LocalEmbeddingProvider {
       try {
         await pipelineToDispose.dispose?.();
       } catch (error) {
-        log("[magic-context] embedding model dispose failed:", error);
+        log2("[magic-context] embedding model dispose failed:", error);
       }
     })();
     return this.disposePromise;
@@ -9120,4 +6819,4 @@ class LocalEmbeddingProvider {
   }
 }
 
-export { isValidLanguageCode, withContentLanguageDirective, buildPrimaryLanguageDirective, string, unknown, array, object, union, tuple, record, 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, embeddingModelsMatch, resolveEmbeddingTextPrefixes, computeNormalizedHash, getEmbeddingProviderIdentity, dominantEmbeddingFailure, resolveLocalEmbeddingWorkerRuntime, getLocalEmbeddingNativeMemoryStats, LocalEmbeddingProvider };
+export { isValidLanguageCode, withContentLanguageDirective, buildPrimaryLanguageDirective, string, unknown, array, object, union, tuple, record, 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, embeddingModelsMatch, resolveEmbeddingTextPrefixes, getEmbeddingProviderIdentity, dominantEmbeddingFailure, resolveLocalEmbeddingWorkerRuntime, getLocalEmbeddingNativeMemoryStats, LocalEmbeddingProvider };