@cortexkit/pi-magic-context 0.32.1 → 0.32.3

package/dist/subagent-entry.js

@@ -8018,9 +8018,27 @@ var require_src2 = __commonJS((exports, module) => {
 
 // ../plugin/src/features/magic-context/storage-db.ts
 import { chmodSync, copyFileSync, cpSync, existsSync as existsSync4, mkdirSync as mkdirSync3, mkdtempSync } from "node:fs";
-init_data_path();
 import { dirname as dirname2, join as join3 } from "node:path";
 
+// ../plugin/src/plugin/boot-quiet.ts
+var BOOT_QUIET_MS = 120000;
+var bootQuietUntilMs = 0;
+function beginBootQuietPeriod(now = Date.now()) {
+  if (bootQuietUntilMs === 0)
+    bootQuietUntilMs = now + BOOT_QUIET_MS;
+}
+function bootQuietRemainingMs(now = Date.now()) {
+  return Math.max(0, bootQuietUntilMs - now);
+}
+function scheduleAfterBootQuiet(task, additionalDelayMs = 0) {
+  const timer = setTimeout(task, bootQuietRemainingMs() + Math.max(0, additionalDelayMs));
+  timer.unref?.();
+  return timer;
+}
+
+// ../plugin/src/features/magic-context/storage-db.ts
+init_data_path();
+
 // ../plugin/src/shared/error-message.ts
 function getErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
@@ -8901,6 +8919,22 @@ function bumpEpochsForWorkspaceMemberSet(db, identities, now = Date.now()) {
 }
 
 // ../plugin/src/features/magic-context/migrations.ts
+var MIGRATION_LOCK_RETRY_DELAYS_MS = [1000, 2000, 4000, 8000, 15000];
+
+class MigrationLockBusyError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MigrationLockBusyError";
+  }
+}
+function isSqliteLockError(error) {
+  if (!error || typeof error !== "object")
+    return false;
+  const candidate = error;
+  if (candidate.code === "SQLITE_BUSY" || candidate.code === "SQLITE_LOCKED")
+    return true;
+  return typeof candidate.message === "string" && /database is locked|sqlite_(busy|locked)/i.test(candidate.message);
+}
 function tableExists2(db, name) {
   return Boolean(db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name = ?").get(name));
 }
@@ -10260,6 +10294,80 @@ var MIGRATIONS = [
         ensureColumn(db, "session_meta", "emergency_recovery_origin", "TEXT DEFAULT ''");
       }
     }
+  },
+  {
+    version: 53,
+    description: "add Synapse batch, shadow, and measurement storage",
+    up(db) {
+      db.exec(`
+                CREATE TABLE IF NOT EXISTS embedding_registrations (
+                    project_path TEXT PRIMARY KEY,
+                    provider_identity TEXT NOT NULL DEFAULT '',
+                    model_id TEXT NOT NULL DEFAULT '',
+                    chunk_model_id TEXT NOT NULL DEFAULT '',
+                    fingerprint TEXT NOT NULL DEFAULT '',
+                    table_epoch INTEGER NOT NULL DEFAULT 0,
+                    dims INTEGER NOT NULL DEFAULT 0,
+                    provenance_json TEXT NOT NULL DEFAULT '{}',
+                    generation INTEGER NOT NULL DEFAULT 0,
+                    updated_at INTEGER NOT NULL DEFAULT 0
+                );
+                CREATE TABLE IF NOT EXISTS synapse_batch_ledger (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    session_id TEXT NOT NULL,
+                    project_path TEXT NOT NULL DEFAULT '',
+                    scope TEXT NOT NULL DEFAULT '',
+                    manifest_json TEXT NOT NULL DEFAULT '{}',
+                    request_key TEXT NOT NULL DEFAULT '',
+                    job_id TEXT,
+                    cursor TEXT,
+                    status TEXT NOT NULL DEFAULT 'pending',
+                    created_at INTEGER NOT NULL DEFAULT 0,
+                    updated_at INTEGER NOT NULL DEFAULT 0,
+                    UNIQUE(session_id, request_key)
+                );
+                CREATE INDEX IF NOT EXISTS idx_synapse_batch_ledger_session
+                    ON synapse_batch_ledger(session_id, updated_at);
+                CREATE TABLE IF NOT EXISTS shadow_embedding_registrations (
+                    project_path TEXT NOT NULL,
+                    scope TEXT NOT NULL CHECK(scope IN ('memory', 'commit', 'chunk')),
+                    model_id TEXT NOT NULL,
+                    generation INTEGER NOT NULL DEFAULT 0,
+                    fingerprint TEXT NOT NULL DEFAULT '',
+                    table_epoch INTEGER NOT NULL DEFAULT 0,
+                    dims INTEGER NOT NULL DEFAULT 0,
+                    provenance_json TEXT NOT NULL DEFAULT '{}',
+                    updated_at INTEGER NOT NULL DEFAULT 0,
+                    PRIMARY KEY(project_path, scope, model_id)
+                );
+                CREATE TABLE IF NOT EXISTS embedding_measurement_corpus (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    session_id TEXT NOT NULL,
+                    project_path TEXT NOT NULL DEFAULT '',
+                    dedup_key TEXT NOT NULL DEFAULT '',
+                    cohort_key TEXT NOT NULL DEFAULT '',
+                    query_text_hash TEXT NOT NULL DEFAULT '',
+                    primary_result_ids_json TEXT NOT NULL DEFAULT '[]',
+                    shadow_result_ids_json TEXT NOT NULL DEFAULT '[]',
+                    primary_latency_ms INTEGER,
+                    shadow_latency_ms INTEGER,
+                    primary_failed INTEGER NOT NULL DEFAULT 0,
+                    shadow_failed INTEGER NOT NULL DEFAULT 0,
+                    primary_model_id TEXT NOT NULL DEFAULT '',
+                    shadow_model_id TEXT NOT NULL DEFAULT '',
+                    primary_fingerprint TEXT NOT NULL DEFAULT '',
+                    shadow_fingerprint TEXT NOT NULL DEFAULT '',
+                    primary_epoch INTEGER NOT NULL DEFAULT 0,
+                    shadow_epoch INTEGER NOT NULL DEFAULT 0,
+                    corpus_hash TEXT NOT NULL DEFAULT '',
+                    coverage_json TEXT NOT NULL DEFAULT '{}',
+                    created_at INTEGER NOT NULL DEFAULT 0,
+                    UNIQUE(dedup_key, cohort_key)
+                );
+                CREATE INDEX IF NOT EXISTS idx_embedding_measurement_session
+                    ON embedding_measurement_corpus(session_id, created_at);
+            `);
+    }
   }
 ];
 var LATEST_MIGRATION_VERSION = MIGRATIONS.reduce((max, m) => Math.max(max, m.version), 0);
@@ -10288,7 +10396,14 @@ function isSiblingMigrationConflict(db, error, version) {
   return confirmed != null;
 }
 function runMigrations(db) {
-  ensureMigrationsTable(db);
+  try {
+    ensureMigrationsTable(db);
+  } catch (error) {
+    if (isSqliteLockError(error)) {
+      throw new MigrationLockBusyError(`failed to prepare migration lock: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    throw error;
+  }
   let loggedPlan = false;
   while (true) {
     let migration;
@@ -10312,6 +10427,9 @@ function runMigrations(db) {
         break;
       log(`[migrations] applied v${migration.version}: ${migration.description}`);
     } catch (error) {
+      if (!migration && isSqliteLockError(error)) {
+        throw new MigrationLockBusyError(`failed to acquire migration write lock: ${error instanceof Error ? error.message : String(error)}`);
+      }
       if (migration && isSiblingMigrationConflict(db, error, migration.version)) {
         log(`[migrations] v${migration.version} already applied by sibling instance — resuming with re-read version`);
         const reReadVersion = getCurrentVersion(db);
@@ -10329,6 +10447,26 @@ function runMigrations(db) {
     log(`[migrations] schema version now: ${MIGRATIONS[MIGRATIONS.length - 1].version}`);
   }
 }
+async function runMigrationsWithRetry(db, options = {}) {
+  const retryDelaysMs = options.retryDelaysMs ?? MIGRATION_LOCK_RETRY_DELAYS_MS;
+  const sleep = options.sleep ?? ((delayMs) => new Promise((resolve) => setTimeout(resolve, delayMs)));
+  const totalAttempts = retryDelaysMs.length + 1;
+  for (let attempt = 1;attempt <= totalAttempts; attempt += 1) {
+    log(`[migrations] migration lock check attempt ${attempt}/${totalAttempts}`);
+    try {
+      runMigrations(db);
+      return;
+    } catch (error) {
+      if (!(error instanceof MigrationLockBusyError))
+        throw error;
+      const delayMs = retryDelaysMs[attempt - 1];
+      if (delayMs === undefined)
+        throw error;
+      log(`[migrations] migration write lock is busy; retrying attempt ${attempt + 1}/${totalAttempts} in ${delayMs}ms`);
+      await sleep(delayMs);
+    }
+  }
+}
 
 // ../plugin/src/shared/commit-detection.ts
 var HASH_HEX = "[0-9a-f]{7,12}";
@@ -143242,11 +143380,12 @@ function backfillToolOwnersInChunks(db, result) {
 
 // ../plugin/src/features/magic-context/storage-db.ts
 var databases = new Map;
+var pendingAsyncOpens = new Map;
 var persistenceByDatabase = new WeakMap;
 var persistenceErrorByDatabase = new WeakMap;
 var pathByDatabase = new WeakMap;
 var lastSchemaFenceRejection = null;
-var LATEST_SUPPORTED_VERSION = 52;
+var LATEST_SUPPORTED_VERSION = 53;
 var PERMISSIONS_ENFORCEABLE = process.platform !== "win32";
 function ensureSecureStorageDir(dir) {
   mkdirSync3(dir, { recursive: true, mode: 448 });
@@ -143376,6 +143515,34 @@ function runSqliteOptimize(db) {
     db.exec("PRAGMA optimize");
   } catch {}
 }
+function finishDatabaseOpen(db, dbPath, explicitDbPath, latestSupportedVersion) {
+  if (!enforceSchemaFence(db, dbPath, latestSupportedVersion)) {
+    closeQuietly(db);
+    return null;
+  }
+  healWedgedChannel2Claims(db);
+  if (!explicitDbPath) {
+    const runBackfill = () => {
+      try {
+        runToolOwnerBackfill(db);
+      } catch (error) {
+        log(`[magic-context] tool-owner backfill failed (continuing with lazy adoption fallback): ${getErrorMessage(error)}`);
+      }
+    };
+    if (bootQuietRemainingMs() > 0)
+      scheduleAfterBootQuiet(runBackfill);
+    else
+      runBackfill();
+  }
+  setDatabase(db);
+  loadToolDefinitionMeasurements(db);
+  restrictDatabaseFilePermissions(dbPath);
+  databases.set(dbPath, db);
+  pathByDatabase.set(db, dbPath);
+  persistenceByDatabase.set(db, true);
+  persistenceErrorByDatabase.delete(db);
+  return db;
+}
 function initializeDatabase(db) {
   db.exec("PRAGMA busy_timeout=5000");
   db.exec("PRAGMA foreign_keys=ON");
@@ -143633,6 +143800,76 @@ function initializeDatabase(db) {
       PRIMARY KEY(project_path, scope, model_id)
     );
 
+    CREATE TABLE IF NOT EXISTS embedding_registrations (
+      project_path TEXT PRIMARY KEY,
+      provider_identity TEXT NOT NULL DEFAULT '',
+      model_id TEXT NOT NULL DEFAULT '',
+      chunk_model_id TEXT NOT NULL DEFAULT '',
+      fingerprint TEXT NOT NULL DEFAULT '',
+      table_epoch INTEGER NOT NULL DEFAULT 0,
+      dims INTEGER NOT NULL DEFAULT 0,
+      provenance_json TEXT NOT NULL DEFAULT '{}',
+      generation INTEGER NOT NULL DEFAULT 0,
+      updated_at INTEGER NOT NULL DEFAULT 0
+    );
+
+    CREATE TABLE IF NOT EXISTS synapse_batch_ledger (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      project_path TEXT NOT NULL DEFAULT '',
+      scope TEXT NOT NULL DEFAULT '',
+      manifest_json TEXT NOT NULL DEFAULT '{}',
+      request_key TEXT NOT NULL DEFAULT '',
+      job_id TEXT,
+      cursor TEXT,
+      status TEXT NOT NULL DEFAULT 'pending',
+      created_at INTEGER NOT NULL DEFAULT 0,
+      updated_at INTEGER NOT NULL DEFAULT 0,
+      UNIQUE(session_id, request_key)
+    );
+    CREATE INDEX IF NOT EXISTS idx_synapse_batch_ledger_session
+      ON synapse_batch_ledger(session_id, updated_at);
+
+    CREATE TABLE IF NOT EXISTS shadow_embedding_registrations (
+      project_path TEXT NOT NULL,
+      scope TEXT NOT NULL CHECK(scope IN ('memory', 'commit', 'chunk')),
+      model_id TEXT NOT NULL,
+      generation INTEGER NOT NULL DEFAULT 0,
+      fingerprint TEXT NOT NULL DEFAULT '',
+      table_epoch INTEGER NOT NULL DEFAULT 0,
+      dims INTEGER NOT NULL DEFAULT 0,
+      provenance_json TEXT NOT NULL DEFAULT '{}',
+      updated_at INTEGER NOT NULL DEFAULT 0,
+      PRIMARY KEY(project_path, scope, model_id)
+    );
+
+    CREATE TABLE IF NOT EXISTS embedding_measurement_corpus (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      project_path TEXT NOT NULL DEFAULT '',
+      dedup_key TEXT NOT NULL DEFAULT '',
+      cohort_key TEXT NOT NULL DEFAULT '',
+      query_text_hash TEXT NOT NULL DEFAULT '',
+      primary_result_ids_json TEXT NOT NULL DEFAULT '[]',
+      shadow_result_ids_json TEXT NOT NULL DEFAULT '[]',
+      primary_latency_ms INTEGER,
+      shadow_latency_ms INTEGER,
+      primary_failed INTEGER NOT NULL DEFAULT 0,
+      shadow_failed INTEGER NOT NULL DEFAULT 0,
+      primary_model_id TEXT NOT NULL DEFAULT '',
+      shadow_model_id TEXT NOT NULL DEFAULT '',
+      primary_fingerprint TEXT NOT NULL DEFAULT '',
+      shadow_fingerprint TEXT NOT NULL DEFAULT '',
+      primary_epoch INTEGER NOT NULL DEFAULT 0,
+      shadow_epoch INTEGER NOT NULL DEFAULT 0,
+      corpus_hash TEXT NOT NULL DEFAULT '',
+      coverage_json TEXT NOT NULL DEFAULT '{}',
+      created_at INTEGER NOT NULL DEFAULT 0,
+      UNIQUE(dedup_key, cohort_key)
+    );
+    CREATE INDEX IF NOT EXISTS idx_embedding_measurement_session
+      ON embedding_measurement_corpus(session_id, created_at);
+
     CREATE TABLE IF NOT EXISTS memory_verifications (
       memory_id    INTEGER NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
       file_path    TEXT NOT NULL,
@@ -144373,32 +144610,60 @@ function openDatabase(dbPathOrOptions) {
     }
     initializeDatabase(db);
     runMigrations(db);
-    if (!enforceSchemaFence(db, dbPath, latestSupportedVersion)) {
-      closeQuietly(db);
-      return null;
-    }
-    healWedgedChannel2Claims(db);
-    if (!explicitDbPath) {
-      try {
-        runToolOwnerBackfill(db);
-      } catch (error) {
-        log(`[magic-context] tool-owner backfill failed (continuing with lazy adoption fallback): ${getErrorMessage(error)}`);
-      }
-    }
-    setDatabase(db);
-    loadToolDefinitionMeasurements(db);
-    restrictDatabaseFilePermissions(dbPath);
-    databases.set(dbPath, db);
-    pathByDatabase.set(db, dbPath);
-    persistenceByDatabase.set(db, true);
-    persistenceErrorByDatabase.delete(db);
-    return db;
+    return finishDatabaseOpen(db, dbPath, explicitDbPath, latestSupportedVersion);
   } catch (error) {
     const detail = getErrorMessage(error);
     log(`[magic-context] storage fatal: failed to open ${dbPath}: ${detail}`);
     throw new Error(`[magic-context] storage unavailable: ${detail}. Magic Context is disabled for this run; check log for details.`);
   }
 }
+async function openDatabaseAsync(dbPathOrOptions) {
+  const options = typeof dbPathOrOptions === "string" ? { dbPath: dbPathOrOptions } : dbPathOrOptions;
+  const explicitDbPath = options?.dbPath !== undefined;
+  const { dbDir, dbPath } = resolveDatabasePath(options?.dbPath);
+  const latestSupportedVersion = getRuntimeLatestSupportedVersion(options);
+  const existing = databases.get(dbPath);
+  if (existing) {
+    if (!enforceSchemaFence(existing, dbPath, latestSupportedVersion))
+      return null;
+    if (!persistenceByDatabase.has(existing))
+      persistenceByDatabase.set(existing, true);
+    healWedgedChannel2Claims(existing);
+    return existing;
+  }
+  const pending = pendingAsyncOpens.get(dbPath);
+  if (pending)
+    return pending;
+  const opening = (async () => {
+    let db;
+    try {
+      if (!explicitDbPath)
+        migrateLegacyStorageIfNeeded(dbPath, dbDir);
+      ensureSecureStorageDir(dbDir);
+      db = new Database(dbPath);
+      if (!enforceSchemaFence(db, dbPath, latestSupportedVersion)) {
+        closeQuietly(db);
+        return null;
+      }
+      initializeDatabase(db);
+      await runMigrationsWithRetry(db);
+      return finishDatabaseOpen(db, dbPath, explicitDbPath, latestSupportedVersion);
+    } catch (error) {
+      if (db)
+        closeQuietly(db);
+      const detail = getErrorMessage(error);
+      log(`[magic-context] storage fatal: failed to open ${dbPath}: ${detail}`);
+      throw new Error(`[magic-context] storage unavailable: ${detail}. Magic Context is disabled for this run; check log for details.`);
+    }
+  })();
+  pendingAsyncOpens.set(dbPath, opening);
+  try {
+    return await opening;
+  } finally {
+    if (pendingAsyncOpens.get(dbPath) === opening)
+      pendingAsyncOpens.delete(dbPath);
+  }
+}
 
 // src/subagent-entry.ts
 init_logger();
@@ -145159,6 +145424,9 @@ function migrateLegacyExperimental(rawConfig, warnings) {
   return patched;
 }
 
+// ../plugin/src/config/schema/magic-context.ts
+import { homedir as homedir3 } from "node:os";
+
 // ../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/classic/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -159825,8 +160093,18 @@ var HistorianConfigSchema = AgentOverrideConfigSchema.extend({
   thinking_level: PiThinkingLevelSchema.describe("Pi only: explicit thinking level passed as --thinking <level> to Pi historian subagent invocations. Required when using reasoning models (e.g. github-copilot/gpt-5.4) because Pi's default thinking-level resolution can pick a value the provider rejects. OpenCode users set variant instead. Valid: off | minimal | low | medium | high | xhigh"),
   disallowed_tools: exports_external.array(exports_external.enum(["*", "read", "aft_outline", "aft_zoom", "aft_search"])).default([]).describe(`OpenCode only. Tools to REMOVE from the historian's default allow-list [read, aft_outline, aft_zoom, aft_search]. Applies to both historian and historian-editor agents. Use ["*"] to strip all tool definitions from the model request — this prevents weak instruction-following models (e.g. mistral-small-latest) from entering tool-calling loops. Individual tool names remove just that tool. Note: a user-supplied historian.permission override can re-allow a tool that disallowed_tools removed — disallowed_tools sets the baseline, permission overrides take precedence. (default: [])`)
 }).optional();
+var EmbeddingFallbackProviderSchema = exports_external.enum(["local", "openai-compatible", "off"]);
+function expandConfigPath(value) {
+  const trimmed = value.trim();
+  if (trimmed === "~")
+    return homedir3();
+  if (trimmed.startsWith("~/"))
+    return `${homedir3()}/${trimmed.slice(2)}`;
+  return trimmed;
+}
 var BaseEmbeddingConfigSchema = exports_external.object({
-  provider: exports_external.enum(["local", "openai-compatible", "off"]).default("local").describe("Embedding provider. 'local' uses Xenova/all-MiniLM-L6-v2, 'openai-compatible' requires endpoint and model, 'off' disables embeddings."),
+  provider: exports_external.enum(["local", "openai-compatible", "off", "synapse"]).default("local").describe("Embedding provider. 'local' uses Xenova/all-MiniLM-L6-v2, 'openai-compatible' requires endpoint and model, 'synapse' uses the certified local Synapse lane with an explicit fallback provider, and 'off' disables embeddings."),
+  fallback_provider: EmbeddingFallbackProviderSchema.optional().describe("Fallback provider for the Synapse lane. Required when provider is 'synapse'; local, openai-compatible, and off are valid."),
   model: exports_external.string().optional().describe("Embedding model name. Required for openai-compatible, ignored for local."),
   endpoint: exports_external.string().optional().describe("API endpoint URL. Required when provider is openai-compatible."),
   api_key: exports_external.string().optional().describe("API key for remote embedding provider (optional)"),
@@ -159835,14 +160113,15 @@ var BaseEmbeddingConfigSchema = exports_external.object({
   truncate: exports_external.string().optional().describe("Optional truncate mode sent in the embedding request body (e.g. NVIDIA NIM accepts 'NONE' | 'START' | 'END'). Omitted from the request when unset."),
   max_input_tokens: exports_external.number().int().positive().optional().describe("Optional maximum input tokens for chunk embeddings. Defaults conservatively to 512 when omitted.")
 }).superRefine((data, ctx) => {
-  if (data.provider === "openai-compatible" && !data.endpoint?.trim()) {
+  const validationProvider = data.provider === "synapse" ? data.fallback_provider : data.provider;
+  if (validationProvider === "openai-compatible" && !data.endpoint?.trim()) {
     ctx.addIssue({
       code: "custom",
       path: ["endpoint"],
       message: "endpoint is required when embedding.provider is openai-compatible"
     });
   }
-  if (data.provider === "openai-compatible" && !data.model?.trim()) {
+  if (validationProvider === "openai-compatible" && !data.model?.trim()) {
     ctx.addIssue({
       code: "custom",
       path: ["model"],
@@ -159851,6 +160130,25 @@ var BaseEmbeddingConfigSchema = exports_external.object({
   }
 });
 var EmbeddingConfigSchema = BaseEmbeddingConfigSchema.transform((data) => {
+  if (data.provider === "synapse") {
+    const model = data.model?.trim();
+    const endpoint = data.endpoint?.trim();
+    const apiKey = data.api_key?.trim();
+    const inputType = data.input_type?.trim();
+    const queryInputType = data.query_input_type?.trim();
+    const truncate = data.truncate?.trim();
+    return {
+      provider: "synapse",
+      ...data.fallback_provider ? { fallback_provider: data.fallback_provider } : {},
+      ...model ? { model } : {},
+      ...endpoint ? { endpoint } : {},
+      ...apiKey ? { api_key: apiKey } : {},
+      ...inputType ? { input_type: inputType } : {},
+      ...queryInputType ? { query_input_type: queryInputType } : {},
+      ...truncate ? { truncate } : {},
+      ...data.max_input_tokens ? { max_input_tokens: data.max_input_tokens } : {}
+    };
+  }
   if (data.provider === "local") {
     return {
       provider: "local",
@@ -159878,6 +160176,7 @@ var EmbeddingConfigSchema = BaseEmbeddingConfigSchema.transform((data) => {
 });
 var MagicContextConfigSchema = exports_external.object({
   enabled: exports_external.boolean().default(true).describe("Enable magic context (default: true)"),
+  transform_mode: exports_external.enum(["ts", "rust"]).default("ts").describe('Experimental: routes the entire Magic Context runtime for the project through the ck-mc Rust module over subc (requires user-level `subc` config); "ts" is the current TypeScript pipeline.'),
   auto_update: exports_external.boolean().optional().describe("Enable automatic npm self-update checks for the OpenCode plugin. Security: USER-only in config loader, so hostile project configs cannot suppress updates."),
   language: exports_external.string().trim().toLowerCase().refine((s) => isValidLanguageCode(s), 'language must be a 2-letter ISO 639-1 code (e.g. "tr", "es", "de")').optional().describe("Output language for Magic Context's generated content and guidance, as a " + '2-letter ISO 639-1 code (e.g. "tr", "es", "de", "ja", "pt"). When set, the ' + "historian, dreamer, sidekick, and the agent-guidance block instruct the model to " + "write its PROSE in this language while keeping all structural tokens (XML tags, " + "the five memory category names, code identifiers, file paths) in English. " + "USER-LEVEL ONLY (ignored in project config for security). Unset = today's " + "behavior (model mirrors the conversation; English scaffolding). Changing it " + "triggers one cache re-materialization; existing compartments/memories keep their " + "original language until naturally rewritten."),
   historian: HistorianConfigSchema.describe("Historian agent configuration (model, fallback_models, variant, temperature, maxTokens, permission, two_pass, etc.)"),
@@ -159914,6 +160213,12 @@ var MagicContextConfigSchema = exports_external.object({
     provider: "local",
     model: DEFAULT_LOCAL_EMBEDDING_MODEL
   }).describe("Embedding provider configuration"),
+  subc: exports_external.object({
+    connection_file: exports_external.string().trim().min(1).transform(expandConfigPath).describe("Path to the owner-only subc connection file.")
+  }).optional().describe("User-only Synapse daemon connection settings."),
+  shadow_embedding: exports_external.object({
+    enabled: exports_external.boolean().default(false).describe("Developer-only Synapse shadow embedding lane switch.")
+  }).default({ enabled: false }).describe("Developer-only Synapse shadow embedding lane."),
   temporal_awareness: exports_external.boolean().default(true).describe('Inject wall-clock gap markers (<!-- +Xm -->) between user messages where > 5 min elapsed since the previous message, and add compact date ranges to compartment headings. Gives the agent a sense of session pacing and "how long ago" across multi-day sessions. Graduated from experimental.temporal_awareness; default: true (set false to opt out).'),
   keep_subagents: exports_external.boolean().default(false).describe("Debug: keep the child sessions Magic Context spawns for its own subagents (historian, dreamer, sidekick, memory-migration) instead of deleting them on success. Useful for short-term inspection/data collection — their full transcript (prompt, tool calls, token usage, output) stays in the host session store. Kept sessions accumulate until manually cleared; leave false for normal use. Requires a restart to take effect."),
   shadow_transform: exports_external.object({
@@ -159963,7 +160268,7 @@ var MagicContextConfigSchema = exports_external.object({
 var HIDDEN_AGENT_KEYS = ["historian", "dreamer", "sidekick"];
 var HISTORIAN_USER_ONLY_FIELDS = ["model", "fallback_models"];
 var AGENT_ESCALATION_FIELDS = ["prompt", "permission", "tools", "system_prompt"];
-var EMBEDDING_DESTINATION_FIELDS = ["endpoint", "provider"];
+var EMBEDDING_DESTINATION_FIELDS = ["endpoint", "provider", "fallback_provider"];
 var PERCENTAGE_THRESHOLD_REASON = "security: a repository may only raise compaction thresholds above the user's effective value; it cannot force earlier historian work or cloned-repo cost escalation.";
 var TOKEN_THRESHOLD_REASON = "security: a repository may only raise execute_threshold_tokens above the user's trusted token threshold; it cannot force earlier historian work or cloned-repo cost escalation.";
 var TOKEN_THRESHOLD_INTRODUCTION_REASON = "security: a repository cannot introduce a new execute_threshold_tokens override when the user has no trusted token threshold for that key; that could force earlier historian work or cloned-repo cost escalation.";
@@ -160079,6 +160384,12 @@ function stripUnsafeProjectConfigFields(projectRaw) {
     delete projectRaw.shadow_transform;
     warnings.push("Ignoring shadow_transform from project config (security: this developer-only mirror lane is user-level only).");
   }
+  for (const field of ["subc", "shadow_embedding"]) {
+    if (field in projectRaw) {
+      delete projectRaw[field];
+      warnings.push(`Ignoring ${field} from project config (security: daemon routing and developer-only embedding traffic are user-level settings).`);
+    }
+  }
   const embedding = projectRaw.embedding;
   if (isPlainObject3(embedding)) {
     const removed = [];
@@ -160254,7 +160565,7 @@ function dropInheritedEmbeddingKeyOnRedirect(projectRaw, mergedRaw, userRaw) {
 
 // ../plugin/src/config/variable.ts
 import { existsSync as existsSync6, readFileSync as readFileSync3 } from "node:fs";
-import { homedir as homedir3 } from "node:os";
+import { homedir as homedir4 } from "node:os";
 import { dirname as dirname4, isAbsolute as isAbsolute2, resolve } from "node:path";
 
 // ../plugin/src/shared/jsonc-parser.ts
@@ -160317,7 +160628,7 @@ function stripJsonComments(content) {
 var ENV_PATTERN = /\{env:([^}]+)\}/g;
 var FILE_PATTERN = /\{file:([^}]+)\}/g;
 function sensitiveFilePathReason(resolvedPath) {
-  const home = homedir3();
+  const home = homedir4();
   const sensitiveDirs = [
     { dir: resolve(home, ".ssh"), label: "SSH keys" },
     { dir: resolve(home, ".aws"), label: "AWS credentials" },
@@ -160380,7 +160691,7 @@ function substituteConfigVariables(input) {
     }
     let filePath = rawPath.trim();
     if (filePath.startsWith("~/")) {
-      filePath = resolve(homedir3(), filePath.slice(2));
+      filePath = resolve(homedir4(), filePath.slice(2));
     } else if (!isAbsolute2(filePath)) {
       filePath = resolve(configDir, filePath);
     }
@@ -161362,14 +161673,2634 @@ function cosineSimilarity(a, b) {
   return denominator === 0 ? 0 : dotProduct / denominator;
 }
 
-// ../plugin/src/features/magic-context/memory/normalize-hash.ts
+// ../plugin/src/features/magic-context/memory/embedding-synapse.ts
 import { createHash as createHash4 } from "node:crypto";
+
+// ../../node_modules/.bun/@cortexkit+subc-client@0.4.1/node_modules/@cortexkit/subc-client/dist/client.js
+import { promises as fs3 } from "node:fs";
+import { debuglog } from "node:util";
+
+// ../../node_modules/.bun/@cortexkit+subc-client@0.4.1/node_modules/@cortexkit/subc-client/dist/auth.js
+import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
+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, domain2, clientNonce, serverNonce, daemonId) {
+  const mac3 = createHmac("sha256", Buffer.from(key));
+  mac3.update(Buffer.from(domain2, "utf8"));
+  mac3.update(Buffer.from(clientNonce));
+  mac3.update(Buffer.from(serverNonce));
+  mac3.update(Buffer.from(daemonId));
+  return new Uint8Array(mac3.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 json2 = Buffer.from(JSON.stringify(value), "utf8");
+  if (json2.length > MAX_AUTH_MESSAGE_LEN) {
+    throw new AuthError(`auth message too large: ${json2.length} > ${MAX_AUTH_MESSAGE_LEN}`);
+  }
+  const lenPrefix = new Uint8Array(4);
+  new DataView(lenPrefix.buffer).setUint32(0, json2.length, true);
+  await sock.write(lenPrefix, deadlineMs);
+  await sock.write(json2, 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)}`);
+  }
+}
+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 = Uint8Array.from(proof.server_nonce);
+  const daemonId = Uint8Array.from(proof.daemon_id);
+  const serverProof = Uint8Array.from(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.4.1/node_modules/@cortexkit/subc-client/dist/connection-file.js
+import { promises as fs2 } 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) || value.some((n) => typeof n !== "number")) {
+    throw new ConnectionFileError(`connection file field '${field}' must be a JSON array of bytes`);
+  }
+  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(path4) {
+  if (process.platform === "win32")
+    return;
+  const stat = await fs2.stat(path4);
+  const mode = stat.mode & 511;
+  if ((mode & 63) !== 0) {
+    throw new ConnectionFileError(`connection file ${path4} has insecure permissions 0o${mode.toString(8)}; expected owner-only 0600`);
+  }
+}
+async function readConnectionFile(path4) {
+  await verifyOwnerOnly(path4);
+  const raw = await fs2.readFile(path4, "utf8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new ConnectionFileError(`connection file JSON read failed for ${path4}: ${String(err)}`);
+  }
+  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.4.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(FrameType2) {
+  FrameType2[FrameType2["Request"] = 0] = "Request";
+  FrameType2[FrameType2["Response"] = 1] = "Response";
+  FrameType2[FrameType2["Push"] = 2] = "Push";
+  FrameType2[FrameType2["StreamData"] = 3] = "StreamData";
+  FrameType2[FrameType2["StreamEnd"] = 4] = "StreamEnd";
+  FrameType2[FrameType2["Error"] = 5] = "Error";
+  FrameType2[FrameType2["Cancel"] = 6] = "Cancel";
+  FrameType2[FrameType2["Ping"] = 7] = "Ping";
+  FrameType2[FrameType2["Pong"] = 8] = "Pong";
+  FrameType2[FrameType2["Hello"] = 9] = "Hello";
+  FrameType2[FrameType2["HelloAck"] = 10] = "HelloAck";
+  FrameType2[FrameType2["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(Priority2) {
+  Priority2[Priority2["Passive"] = 0] = "Passive";
+  Priority2[Priority2["Interactive"] = 1] = "Interactive";
+  Priority2[Priority2["Background"] = 2] = "Background";
+})(Priority || (Priority = {}));
+var AdmissionClass;
+(function(AdmissionClass2) {
+  AdmissionClass2[AdmissionClass2["Normal"] = 0] = "Normal";
+  AdmissionClass2[AdmissionClass2["Expedite"] = 1] = "Expedite";
+  AdmissionClass2[AdmissionClass2["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 = 192;
+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 encodeHeader(header) {
+  const buffer2 = new Uint8Array(HEADER_LEN);
+  const view = new DataView(buffer2.buffer);
+  view.setUint32(0, header.len, true);
+  buffer2[4] = header.ver;
+  buffer2[5] = header.ty;
+  buffer2[6] = header.flags;
+  view.setUint16(7, header.channel, true);
+  view.setUint32(9, header.epoch, true);
+  view.setBigUint64(13, header.corr, true);
+  return buffer2;
+}
+
+class DecodeError extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "DecodeError";
+  }
+}
+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 };
+  decodeHeader(encodeHeader(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.4.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.4.1/node_modules/@cortexkit/subc-client/dist/socket.js
+import net from "node:net";
+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;
+  }
+}
+
+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((resolve2, 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);
+        resolve2(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 version2 = prefix[4];
+    if (version2 !== PROTOCOL_VERSION)
+      throw new DecodeError(`unsupported envelope version ${version2}`, "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((resolve2, 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: resolve2, reject, timer };
+      this.tryServe();
+    });
+  }
+  async write(bytes, deadlineMs) {
+    try {
+      await this.writeTracked(bytes, deadlineMs).completed;
+    } catch (err) {
+      if (err instanceof SocketWriteNotQueuedError || err instanceof SocketWriteQueuedError) {
+        throw err.cause ?? err;
+      }
+      throw err;
+    }
+  }
+  writeTracked(bytes, 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((resolve2, 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.from(bytes), (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 {
+              resolve2();
+            }
+          });
+        });
+        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.4.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 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";
+  }
+}
+
+class SubcError extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+  }
+}
+
+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 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 bytes = 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);
+    return this.parseJson(reply);
+  }
+  async call(moduleId, method, params, opts = {}) {
+    const body = params === undefined ? { method } : { method, params };
+    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);
+        if (err.code === "unknown_channel" && !retriedUnknownChannel && !this.closeStarted) {
+          retriedUnknownChannel = true;
+          this.evictRouteHandle(routeHandle);
+          continue;
+        }
+        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);
+        }
+        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);
+    const closed = new Promise((resolve2, reject) => {
+      if (this.closedErr) {
+        reject(this.closedErr);
+        return;
+      }
+      this.pending.set(key, {
+        handle,
+        resolve: () => resolve2(),
+        reject,
+        onProgress: onEvent,
+        timer: null,
+        subscription: true
+      });
+      const frame = buildFrame(FrameType.Request, buildFlags(false, priority, false, admission), handle.channel, handle.epoch, corr, bytes);
+      this.sock.write(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;
+      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);
+    this.sock.write(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, cached2] of this.routes) {
+      if (cached2.handle && sameRouteHandle(cached2.handle, handle)) {
+        cached2.closed = true;
+        cached2.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 cached2 = this.routes.get(key);
+    if (!cached2)
+      return;
+    cached2.closed = true;
+    this.routes.delete(key);
+    const handle = cached2.handle;
+    cached2.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((resolve2) => {
+          const previous = pending.onSettle;
+          pending.onSettle = () => {
+            previous?.();
+            resolve2();
+          };
+        }));
+      }
+    }
+    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 = this.sock.writeTracked(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) {
+    if (handle)
+      this.assertLiveHandle(handle);
+    if (this.closedErr)
+      return Promise.reject(this.closedErr);
+    let corr;
+    try {
+      corr = this.allocateCorr();
+    } catch (error51) {
+      return Promise.reject(error51);
+    }
+    const key = pendingKey(handle, corr);
+    const channel = handle?.channel ?? 0;
+    const epoch = handle?.epoch ?? 0;
+    const frame = buildFrame(FrameType.Request, buildFlags(false, priority, false, admission), channel, epoch, corr, body);
+    return new Promise((resolve2, reject) => {
+      const ms = timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+      const pending = {
+        handle,
+        resolve: resolve2,
+        reject,
+        onProgress,
+        timer: null,
+        acceptFrame,
+        onLateResponse
+      };
+      pending.timer = setTimeout(() => this.arbitrateTimeout(key, pending, channel, corr, ms), ms);
+      this.pending.set(key, pending);
+      this.sock.write(encodeFrame(frame), Date.now() + ms).catch((error51) => {
+        const current = this.pending.get(key);
+        if (current)
+          this.rejectPending(key, current, error51 instanceof Error ? error51 : new SubcError(String(error51)));
+      });
+    });
+  }
+  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 bytes = 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);
+      return this.parseJson(reply);
+    } catch (error51) {
+      if (error51 instanceof SubcCallError)
+        throw error51;
+      throw this.terminalCallError("managed call failed", error51);
+    }
+  }
+  sendManaged(handle, body, priority, admission, timeoutMs, onProgress) {
+    try {
+      this.assertLiveHandle(handle);
+    } catch (error51) {
+      return Promise.reject(this.notSentCallError("request used a stale route handle", error51));
+    }
+    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 (error51) {
+      return Promise.reject(this.notSentCallError("request correlation allocator was exhausted", error51));
+    }
+    const key = pendingKey(handle, corr);
+    const frame = buildFrame(FrameType.Request, buildFlags(false, priority, false, admission), handle.channel, handle.epoch, corr, body);
+    let handedToSocket = false;
+    const classifyFailure = (error51) => {
+      if (!handedToSocket)
+        return this.notSentCallError("request bytes were not queued to the subc socket", error51);
+      if (error51 instanceof SubcError && error51.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(error51)}`, DEADLINE_NO_DROP_CODE, error51);
+      }
+      return this.outcomeUnknownCallError("connection dropped before the managed call returned a response", error51);
+    };
+    return new Promise((resolve2, reject) => {
+      const ms = timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+      const pending = {
+        handle,
+        resolve: resolve2,
+        reject,
+        onProgress,
+        timer: null,
+        classifyFailure
+      };
+      pending.timer = setTimeout(() => this.arbitrateTimeout(key, pending, handle.channel, corr, ms), ms);
+      this.pending.set(key, pending);
+      const write = this.sock.writeTracked(encodeFrame(frame), Date.now() + ms);
+      handedToSocket = write.queued;
+      write.completed.catch((error51) => {
+        const current = this.pending.get(key);
+        if (current)
+          this.rejectPending(key, current, error51 instanceof Error ? error51 : new SubcError(String(error51)));
+      });
+    });
+  }
+  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 cached2 = this.routes.get(key);
+    if (!cached2) {
+      cached2 = {
+        key,
+        moduleId,
+        target,
+        identity,
+        consumerIdentity,
+        handle: null,
+        opening: null
+      };
+      this.routes.set(key, cached2);
+    }
+    if (cached2.handle && this.isLiveHandle(cached2.handle))
+      return cached2.handle;
+    if (!cached2.opening) {
+      cached2.opening = this.openCachedRoute(cached2).finally(() => {
+        cached2.opening = null;
+      });
+    }
+    return cached2.opening;
+  }
+  async openCachedRoute(cached2) {
+    const routeRetryDeadline = Date.now() + ROUTE_OPEN_RETRY_DEADLINE_MS;
+    let routeRetryDelay = this.opts.reconnectBackoff.baseMs;
+    let routeRetryAttempt = 0;
+    for (;; ) {
+      if (cached2.closed)
+        throw this.routeClosedDuringOpen();
+      try {
+        await this.ensureConnectedForManaged();
+      } catch (error51) {
+        throw this.notSentRecoveryError("route.open could not run because reconnect failed", error51);
+      }
+      if (cached2.handle && this.isLiveHandle(cached2.handle))
+        return cached2.handle;
+      try {
+        const handle = await this.routeOpen(cached2.target, cached2.identity, {
+          consumerIdentity: cached2.consumerIdentity ?? null
+        });
+        if (cached2.closed) {
+          this.liveRoutes.delete(handle.channel);
+          this.sendRouteGoodbye(handle);
+          throw this.routeClosedDuringOpen();
+        }
+        cached2.handle = handle;
+        return handle;
+      } catch (error51) {
+        if (error51 instanceof SubcCallError && error51.code === "route_closed")
+          throw error51;
+        if (!this.closeStarted && isConsumerReconnectTransient(error51)) {
+          try {
+            await this.reconnectAfterDrop(error51);
+          } catch (reconnectError) {
+            throw this.notSentRecoveryError("route.open was not sent and reconnect failed", reconnectError);
+          }
+          continue;
+        }
+        if (!this.closeStarted && error51 instanceof SubcError && isRetryableRouteOpenCode(error51.code)) {
+          routeRetryAttempt += 1;
+          if (routeRetryAttempt < this.opts.reconnectBackoff.maxAttempts && 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 ${cached2.moduleId}: ${error51.code} (retry budget exhausted)`, error51);
+        }
+        throw this.terminalCallError(`route.open failed for module ${cached2.moduleId}`, error51);
+      }
+    }
+  }
+  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 promise2 = this.reconnectWithRetry(trigger).finally(() => {
+      if (this.reconnecting === promise2)
+        this.reconnecting = null;
+    });
+    this.reconnecting = promise2;
+    return promise2;
+  }
+  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() {
+    for (const cached2 of this.routes.values())
+      cached2.handle = null;
+    for (const cached2 of this.routes.values()) {
+      if (cached2.closed)
+        continue;
+      const handle = await this.routeOpen(cached2.target, cached2.identity, {
+        consumerIdentity: cached2.consumerIdentity ?? null
+      });
+      if (cached2.closed) {
+        this.liveRoutes.delete(handle.channel);
+        this.sendRouteGoodbye(handle);
+        continue;
+      }
+      cached2.handle = handle;
+    }
+  }
+  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 (error51) {
+      if (this.sock === sock && this.generation === generation) {
+        this.fail(error51 instanceof Error ? error51 : new SubcError(String(error51)));
+      }
+    }
+  }
+  dispatch(frame) {
+    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:
+          pending.onProgress?.(frame.body);
+          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)"));
+      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);
+    } catch {
+      return new SubcError(Buffer.from(frame.body).toString("utf8") || "subc error");
+    }
+  }
+  evictRouteHandle(handle) {
+    for (const cached2 of this.routes.values()) {
+      if (cached2.handle && sameRouteHandle(cached2.handle, handle))
+        cached2.handle = null;
+    }
+  }
+  failHandle(handle, error51) {
+    for (const [key, pending] of this.pending) {
+      if (pending.handle && sameRouteHandle(pending.handle, handle))
+        this.rejectPending(key, pending, error51);
+    }
+  }
+  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 error51 = new SubcError("channel-0 correlation id allocator exhausted", "corr_exhausted");
+      this.fail(error51);
+      this.sock.close();
+      this.scheduleReconnectAfterDrop(error51);
+      throw error51;
+    }
+    const corr = this.nextCorr;
+    this.nextCorr += 1n;
+    return corr;
+  }
+  closeConnectionAfterCleanupFailure() {
+    const error51 = new SubcError("late route cleanup could not be queued", "late_route_cleanup_failed");
+    this.fail(error51);
+    this.sock.close();
+    this.scheduleReconnectAfterDrop(error51);
+  }
+  encode(value) {
+    return new Uint8Array(Buffer.from(JSON.stringify(value), "utf8"));
+  }
+  parseJson(frame) {
+    return JSON.parse(Buffer.from(frame.body).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 isRetryableRouteOpenCode(code) {
+  return code === "unknown_module" || code === "module_reloading" || code === "target_unavailable" || code === "module_timeout";
+}
+async function connectionFileExists(path4) {
+  try {
+    await fs3.access(path4);
+    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((resolve2) => setTimeout(resolve2, ms))),
+    timeoutArbitrationGraceMs: opts.timeoutArbitrationGraceMs ?? TIMEOUT_ARBITRATION_GRACE_MS
+  };
+}
+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}`;
+}
+// ../../node_modules/.bun/@cortexkit+subc-client@0.4.1/node_modules/@cortexkit/subc-client/dist/provider.js
+import { Buffer as Buffer2 } from "node:buffer";
+var DEFAULT_HANDSHAKE_TIMEOUT_MS2 = 1e4;
+var BODY_READ_TIMEOUT_MS2 = 30000;
+var WRITE_TIMEOUT_MS = 30000;
+var DEFAULT_RESTORED_DEBOUNCE_MS = 250;
+var DEFAULT_PROVIDER_HANDLER_CAPACITY = 64;
+var HEALTH_CHECK_OP = "health.check";
+var HELLO_CORR = 1n;
+
+class AsyncPermitPool {
+  available;
+  waiters = [];
+  constructor(capacity) {
+    if (!Number.isInteger(capacity) || capacity <= 0) {
+      throw new SubcProviderError("provider handler capacity must be a positive integer", "invalid_handler_capacity");
+    }
+    this.available = capacity;
+  }
+  async acquire() {
+    if (this.available > 0) {
+      this.available -= 1;
+      return this.releaseOnce();
+    }
+    await new Promise((resolve2) => {
+      this.waiters.push(resolve2);
+    });
+    return this.releaseOnce();
+  }
+  releaseOnce() {
+    let released = false;
+    return () => {
+      if (released)
+        return;
+      released = true;
+      const next = this.waiters.shift();
+      if (next) {
+        next();
+      } else {
+        this.available += 1;
+      }
+    };
+  }
+}
+
+class SubcProviderError extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+  }
+}
+class SubcProvider {
+  sock;
+  currentConn;
+  opts;
+  closed;
+  resolveClosed = () => {
+    return;
+  };
+  closeStarted = false;
+  closedErr = null;
+  inflight = new Map;
+  pending = new Map;
+  liveRoutes = new Map;
+  connectionToken = newConnectionToken();
+  nextCorr = 1n;
+  ingressEpochDropCount = 0;
+  requestGate = new AsyncPermitPool(DEFAULT_PROVIDER_HANDLER_CAPACITY);
+  reconnecting = null;
+  generation = 1;
+  connectionEpoch = 1;
+  stateQueue = [];
+  drainingStateQueue = false;
+  restoredDebounceToken = 0;
+  storage;
+  constructor(sock, currentConn, opts, storage) {
+    this.sock = sock;
+    this.currentConn = currentConn;
+    this.opts = opts;
+    this.storage = storage;
+    this.closed = new Promise((resolve2) => {
+      this.resolveClosed = resolve2;
+    });
+    this.readLoop(sock, this.generation);
+    this.enqueueConnectionState({ state: "connected", epoch: this.connectionEpoch });
+  }
+  get droppedIngressFrames() {
+    return this.ingressEpochDropCount;
+  }
+  get conn() {
+    return this.currentConn;
+  }
+  currentEpoch() {
+    return this.connectionEpoch;
+  }
+  async request(handle, body, opts = {}) {
+    this.assertLiveHandle(handle);
+    const corr = this.allocateCorr();
+    const key = routeKey(handle, corr);
+    const timeoutMs = opts.timeoutMs ?? WRITE_TIMEOUT_MS;
+    const frame = buildFrame(FrameType.Request, buildFlags(false, opts.priority ?? Priority.Interactive, false, opts.admissionClass ?? AdmissionClass.Normal), handle.channel, handle.epoch, corr, body);
+    return await new Promise((resolve2, reject) => {
+      const timer = setTimeout(() => {
+        if (this.pending.delete(key))
+          reject(new SubcProviderError("reverse request timed out", "request_timeout"));
+      }, timeoutMs);
+      this.pending.set(key, {
+        resolve: (response) => resolve2(response.body),
+        reject,
+        timer
+      });
+      this.sendOn(this.sock, this.generation, frame).catch((error51) => {
+        const pending = this.pending.get(key);
+        if (!pending)
+          return;
+        this.pending.delete(key);
+        clearTimeout(pending.timer);
+        reject(error51 instanceof Error ? error51 : new SubcProviderError(String(error51)));
+      });
+    });
+  }
+  async push(handle, body, opts = {}) {
+    this.assertLiveHandle(handle);
+    await this.sendOn(this.sock, this.generation, buildFrame(FrameType.Push, buildFlags(false, opts.priority ?? Priority.Interactive, false, opts.admissionClass ?? AdmissionClass.Normal), handle.channel, handle.epoch, 0n, body));
+  }
+  cancel(handle, corr) {
+    this.assertLiveHandle(handle);
+    this.sendOn(this.sock, this.generation, buildFrame(FrameType.Cancel, controlFlags(), handle.channel, handle.epoch, corr, new Uint8Array(0)));
+  }
+  closeRoute(handle) {
+    this.assertLiveHandle(handle);
+    this.liveRoutes.delete(handle.channel);
+    this.abortHandle(handle);
+    this.sendOn(this.sock, this.generation, buildFrame(FrameType.Goodbye, controlFlags(), handle.channel, handle.epoch, 0n, new Uint8Array(0)));
+  }
+  static async connect(opts) {
+    if (opts.manifest.protocol_ver !== PROTOCOL_VERSION) {
+      throw new SubcProviderError(`manifest protocol_ver ${opts.manifest.protocol_ver} does not match client protocol ${PROTOCOL_VERSION}`, "invalid_manifest");
+    }
+    const normalized = normalizeProviderConnectOptions(opts);
+    const opened = await SubcProvider.openConnection(normalized);
+    return new SubcProvider(opened.sock, opened.conn, normalized, opened.ack.storage);
+  }
+  async close() {
+    if (!this.closeStarted) {
+      this.closeStarted = true;
+      this.cancelRestoredDebounce();
+      const sock = this.sock;
+      try {
+        await sendFrame(sock, buildFrame(FrameType.Goodbye, controlFlags(), 0, 0, 0n, new Uint8Array(0)));
+      } catch {} finally {
+        sock.close();
+        this.finishClosed();
+      }
+    }
+    await this.closed;
+  }
+  static async openConnection(opts) {
+    const conn = await readConnectionFile(opts.connectionFile);
+    const deadline = Date.now() + (opts.handshakeTimeoutMs ?? DEFAULT_HANDSHAKE_TIMEOUT_MS2);
+    const endpoint = conn.endpoints[0];
+    const sock = await SubcSocket.connect(endpoint.host, endpoint.port, deadline);
+    try {
+      await authenticateClient(sock, conn, deadline);
+      await sendFrame(sock, buildHelloFrame(opts));
+      const ack = await expectHelloAck(sock, deadline);
+      return { sock, conn, ack };
+    } catch (err) {
+      sock.close();
+      throw err;
+    }
+  }
+  async readLoop(sock, generation) {
+    try {
+      for (;; ) {
+        const frame = await sock.readFrame(Number.POSITIVE_INFINITY, { afterHeaderMs: BODY_READ_TIMEOUT_MS2 });
+        const keepGoing = await this.dispatch(frame, sock, generation);
+        if (!keepGoing) {
+          if (this.sock === sock && this.generation === generation)
+            this.closeStarted = true;
+          break;
+        }
+      }
+    } catch (error51) {
+      if (this.sock === sock && this.generation === generation && !this.closeStarted) {
+        this.handleUnexpectedDrop(sock, generation, error51 instanceof Error ? error51 : new SubcProviderError(String(error51)));
+        return;
+      }
+    } finally {
+      if (this.sock === sock && this.generation === generation) {
+        sock.close();
+        if (this.closeStarted)
+          this.finishClosed();
+      }
+    }
+  }
+  async dispatch(frame, sock, generation) {
+    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 true;
+      }
+    }
+    if (handle) {
+      const pendingKey2 = routeKey(handle, frame.header.corr);
+      const pending = this.pending.get(pendingKey2);
+      if (pending) {
+        if (frame.header.ty === FrameType.Push || frame.header.ty === FrameType.StreamData)
+          return true;
+        if (frame.header.ty === FrameType.Response || frame.header.ty === FrameType.StreamEnd) {
+          this.pending.delete(pendingKey2);
+          clearTimeout(pending.timer);
+          pending.resolve(frame);
+          return true;
+        }
+        if (frame.header.ty === FrameType.Error) {
+          this.pending.delete(pendingKey2);
+          clearTimeout(pending.timer);
+          pending.reject(providerErrorFromFrame(frame));
+          return true;
+        }
+      }
+    }
+    switch (frame.header.ty) {
+      case FrameType.Ping:
+        if (frame.header.channel === 0) {
+          await this.sendOn(sock, generation, buildFrameWithVersion(frame.header.ver, FrameType.Pong, frame.header.flags, 0, 0, frame.header.corr, new Uint8Array(0)));
+        }
+        return true;
+      case FrameType.Goodbye:
+        if (!handle)
+          return false;
+        this.liveRoutes.delete(handle.channel);
+        this.abortHandle(handle);
+        await this.opts.onRouteGone?.(handle);
+        return true;
+      case FrameType.Cancel:
+        if (handle)
+          this.inflight.get(routeKey(handle, frame.header.corr))?.abort();
+        return true;
+      case FrameType.Request:
+        if (frame.header.channel === 0) {
+          await this.handleControlRequest(frame, sock, generation);
+        } else if (handle) {
+          this.handleDataRequest(frame, handle, sock, generation).catch((error51) => {
+            if (!this.closeStarted && this.sock === sock && this.generation === generation) {
+              console.warn("SubcProvider handler failed after its request was dispatched", error51);
+            }
+          });
+        }
+        return true;
+      default:
+        return true;
+    }
+  }
+  abortHandle(handle) {
+    const prefix = `${handle.channel}:${handle.epoch}:`;
+    for (const [key, controller] of this.inflight) {
+      if (key.startsWith(prefix))
+        controller.abort();
+    }
+    for (const [key, pending] of this.pending) {
+      if (!key.startsWith(prefix))
+        continue;
+      this.pending.delete(key);
+      clearTimeout(pending.timer);
+      pending.reject(new StaleRouteHandleError(handle));
+    }
+  }
+  abortGeneration(_generation) {
+    this.abortAllInflight();
+    for (const [key, pending] of this.pending) {
+      this.pending.delete(key);
+      clearTimeout(pending.timer);
+      pending.reject(new SubcProviderError("provider connection dropped", "connection_dropped"));
+    }
+    this.liveRoutes.clear();
+  }
+  abortAllInflight() {
+    for (const controller of this.inflight.values())
+      controller.abort();
+  }
+  async handleControlRequest(frame, sock, generation) {
+    const request = parseJson(frame.body);
+    if (request.op === HEALTH_CHECK_OP) {
+      this.handleHealthRequest(frame, sock, generation).catch((error51) => {
+        if (!this.closeStarted && this.sock === sock && this.generation === generation) {
+          console.warn("SubcProvider health handler failed after its request was dispatched", error51);
+        }
+      });
+      return;
+    }
+    if (request.op !== "route.bind") {
+      throw new SubcProviderError(`unsupported module control request ${request.op ?? "<missing op>"}`);
+    }
+    const tentative = createRouteHandle(numberField(request.route_channel, "route_channel"), numberField(request.epoch, "epoch"), this.connectionToken);
+    const bindRequest = {
+      handle: tentative,
+      target: request.target,
+      identity: request.identity,
+      principal: request.principal,
+      consumer_capabilities: request.consumer_capabilities
+    };
+    let decision;
+    try {
+      decision = await this.opts.onBind?.(bindRequest);
+    } catch (error51) {
+      try {
+        await this.sendError(frame, "route_rejected", error51 instanceof Error ? error51.message : String(error51), controlFlags(), sock, generation);
+      } finally {
+        await this.opts.onRouteGone?.(tentative);
+      }
+      return;
+    }
+    const rejection = bindRejection(decision);
+    if (rejection) {
+      try {
+        await this.sendError(frame, rejection.code, rejection.message, controlFlags(), sock, generation);
+      } finally {
+        await this.opts.onRouteGone?.(tentative);
+      }
+      return;
+    }
+    try {
+      await this.sendOn(sock, generation, buildFrameWithVersion(frame.header.ver, FrameType.Response, controlFlags(), 0, 0, frame.header.corr, encodeJson({ op: "route.bind" })));
+    } catch (error51) {
+      await this.opts.onRouteGone?.(tentative);
+      throw error51;
+    }
+    if (this.sock !== sock || this.generation !== generation || this.closeStarted || this.closedErr) {
+      await this.opts.onRouteGone?.(tentative);
+      return;
+    }
+    this.liveRoutes.set(tentative.channel, tentative);
+    await this.opts.onBound?.(tentative);
+  }
+  async handleDataRequest(frame, handle, sock, generation) {
+    const { corr, ver } = frame.header;
+    const key = routeKey(handle, corr);
+    const controller = new AbortController;
+    this.inflight.set(key, controller);
+    const context = {
+      handle,
+      signal: controller.signal,
+      currentEpoch: () => this.connectionEpoch,
+      emit: async (eventBody, options = {}) => {
+        this.assertLiveHandle(handle);
+        if (controller.signal.aborted)
+          return;
+        await this.sendOn(sock, generation, buildFrameWithVersion(ver, FrameType.StreamData, buildFlags(false, options.priority ?? Priority.Interactive, false, options.admissionClass ?? AdmissionClass.Normal), handle.channel, handle.epoch, corr, eventBody));
+      }
+    };
+    const releasePermit = await (this.requestGate ?? new AsyncPermitPool(DEFAULT_PROVIDER_HANDLER_CAPACITY)).acquire();
+    const dataFlags = buildFlags(false, Priority.Interactive, false);
+    try {
+      const body = await this.opts.handler(handle, frame.body, context);
+      if (controller.signal.aborted)
+        return;
+      this.assertLiveHandle(handle);
+      if (body === undefined) {
+        await this.sendOn(sock, generation, buildFrameWithVersion(ver, FrameType.StreamEnd, dataFlags, handle.channel, handle.epoch, corr, new Uint8Array(0)));
+      } else if (body instanceof Uint8Array) {
+        await this.sendOn(sock, generation, buildFrameWithVersion(ver, FrameType.Response, dataFlags, handle.channel, handle.epoch, corr, body));
+      } else {
+        throw new SubcProviderError("provider handler must return a Uint8Array or void", "invalid_handler_response");
+      }
+    } catch (error51) {
+      if (error51 instanceof StaleRouteHandleError || controller.signal.aborted)
+        return;
+      await this.sendError(frame, error51 instanceof SubcProviderError && error51.code ? error51.code : "handler_error", error51 instanceof Error ? error51.message : String(error51), dataFlags, sock, generation);
+    } finally {
+      releasePermit();
+      if (this.inflight.get(key) === controller)
+        this.inflight.delete(key);
+    }
+  }
+  async handleHealthRequest(frame, sock, generation) {
+    const { corr, ver } = frame.header;
+    const key = `control:${generation}:${corr}`;
+    const controller = new AbortController;
+    this.inflight.set(key, controller);
+    const releasePermit = await (this.requestGate ?? new AsyncPermitPool(DEFAULT_PROVIDER_HANDLER_CAPACITY)).acquire();
+    try {
+      if (controller.signal.aborted)
+        return;
+      const report = await this.opts.health();
+      await this.sendOn(sock, generation, buildFrameWithVersion(ver, FrameType.Response, controlFlags(), 0, 0, corr, encodeJson({
+        op: HEALTH_CHECK_OP,
+        status: report.status,
+        ...report.detail === undefined ? {} : { detail: report.detail },
+        ...report.metrics === undefined ? {} : { metrics: report.metrics }
+      })));
+    } catch (error51) {
+      await this.sendError(frame, error51 instanceof SubcProviderError && error51.code ? error51.code : "health_error", error51 instanceof Error ? error51.message : String(error51), controlFlags(), sock, generation);
+    } finally {
+      releasePermit();
+      if (this.inflight.get(key) === controller)
+        this.inflight.delete(key);
+    }
+  }
+  async sendError(frame, code, message, flags, sock, generation) {
+    await this.sendOn(sock, generation, buildFrameWithVersion(frame.header.ver, FrameType.Error, flags, frame.header.channel, frame.header.epoch, frame.header.corr, encodeJson({ code, message })));
+  }
+  async sendOn(sock, generation, frame) {
+    if (this.sock !== sock || this.generation !== generation || this.closeStarted || this.closedErr)
+      return;
+    await sendFrame(sock, frame);
+  }
+  handleUnexpectedDrop(sock, generation, cause) {
+    this.cancelRestoredDebounce();
+    this.abortGeneration(generation);
+    this.generation += 1;
+    sock.close();
+    this.enqueueConnectionState({ state: "down", cause });
+    this.scheduleReconnectAfterDrop(cause);
+  }
+  scheduleReconnectAfterDrop(trigger) {
+    if (this.closeStarted || this.reconnecting)
+      return;
+    const promise2 = this.reconnectWithRetry(trigger).catch((err) => {
+      if (!this.closeStarted)
+        this.failFatal(err instanceof Error ? err : new SubcProviderError(String(err)));
+    }).finally(() => {
+      if (this.reconnecting === promise2)
+        this.reconnecting = null;
+    });
+    this.reconnecting = promise2;
+  }
+  async reconnectWithRetry(_trigger) {
+    let attempt = 0;
+    let delay = this.opts.reconnectBackoff.baseMs;
+    for (;; ) {
+      if (this.closeStarted)
+        throw new SubcProviderError("provider closed");
+      attempt += 1;
+      this.enqueueConnectionState({ state: "reconnecting", attempt });
+      try {
+        const opened = await SubcProvider.openConnection(this.opts);
+        if (this.closeStarted) {
+          opened.sock.close();
+          throw new SubcProviderError("provider closed");
+        }
+        this.replaceConnection(opened);
+        return;
+      } catch (err) {
+        if (this.closeStarted)
+          throw err;
+        if (!isProviderReconnectTransient(err))
+          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.storage = opened.ack.storage;
+    this.closedErr = null;
+    this.connectionEpoch += 1;
+    this.connectionToken = newConnectionToken();
+    this.liveRoutes.clear();
+    this.nextCorr = 1n;
+    const generation = this.generation;
+    this.readLoop(opened.sock, generation);
+    this.scheduleRestored(generation, this.connectionEpoch);
+  }
+  scheduleRestored(generation, epoch) {
+    if (!this.opts.onConnectionState)
+      return;
+    const token = ++this.restoredDebounceToken;
+    this.opts.sleep(this.opts.restoredDebounceMs).then(() => {
+      if (token === this.restoredDebounceToken && !this.closeStarted && this.sock && this.generation === generation && this.connectionEpoch === epoch) {
+        this.enqueueConnectionState({ state: "restored", epoch });
+      }
+    }).catch((err) => {
+      if (token === this.restoredDebounceToken && !this.closeStarted) {
+        console.warn("SubcProvider restored debounce timer failed", err);
+      }
+    });
+  }
+  cancelRestoredDebounce() {
+    this.restoredDebounceToken += 1;
+  }
+  enqueueConnectionState(event) {
+    if (!this.opts.onConnectionState)
+      return;
+    this.stateQueue.push(event);
+    if (!this.drainingStateQueue)
+      this.drainConnectionStateQueue();
+  }
+  async drainConnectionStateQueue() {
+    if (this.drainingStateQueue)
+      return;
+    this.drainingStateQueue = true;
+    try {
+      while (this.stateQueue.length > 0) {
+        const event = this.stateQueue[0];
+        try {
+          await this.opts.onConnectionState?.(event);
+          this.stateQueue.shift();
+        } catch (err) {
+          if (event.state === "restored") {
+            console.warn("SubcProvider restored callback failed; retrying delivery", err);
+            await pauseBeforeStateRetry();
+            continue;
+          }
+          console.warn("SubcProvider connection-state callback failed", err);
+          this.stateQueue.shift();
+        }
+      }
+    } finally {
+      this.drainingStateQueue = false;
+      if (this.stateQueue.length > 0)
+        this.drainConnectionStateQueue();
+    }
+  }
+  isLiveHandle(handle) {
+    return belongsToConnection(handle, this.connectionToken) && this.liveRoutes.get(handle.channel) === handle;
+  }
+  assertLiveHandle(handle) {
+    if (!this.isLiveHandle(handle))
+      throw new StaleRouteHandleError(handle);
+  }
+  allocateCorr() {
+    const maximum = 0xffffffffffffffffn;
+    if (this.nextCorr > maximum) {
+      const error51 = new SubcProviderError("channel-0 correlation id allocator exhausted", "corr_exhausted");
+      this.handleUnexpectedDrop(this.sock, this.generation, error51);
+      throw error51;
+    }
+    const corr = this.nextCorr;
+    this.nextCorr += 1n;
+    return corr;
+  }
+  failFatal(err) {
+    if (!this.closedErr)
+      this.closedErr = err;
+    this.closeStarted = true;
+    this.cancelRestoredDebounce();
+    this.abortAllInflight();
+    this.sock.close();
+    this.finishClosed();
+  }
+  finishClosed() {
+    this.resolveClosed();
+  }
+}
+function routeKey(handle, corr) {
+  return `${handle.channel}:${handle.epoch}:${corr}`;
+}
+function providerErrorFromFrame(frame) {
+  try {
+    const body = parseJson(frame.body);
+    return new SubcProviderError(body.message ?? "subc error", body.code);
+  } catch {
+    return new SubcProviderError(Buffer2.from(frame.body).toString("utf8") || "subc error");
+  }
+}
+function launchNonce(opts) {
+  const nonce = opts.launchNonce ?? process.env[SUBC_LAUNCH_NONCE_ENV2];
+  return nonce && nonce.length > 0 ? nonce : undefined;
+}
+var SUBC_LAUNCH_NONCE_ENV2 = "SUBC_LAUNCH_NONCE";
+function normalizeProviderConnectOptions(opts) {
+  return {
+    connectionFile: opts.connectionFile,
+    manifest: opts.manifest,
+    handler: opts.handler,
+    health: opts.health ?? (() => ({ status: "ok" })),
+    handshakeTimeoutMs: opts.handshakeTimeoutMs,
+    controlOps: opts.controlOps,
+    onBind: opts.onBind,
+    onBound: opts.onBound,
+    onRouteGone: opts.onRouteGone,
+    reconnectBackoff: opts.reconnectBackoff ?? DEFAULT_RECONNECT_BACKOFF,
+    sleep: opts.sleep ?? ((ms) => new Promise((resolve2) => setTimeout(resolve2, ms))),
+    restoredDebounceMs: opts.restoredDebounceMs ?? DEFAULT_RESTORED_DEBOUNCE_MS,
+    onConnectionState: opts.onConnectionState,
+    launchNonce: opts.launchNonce
+  };
+}
+function normalizedControlOps(controlOps) {
+  if (controlOps === null)
+    return null;
+  const merged = new Set(controlOps ?? []);
+  merged.add(HEALTH_CHECK_OP);
+  return [...merged];
+}
+function buildHelloFrame(opts) {
+  const nonce = launchNonce(opts);
+  return buildFrame(FrameType.Hello, controlFlags(), 0, 0, HELLO_CORR, encodeJson({
+    manifest: normalizeManifest(opts.manifest),
+    protocol_ver: PROTOCOL_VERSION,
+    control_ops: normalizedControlOps(opts.controlOps),
+    ...nonce ? { launch_nonce: nonce } : {}
+  }));
+}
+function isProviderReconnectTransient(err) {
+  if (err instanceof SubcProviderError)
+    return err.code === "duplicate_module_id";
+  if (err instanceof SocketClosedError || err instanceof SocketTimeoutError)
+    return true;
+  if (err instanceof SocketWriteNotQueuedError || err instanceof SocketWriteQueuedError)
+    return true;
+  if (err instanceof AuthError)
+    return true;
+  if (err instanceof ConnectionFileError)
+    return false;
+  const code = errorCode2(err);
+  return code === "ECONNREFUSED" || code === "ECONNRESET" || code === "EPIPE" || code === "ETIMEDOUT" || code === "ENOENT";
+}
+function errorCode2(err) {
+  if (typeof err === "object" && err !== null && "code" in err) {
+    const code = err.code;
+    if (typeof code === "string")
+      return code;
+  }
+  return;
+}
+async function pauseBeforeStateRetry() {
+  await new Promise((resolve2) => setTimeout(resolve2, 0));
+}
+function controlFlags() {
+  return buildFlags(false, Priority.Passive, false);
+}
+async function sendFrame(sock, frame) {
+  await sock.write(encodeFrame(frame), Date.now() + WRITE_TIMEOUT_MS);
+}
+async function expectHelloAck(sock, deadline) {
+  const frame = await sock.readFrame(deadline, deadline);
+  switch (frame.header.ty) {
+    case FrameType.HelloAck: {
+      const ack = parseJson(frame.body);
+      if (ack.negotiated_ver !== PROTOCOL_VERSION) {
+        throw new SubcProviderError(`subc negotiated protocol ${ack.negotiated_ver}; expected exactly ${PROTOCOL_VERSION}`, "unsupported_version");
+      }
+      return ack;
+    }
+    case FrameType.Error: {
+      const error51 = parseJson(frame.body);
+      throw new SubcProviderError(`subc rejected HELLO: ${error51.code ?? "unknown"} — ${error51.message ?? "subc error"}`, error51.code);
+    }
+    default:
+      throw new SubcProviderError(`unexpected frame ${FrameType[frame.header.ty]} awaiting HELLO_ACK`);
+  }
+}
+function encodeJson(value) {
+  return new Uint8Array(Buffer2.from(JSON.stringify(value), "utf8"));
+}
+function parseJson(bytes) {
+  return JSON.parse(Buffer2.from(bytes).toString("utf8"));
+}
+function numberField(value, field) {
+  if (typeof value !== "number" || !Number.isInteger(value)) {
+    throw new SubcProviderError(`route.bind ${field} must be an integer`);
+  }
+  return value;
+}
+function bindRejection(decision) {
+  if (decision === undefined || decision === true)
+    return null;
+  if (decision === false) {
+    return { code: "route_rejected", message: "route.bind rejected by provider" };
+  }
+  if (decision.accept)
+    return null;
+  return {
+    code: decision.code ?? "route_rejected",
+    message: decision.message ?? "route.bind rejected by provider"
+  };
+}
+function normalizeManifest(manifest) {
+  return {
+    module_id: manifest.module_id,
+    module_version: manifest.module_version,
+    protocol_ver: manifest.protocol_ver,
+    trust_tier: manifest.trust_tier,
+    provides: manifest.provides.map(normalizeProviderRole),
+    consumes: manifest.consumes.map(normalizeConsumerRole),
+    scheduled_tasks: manifest.scheduled_tasks.map(normalizeScheduledTask),
+    bindings: {
+      storage: {
+        kind: manifest.bindings.storage.kind,
+        scope: manifest.bindings.storage.scope,
+        owns_schema: manifest.bindings.storage.owns_schema
+      },
+      vault_grants: manifest.bindings.vault_grants.map((grant) => ({
+        secret: grant.secret,
+        reason: grant.reason
+      })),
+      identity: {
+        requires: [...manifest.bindings.identity.requires],
+        optional: [...manifest.bindings.identity.optional]
+      }
+    }
+  };
+}
+function normalizeProviderRole(role) {
+  switch (role.role) {
+    case "tool_provider":
+      return {
+        role: "tool_provider",
+        tools: role.tools.map((tool) => ({
+          name: tool.name,
+          ...tool.description === undefined ? {} : { description: tool.description },
+          execution_mode: tool.execution_mode,
+          schema: tool.schema
+        })),
+        identity_scope: [...role.identity_scope],
+        concurrency: role.concurrency,
+        emits_push: role.emits_push,
+        sub_supervises: role.sub_supervises
+      };
+    case "pipeline_stage":
+      return {
+        role: "pipeline_stage",
+        stage: role.stage,
+        applies_to: {
+          provider: role.applies_to.provider,
+          model: role.applies_to.model
+        },
+        interface: role.interface,
+        declares_frozen_floor: role.declares_frozen_floor,
+        needs_signals: [...role.needs_signals],
+        conformance_class: role.conformance_class
+      };
+    case "management_surface":
+      return {
+        role: "management_surface",
+        operations: role.operations.map((operation) => ({
+          name: operation.name,
+          kind: operation.kind
+        })),
+        config_schema: role.config_schema,
+        observability: role.observability.map((surface) => ({
+          name: surface.name,
+          kind: surface.kind
+        })),
+        identity_scope: [...role.identity_scope]
+      };
+    case "internal_service":
+      return {
+        role: "internal_service",
+        service_id: role.service_id,
+        transport: role.transport,
+        agent_facing: role.agent_facing,
+        operations: [...role.operations]
+      };
+  }
+}
+function normalizeConsumerRole(role) {
+  switch (role.role) {
+    case "tool_client":
+      return { role: "tool_client", of: [...role.of] };
+    case "llm_client":
+      return { role: "llm_client", via: role.via, auth: role.auth };
+    case "service_client":
+      return { role: "service_client", of: [...role.of] };
+  }
+}
+function normalizeScheduledTask(task) {
+  return {
+    task_id: task.task_id,
+    eligibility: {
+      cooldown: task.eligibility.cooldown,
+      window: task.eligibility.window
+    },
+    lease_scope: task.lease_scope,
+    renews_during_calls: task.renews_during_calls,
+    toolset: [...task.toolset],
+    model_policy: {
+      tier: task.model_policy.tier,
+      fallback_chain: [...task.model_policy.fallback_chain]
+    },
+    step_cap: task.step_cap,
+    circuit_breaker: {
+      identical_failures: task.circuit_breaker.identical_failures
+    }
+  };
+}
+// ../plugin/src/features/magic-context/memory/embedding-synapse.ts
+init_logger();
+var SYNAPSE_DEFAULT_MODEL = "gte-modernbert-base-f16";
+var SYNAPSE_MAX_INPUT_TOKENS = 8192;
+var SYNAPSE_DEFAULT_QUERY_TIMEOUT_MS = 3000;
+var SYNAPSE_DEFAULT_BATCH_TIMEOUT_MS = 120000;
+
+class SynapseEmbeddingError extends Error {
+  code;
+  retryAfterMs;
+  permanent;
+  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);
+  }
+}
+function isPermanentSynapseCode(code) {
+  return code === "artifact_invalid" || code === "substitution_rejected" || code === "not_certified" || code === "probe_required" || code === "idempotency_conflict" || code === "schema_violation";
+}
+function asRecord(value) {
+  return value !== null && typeof value === "object" ? value : null;
+}
+function responseBody(value) {
+  const record2 = asRecord(value);
+  const result = asRecord(record2?.result);
+  return result ? { ...record2, ...result } : record2 ?? {};
+}
+function readRetryAfter(value) {
+  const record2 = asRecord(value);
+  const candidate = record2?.retry_after_ms ?? record2?.retryAfterMs;
+  if (typeof candidate !== "number" || !Number.isFinite(candidate) || candidate < 0)
+    return;
+  return Math.ceil(candidate);
+}
+function readErrorCode(value) {
+  const record2 = asRecord(value);
+  if (typeof record2?.code === "string")
+    return record2.code;
+  if (value instanceof Error && "code" in value && typeof value.code === "string") {
+    return value.code;
+  }
+  return;
+}
+function classifyError(value) {
+  if (value instanceof SynapseEmbeddingError)
+    return value;
+  const code = readErrorCode(value) ?? (value instanceof Error ? value.name : "transport");
+  const normalized = code.toLowerCase();
+  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.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("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
+  });
+}
+function wait(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+function sha256(value) {
+  return createHash4("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)
+  }));
+}
+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;
+  return raw.flatMap((entry) => {
+    const record2 = asRecord(entry);
+    if (!record2)
+      return [];
+    const model = typeof record2.model === "string" && record2.model.length > 0 ? record2.model : typeof record2.model_id === "string" ? record2.model_id : "";
+    const fingerprint = typeof record2.fingerprint === "string" && record2.fingerprint.length > 0 ? record2.fingerprint : Array.isArray(record2.fingerprints) && typeof record2.fingerprints[0] === "string" ? record2.fingerprints[0] : "";
+    const entryEpoch = record2.table_epoch ?? record2.tableEpoch;
+    const tableEpoch = typeof entryEpoch === "number" && Number.isInteger(entryEpoch) ? entryEpoch : envelopeEpoch;
+    const dims = record2.dims ?? record2.dimensions;
+    if (model.length === 0 || fingerprint.length === 0 || typeof tableEpoch !== "number" || !Number.isInteger(tableEpoch)) {
+      return [];
+    }
+    const recommendedBatch = record2.recommended_batch ?? record2.recommendedBatch;
+    const state = typeof record2.state === "string" ? record2.state : undefined;
+    return [
+      {
+        model,
+        fingerprint,
+        table_epoch: tableEpoch,
+        ...typeof dims === "number" && Number.isInteger(dims) && dims > 0 ? { dims } : {},
+        ...typeof recommendedBatch === "number" && recommendedBatch > 0 ? { recommended_batch: Math.floor(recommendedBatch) } : {},
+        ...record2.provenance !== undefined ? { provenance: record2.provenance } : {},
+        ...typeof record2.certified === "boolean" ? { certified: record2.certified } : {},
+        ...typeof record2.status === "string" ? { status: record2.status } : state ? { status: state } : {}
+      }
+    ];
+  });
+}
+function extractVector(value) {
+  const body = responseBody(value);
+  const fromVectors = Array.isArray(body.vectors) ? asRecord(body.vectors[0])?.vector : undefined;
+  const raw = fromVectors ?? body.vector ?? body.embedding;
+  if (!Array.isArray(raw) || raw.some((item) => typeof item !== "number" || !Number.isFinite(item))) {
+    return null;
+  }
+  return { vector: Float32Array.from(raw), 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 record2 = asRecord(item);
+    return record2 ? [record2] : [];
+  });
+}
+var sharedClient = null;
+var sharedClientFile = null;
+var sharedClientPromise = null;
+var factoryClients = new WeakMap;
+async function getSharedClient(options) {
+  if (options.clientFactory) {
+    let promise2 = factoryClients.get(options.clientFactory);
+    if (!promise2) {
+      promise2 = options.clientFactory();
+      factoryClients.set(options.clientFactory, promise2);
+    }
+    return promise2;
+  }
+  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;
+  maxInputTokens = SYNAPSE_MAX_INPUT_TOKENS;
+  metadata;
+  options;
+  client = null;
+  initialized = false;
+  initializing = null;
+  permanentFailure = false;
+  batchLimit = 16;
+  constructor(options) {
+    this.options = options;
+    const model = options.model || SYNAPSE_DEFAULT_MODEL;
+    const fingerprint = options.fingerprint ?? "";
+    this.metadata = fingerprint && Number.isInteger(options.tableEpoch) && Number.isInteger(options.dims) && (options.dims ?? 0) > 0 ? {
+      model,
+      fingerprint,
+      table_epoch: options.tableEpoch,
+      dims: options.dims,
+      ...options.recommendedBatch ? { recommended_batch: Math.max(1, Math.floor(options.recommendedBatch)) } : {},
+      ...options.provenance !== undefined ? { provenance: options.provenance } : {},
+      laneIdentity: getSynapseLaneIdentity(model, fingerprint)
+    } : null;
+    this.modelId = this.metadata?.laneIdentity ?? "synapse:v1:pending";
+    this.batchLimit = this.metadata?.recommended_batch ?? 16;
+  }
+  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.initialized = true;
+        return true;
+      } catch (error51) {
+        const classified = classifyError(error51);
+        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) {
+    if (!await this.initialize() || signal?.aborted || !this.metadata)
+      return null;
+    try {
+      const value = await this.callWithRetry("embed.query", this.requestConstraints({
+        text,
+        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");
+      this.validateResponse(extracted.metadata, extracted.vector.length);
+      return extracted.vector;
+    } catch (error51) {
+      this.logCallFailure(error51, "embed.query");
+      return null;
+    }
+  }
+  async embedBatch(texts, signal) {
+    if (texts.length === 0)
+      return [];
+    const items = texts.map((text, index) => ({
+      id: `item:${index}`,
+      text,
+      contentSha256: hashContent(text)
+    }));
+    const map2 = await this.embedItems(items, signal);
+    return items.map((item) => map2.get(item.id) ?? null);
+  }
+  async embedItems(items, signal) {
+    const output = new Map;
+    if (items.length === 0 || !await this.initialize() || !this.metadata || signal?.aborted) {
+      return output;
+    }
+    for (let start = 0;start < items.length; start += this.batchLimit) {
+      if (signal?.aborted || this.permanentFailure)
+        break;
+      const page = items.slice(start, start + this.batchLimit);
+      try {
+        const requestKey = this.requestKey(page);
+        let body = {};
+        let restarted = false;
+        for (;; ) {
+          try {
+            body = await this.callWithRetry("embed.batch", this.batchRequest(page, requestKey), 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 (error51) {
+            const classified = classifyError(error51);
+            if (classified.code !== "module_restarted" || restarted)
+              throw classified;
+            restarted = true;
+          }
+        }
+        const batchEnvelope = responseBody(body);
+        for (const item of extractBatchItems(body)) {
+          const id = typeof item.id === "string" ? item.id : "";
+          const vector = item.vector ?? item.embedding;
+          if (!id || !Array.isArray(vector)) {
+            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}`);
+          }
+          if (typeof item.content_sha256 === "string" && item.content_sha256 !== expected.contentSha256) {
+            throw new SynapseEmbeddingError("artifact_invalid", `Synapse content hash mismatch for item ${id}`);
+          }
+          const vectorArray = Float32Array.from(vector);
+          this.validateResponse({ ...batchEnvelope, ...item }, vectorArray.length);
+          output.set(id, vectorArray);
+        }
+      } catch (error51) {
+        const classified = classifyError(error51);
+        this.logCallFailure(classified, "embed.batch");
+        if (classified.code === "idempotency_conflict")
+          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;
+  }
+  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) {
+    return this.requestConstraints({
+      items: items.map((item) => ({
+        id: item.id,
+        text: item.text,
+        content_sha256: item.contentSha256
+      })),
+      request_key: requestKey
+    });
+  }
+  requestKey(items) {
+    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
+    });
+  }
+  async pollBatch(jobId, requestKey, signal) {
+    let cursor = null;
+    const allItems = [];
+    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);
+      allItems.push(...items);
+      const nextCursor = parsed.next_cursor ?? parsed.cursor;
+      const done = parsed.done === true || parsed.complete === true || nextCursor === undefined || nextCursor === null;
+      if (done)
+        return { ...parsed, items: allItems };
+      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 (error51) {
+        const classified = classifyError(error51);
+        if (classified.code === "idempotency_conflict")
+          throw classified;
+        const outcomeUnknown = error51 instanceof SubcCallError && error51.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(error51, operation) {
+    const classified = classifyError(error51);
+    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}`);
+  }
+}
+
+// ../plugin/src/features/magic-context/memory/normalize-hash.ts
+import { createHash as createHash5 } from "node:crypto";
 function normalizeMemoryContent(content) {
   return content.toLowerCase().replace(/\s+/g, " ").trim();
 }
 function computeNormalizedHash(content) {
   const normalized = normalizeMemoryContent(content);
-  return createHash4("md5").update(normalized).digest("hex");
+  return createHash5("md5").update(normalized).digest("hex");
 }
 
 // ../plugin/src/features/magic-context/memory/embedding-identity.ts
@@ -161380,6 +164311,15 @@ function getEmbeddingProviderIdentity(config2) {
   if (config2.provider === "off") {
     return "embedding-provider:off";
   }
+  if (config2.provider === "synapse") {
+    const resolved = config2;
+    if (!resolved.model || !resolved.synapse_fingerprint)
+      return "synapse:v1:pending";
+    return getSynapseLaneIdentity(resolved.model, resolved.synapse_fingerprint);
+  }
+  if (config2.provider !== "local" && config2.provider !== "openai-compatible") {
+    throw new Error("Unknown embedding provider");
+  }
   const truncate = config2.provider === "openai-compatible" ? config2.truncate?.trim() : undefined;
   const identityInput = config2.provider === "openai-compatible" ? {
     provider: "openai-compatible",
@@ -162169,7 +165109,7 @@ function getMemoryEmbedCoverage(db, projectPath, modelId) {
 }
 
 // ../plugin/src/features/magic-context/project-embedding-registry.ts
-import { createHash as createHash5, randomUUID } from "node:crypto";
+import { createHash as createHash7, randomUUID } from "node:crypto";
 init_logger();
 
 // ../plugin/src/features/magic-context/git-commits/storage-git-commit-embeddings.ts
@@ -162622,6 +165562,37 @@ function repairMisScopedCompartmentChunkEmbeddingsForProject(db, projectPath) {
   return getRepairProjectChunkProjectStatement(db).run(projectPath, projectPath).changes;
 }
 
+// ../plugin/src/features/magic-context/storage-embedding-measurements.ts
+import { createHash as createHash6 } from "node:crypto";
+function normalizedQueryHash(query) {
+  const normalized = query.trim().replace(/\s+/g, " ").toLowerCase();
+  return createHash6("sha256").update(normalized).digest("hex");
+}
+function recordEmbeddingMeasurement(db, input) {
+  const queryTextHash = normalizedQueryHash(input.queryText);
+  const dedupKey = queryTextHash;
+  const result = db.prepare(`INSERT OR IGNORE INTO embedding_measurement_corpus
+            (session_id, project_path, dedup_key, cohort_key, query_text_hash,
+             primary_result_ids_json, shadow_result_ids_json, primary_latency_ms, shadow_latency_ms,
+             primary_failed, shadow_failed, primary_model_id, shadow_model_id,
+             primary_fingerprint, shadow_fingerprint, primary_epoch, shadow_epoch,
+             corpus_hash, coverage_json, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(input.sessionId, input.projectPath, dedupKey, input.cohortKey, queryTextHash, JSON.stringify(input.primaryResultIds.slice(0, 10)), JSON.stringify(input.shadowResultIds.slice(0, 10)), input.primaryLatencyMs, input.shadowLatencyMs, input.primaryFailed ? 1 : 0, input.shadowFailed ? 1 : 0, input.primaryModelId, input.shadowModelId, input.primaryFingerprint, input.shadowFingerprint, input.primaryEpoch, input.shadowEpoch, input.corpusHash, JSON.stringify(input.coverage), Date.now());
+  return result.changes > 0;
+}
+function beginSynapseBatchLedger(db, input) {
+  const now = Date.now();
+  db.prepare(`INSERT INTO synapse_batch_ledger
+            (session_id, project_path, scope, manifest_json, request_key, status, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, 'pending', ?, ?)
+         ON CONFLICT(session_id, request_key) DO UPDATE SET
+            manifest_json = excluded.manifest_json,
+            updated_at = excluded.updated_at`).run(input.sessionId, input.projectPath, input.scope, JSON.stringify(input.manifest), input.requestKey, now, now);
+}
+function finishSynapseBatchLedger(db, sessionId, requestKey, status) {
+  db.prepare("UPDATE synapse_batch_ledger SET status = ?, updated_at = ? WHERE session_id = ? AND request_key = ?").run(status, Date.now(), sessionId, requestKey);
+}
+
 // ../plugin/src/features/magic-context/project-embedding-registry.ts
 var OFF_PROVIDER_IDENTITY = "embedding-provider:off";
 var SWEEP_MAX_WALL_CLOCK_MS = 10 * 60 * 1000;
@@ -162637,6 +165608,12 @@ var EMBED_SLICE_RETRY_BASE_MS = 250;
 var EMBED_SLOW_FAILURE_NO_RETRY_MS = 1e4;
 var MAX_CONSECUTIVE_FAILED_BATCHES = 3;
 var projectRegistrations = new Map;
+var shadowRegistrations = new Map;
+var shadowQueue = [];
+var shadowWorker = null;
+var SHADOW_MAX_ITEMS_PER_TICK = 64;
+var SHADOW_MAX_BYTES_PER_TICK = 512 * 1024;
+var SHADOW_MAX_WALL_CLOCK_MS = 2000;
 var loadUnembeddedMemoriesStatements = new WeakMap;
 var upsertActiveIdentityStatements = new WeakMap;
 var backfillActiveIdentityStatements = new Map;
@@ -162648,6 +165625,35 @@ function markProjectLoadUntrusted(projectIdentity) {
   untrustedLoadProjects.add(projectIdentity);
 }
 var testProviderFactory = null;
+function synapseConfigFields(config2) {
+  const raw = config2;
+  return {
+    ...typeof raw.model === "string" ? { model: raw.model } : {},
+    ...typeof raw.synapse_fingerprint === "string" ? { fingerprint: raw.synapse_fingerprint } : {},
+    ...typeof raw.synapse_table_epoch === "number" ? { tableEpoch: raw.synapse_table_epoch } : {},
+    ...typeof raw.synapse_dims === "number" ? { dims: raw.synapse_dims } : {},
+    ...raw.synapse_provenance !== undefined ? { provenance: raw.synapse_provenance } : {}
+  };
+}
+function persistPrimaryDescriptor(db, registration) {
+  const descriptorTable = db.prepare("SELECT 1 AS present FROM sqlite_master WHERE type = 'table' AND name = 'embedding_registrations'").get();
+  if (!descriptorTable)
+    return;
+  const fields = synapseConfigFields(registration.config);
+  db.prepare(`INSERT INTO embedding_registrations
+            (project_path, provider_identity, model_id, chunk_model_id, fingerprint, table_epoch, dims, provenance_json, generation, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(project_path) DO UPDATE SET
+            provider_identity = excluded.provider_identity,
+            model_id = excluded.model_id,
+            chunk_model_id = excluded.chunk_model_id,
+            fingerprint = excluded.fingerprint,
+            table_epoch = excluded.table_epoch,
+            dims = excluded.dims,
+            provenance_json = excluded.provenance_json,
+            generation = excluded.generation,
+            updated_at = excluded.updated_at`).run(registration.projectIdentity, registration.providerIdentity, registration.modelId, registration.chunkModelId, fields.fingerprint ?? "", fields.tableEpoch ?? 0, fields.dims ?? 0, JSON.stringify(fields.provenance ?? {}), registration.generation, Date.now());
+}
 function resolveEmbeddingConfig(config2) {
   if (!config2 || config2.provider === "local") {
     return {
@@ -162676,9 +165682,26 @@ function resolveEmbeddingConfig(config2) {
       } : {}
     };
   }
-  return { provider: "off" };
+  if (config2.provider === "off") {
+    return { provider: "off" };
+  }
+  if (config2.provider === "synapse") {
+    const synapse = config2;
+    return {
+      provider: "synapse",
+      model: synapse.model?.trim() || "gte-modernbert-base-f16",
+      max_input_tokens: SYNAPSE_MAX_INPUT_TOKENS,
+      ...synapse.synapse_connection_file ? { synapse_connection_file: synapse.synapse_connection_file } : {},
+      ...synapse.synapse_fingerprint ? { synapse_fingerprint: synapse.synapse_fingerprint } : {},
+      ...typeof synapse.synapse_table_epoch === "number" ? { synapse_table_epoch: synapse.synapse_table_epoch } : {},
+      ...typeof synapse.synapse_dims === "number" ? { synapse_dims: synapse.synapse_dims } : {},
+      ...typeof synapse.synapse_recommended_batch === "number" ? { synapse_recommended_batch: synapse.synapse_recommended_batch } : {},
+      ...synapse.synapse_provenance !== undefined ? { synapse_provenance: synapse.synapse_provenance } : {}
+    };
+  }
+  throw new Error("Unknown embedding provider");
 }
-function createProvider(config2) {
+function createProvider(config2, context) {
   if (testProviderFactory) {
     return testProviderFactory(config2);
   }
@@ -162696,7 +165719,24 @@ function createProvider(config2) {
       maxInputTokens: config2.max_input_tokens
     });
   }
-  return new LocalEmbeddingProvider(config2.model, config2.max_input_tokens);
+  if (config2.provider === "local") {
+    return new LocalEmbeddingProvider(config2.model, config2.max_input_tokens);
+  }
+  if (config2.provider === "synapse") {
+    const synapse = config2;
+    return new SynapseEmbeddingProvider({
+      connectionFile: synapse.synapse_connection_file ?? "",
+      projectRoot: context?.projectRoot ?? "",
+      session: context?.session ?? "embedding",
+      model: synapse.model,
+      fingerprint: synapse.synapse_fingerprint,
+      tableEpoch: synapse.synapse_table_epoch,
+      dims: synapse.synapse_dims,
+      recommendedBatch: synapse.synapse_recommended_batch,
+      provenance: synapse.synapse_provenance
+    });
+  }
+  throw new Error("Unknown embedding provider");
 }
 function stableStringify2(value) {
   if (Array.isArray(value)) {
@@ -162709,7 +165749,10 @@ function stableStringify2(value) {
   return JSON.stringify(value);
 }
 function sha256Prefix(value, length = 16) {
-  return createHash5("sha256").update(value).digest("hex").slice(0, length);
+  return createHash7("sha256").update(value).digest("hex").slice(0, length);
+}
+function contentSha256(value) {
+  return createHash7("sha256").update(value).digest("hex");
 }
 function getRuntimeFingerprint(config2) {
   if (config2.provider === "off") {
@@ -162736,6 +165779,7 @@ function snapshotFor(registration) {
   const providerIsOn = registration.providerIdentity !== OFF_PROVIDER_IDENTITY;
   const enabled = !registration.observationMode && providerIsOn && registration.features.memoryEnabled;
   const gitCommitEnabled = !registration.observationMode && providerIsOn && registration.features.gitCommitEnabled;
+  const configuredModel = "model" in registration.config && typeof registration.config.model === "string" ? registration.config.model.trim() : "";
   return {
     projectIdentity: registration.projectIdentity,
     sourceDirectory: registration.sourceDirectory,
@@ -162747,7 +165791,7 @@ function snapshotFor(registration) {
     gitCommitEnabled,
     modelId: registration.observationMode || !providerIsOn ? "off" : registration.modelId,
     chunkModelId: registration.observationMode || !providerIsOn ? "off" : registration.chunkModelId,
-    model: registration.observationMode || !providerIsOn ? "off" : ("model" in registration.config) && registration.config.model.trim() ? registration.config.model.trim() : registration.modelId,
+    model: registration.observationMode || !providerIsOn ? "off" : configuredModel ? configuredModel : registration.modelId,
     provider: registration.observationMode || !providerIsOn ? "off" : registration.config.provider ?? "local"
   };
 }
@@ -162854,9 +165898,9 @@ function getDeleteActiveIdentityStatement(db) {
   }
   return stmt;
 }
-function staleModelsForScope(db, projectIdentity, scope, currentModelId, cutoff) {
+function staleModelsForScope(db, projectIdentity, scope, currentModelId, cutoff, protectedModelIds = new Set([currentModelId])) {
   const rows = getStaleIdentityStatement(db, scope).all(projectIdentity, scope, currentModelId, cutoff);
-  return rows.map((row) => row.modelId).filter((modelId) => typeof modelId === "string");
+  return rows.map((row) => row.modelId).filter((modelId) => typeof modelId === "string" && !protectedModelIds.has(modelId));
 }
 function deleteStaleEmbeddingBatch(db, scope, projectIdentity, modelId, limit) {
   if (scope === "memory") {
@@ -162921,6 +165965,12 @@ function sweepStaleEmbeddingIdentitiesForProject(db, projectIdentity, now = Date
     return result;
   const cutoff = now - EMBEDDING_IDENTITY_GC_GRACE_MS;
   const deleteTracking = getDeleteActiveIdentityStatement(db);
+  const shadow = shadowRegistrations.get(projectIdentity);
+  const protectedModels = {
+    memory: new Set([snapshot.modelId, ...shadow ? [shadow.modelId] : []]),
+    commit: new Set([snapshot.modelId, ...shadow ? [shadow.modelId] : []]),
+    chunk: new Set([snapshot.chunkModelId, ...shadow ? [shadow.chunkModelId] : []])
+  };
   const scopes = [
     {
       scope: "memory",
@@ -162944,7 +165994,7 @@ function sweepStaleEmbeddingIdentitiesForProject(db, projectIdentity, now = Date
     for (const { scope, enabled, currentModelId } of scopes) {
       if (!enabled || remainingBudget === 0)
         continue;
-      for (const modelId of staleModelsForScope(db, projectIdentity, scope, currentModelId, cutoff)) {
+      for (const modelId of staleModelsForScope(db, projectIdentity, scope, currentModelId, cutoff, protectedModels[scope])) {
         if (remainingBudget === 0)
           break;
         const deleted = deleteStaleEmbeddingBatch(db, scope, projectIdentity, modelId, remainingBudget);
@@ -162998,11 +166048,206 @@ function registerProjectEmbedding(db, projectIdentity, config2, features, source
     observationMode: false
   };
   projectRegistrations.set(projectIdentity, registration);
+  persistPrimaryDescriptor(db, registration);
   if (!canReuseProvider) {
     disposeProvider(prior?.provider ?? null);
   }
   return snapshotFor(registration);
 }
+function startShadowWorker() {
+  if (shadowWorker)
+    return;
+  shadowWorker = runShadowWorker().finally(() => {
+    shadowWorker = null;
+    if (shadowQueue.length > 0)
+      startShadowWorker();
+  });
+}
+function getShadowEmbeddingMeasurementCohort(projectIdentity) {
+  const registration = shadowRegistrations.get(projectIdentity);
+  if (!registration)
+    return null;
+  const fields = synapseConfigFields(registration.config);
+  return {
+    modelId: registration.modelId,
+    chunkModelId: registration.chunkModelId,
+    fingerprint: fields.fingerprint ?? "",
+    epoch: fields.tableEpoch ?? 0,
+    dims: fields.dims ?? 0
+  };
+}
+function getPrimaryEmbeddingMeasurementCohort(projectIdentity) {
+  const registration = projectRegistrations.get(projectIdentity);
+  if (!registration)
+    return null;
+  const fields = synapseConfigFields(registration.config);
+  return {
+    modelId: registration.modelId,
+    chunkModelId: registration.chunkModelId,
+    fingerprint: fields.fingerprint ?? "",
+    epoch: fields.tableEpoch ?? 0,
+    dims: fields.dims ?? 0
+  };
+}
+async function embedShadowTextForProject(projectIdentity, text, signal) {
+  const registration = shadowRegistrations.get(projectIdentity);
+  if (!registration)
+    return null;
+  try {
+    return await registration.provider.embed(text, signal, "query");
+  } catch (error51) {
+    log("[magic-context] Synapse shadow query failed:", error51);
+    return null;
+  }
+}
+function enqueueShadowEmbeddingItems(projectIdentity, scope, ids) {
+  if (ids.length === 0 || !shadowRegistrations.has(projectIdentity))
+    return;
+  shadowQueue.push({ projectIdentity, scope, ids: [...ids] });
+  startShadowWorker();
+}
+async function embedShadowItems(registration, items, db, scope) {
+  const raw = registration.config;
+  const fingerprint = typeof raw.synapse_fingerprint === "string" ? raw.synapse_fingerprint : "";
+  const tableEpoch = typeof raw.synapse_table_epoch === "number" ? raw.synapse_table_epoch : 0;
+  const requestKey = getSynapseBatchRequestKey({
+    model: typeof raw.model === "string" ? raw.model : SYNAPSE_DEFAULT_MODEL,
+    fingerprint,
+    tableEpoch,
+    items
+  });
+  beginSynapseBatchLedger(db, {
+    sessionId: `shadow:${registration.projectIdentity}`,
+    projectPath: registration.projectIdentity,
+    scope,
+    manifest: items.map(({ id, contentSha256: contentSha2562 }) => ({ id, contentSha256: contentSha2562 })),
+    requestKey
+  });
+  try {
+    if (registration.provider.embedItems) {
+      const vectors2 = await registration.provider.embedItems(items);
+      finishSynapseBatchLedger(db, `shadow:${registration.projectIdentity}`, requestKey, vectors2.size === items.length ? "complete" : "partial");
+      return vectors2;
+    }
+    const positional = await registration.provider.embedBatch(items.map((item) => item.text));
+    const vectors = new Map(items.flatMap((item, index) => {
+      const vector = positional[index];
+      return vector ? [[item.id, vector]] : [];
+    }));
+    finishSynapseBatchLedger(db, `shadow:${registration.projectIdentity}`, requestKey, vectors.size === items.length ? "complete" : "partial");
+    return vectors;
+  } catch (error51) {
+    finishSynapseBatchLedger(db, `shadow:${registration.projectIdentity}`, requestKey, "failed");
+    throw error51;
+  }
+}
+async function processShadowQueueItem(item) {
+  const registration = shadowRegistrations.get(item.projectIdentity);
+  if (!registration)
+    return;
+  const boundedIds = item.ids.slice(0, SHADOW_MAX_ITEMS_PER_TICK);
+  if (item.scope === "memory") {
+    const db2 = dbForShadowQueue.get(item.projectIdentity);
+    if (!db2)
+      return;
+    const placeholders3 = boundedIds.map(() => "?").join(",");
+    const rows = db2.prepare(`SELECT id, content, normalized_hash FROM memories
+                 WHERE project_path = ? AND id IN (${placeholders3}) AND status = 'active'`).all(item.projectIdentity, ...boundedIds.map((id) => Number(id)));
+    const vectors2 = await embedShadowItems(registration, rows.map((row) => ({
+      id: `memory:${row.id}`,
+      text: row.content,
+      contentSha256: contentSha256(row.content)
+    })), db2, "memory");
+    db2.transaction(() => {
+      for (const row of rows) {
+        const vector = vectors2.get(`memory:${row.id}`);
+        if (vector)
+          saveEmbeddingIfHashMatches(db2, row.id, vector, registration.modelId, row.normalized_hash);
+      }
+    })();
+    return;
+  }
+  if (item.scope === "commit") {
+    const db2 = dbForShadowQueue.get(item.projectIdentity);
+    if (!db2)
+      return;
+    const placeholders3 = boundedIds.map(() => "?").join(",");
+    const rows = db2.prepare(`SELECT sha, message FROM git_commits WHERE project_path = ? AND sha IN (${placeholders3})`).all(item.projectIdentity, ...boundedIds);
+    const vectors2 = await embedShadowItems(registration, rows.map((row) => ({
+      id: `commit:${row.sha}`,
+      text: row.message,
+      contentSha256: contentSha256(row.message)
+    })), db2, "commit");
+    db2.transaction(() => {
+      for (const row of rows) {
+        const vector = vectors2.get(`commit:${row.sha}`);
+        if (vector)
+          saveCommitEmbedding(db2, row.sha, vector, registration.modelId);
+      }
+    })();
+    return;
+  }
+  const db = dbForShadowQueue.get(item.projectIdentity);
+  if (!db)
+    return;
+  const placeholders2 = boundedIds.map(() => "?").join(",");
+  const candidates = db.prepare(`SELECT id, session_id, start_message, end_message
+         FROM compartments WHERE id IN (${placeholders2})`).all(...boundedIds.map((id) => Number(id)));
+  const prepared = candidates.flatMap((candidate) => {
+    const text = buildCanonicalChunkTextFromFts(db, candidate.session_id, candidate.start_message, candidate.end_message) || buildCompartmentSummaryFallbackText(db, candidate.id);
+    if (!text)
+      return [];
+    const windows = chunkCanonicalText(text, candidate.start_message, candidate.end_message, SYNAPSE_MAX_INPUT_TOKENS);
+    return windows.length > 0 ? [{ candidate, windows }] : [];
+  });
+  const items = prepared.flatMap((item2) => item2.windows.map((window) => ({
+    id: `chunk:${item2.candidate.id}:${window.windowIndex}`,
+    text: window.text,
+    contentSha256: contentSha256(window.text)
+  })));
+  const vectors = await embedShadowItems(registration, items, db, "chunk");
+  for (const item2 of prepared) {
+    const rows = item2.windows.flatMap((window) => {
+      const vector = vectors.get(`chunk:${item2.candidate.id}:${window.windowIndex}`);
+      return vector ? [
+        {
+          compartmentId: item2.candidate.id,
+          sessionId: item2.candidate.session_id,
+          projectPath: registration.projectIdentity,
+          window,
+          modelId: registration.chunkModelId,
+          vector
+        }
+      ] : [];
+    });
+    if (rows.length === item2.windows.length)
+      replaceCompartmentChunkEmbeddings(db, rows);
+  }
+}
+var dbForShadowQueue = new Map;
+async function runShadowWorker() {
+  const startedAt = Date.now();
+  let processed = 0;
+  let processedBytes = 0;
+  while (shadowQueue.length > 0 && processed < SHADOW_MAX_ITEMS_PER_TICK && Date.now() - startedAt < SHADOW_MAX_WALL_CLOCK_MS) {
+    const item = shadowQueue.shift();
+    if (!item)
+      break;
+    const itemBytes = item.ids.reduce((total, id) => total + id.length, 0);
+    if (processed > 0 && processedBytes + itemBytes > SHADOW_MAX_BYTES_PER_TICK) {
+      shadowQueue.unshift(item);
+      break;
+    }
+    try {
+      await processShadowQueueItem(item);
+    } catch (error51) {
+      log("[magic-context] Synapse shadow write failed:", error51);
+    }
+    processed += item.ids.length;
+    processedBytes += itemBytes;
+    await new Promise((resolve2) => setTimeout(resolve2, 0));
+  }
+}
 function registerProjectInObservationMode(db, projectIdentity, sourceDirectory, failedConfig, failureSummary) {
   const prior = projectRegistrations.get(projectIdentity);
   const runtimeFingerprint = `observation:${sha256Prefix(failureSummary)}`;
@@ -163044,7 +166289,10 @@ function getOrCreateProjectProvider(registration) {
   if (registration.provider) {
     return registration.provider;
   }
-  const provider = createProvider(registration.config);
+  const provider = createProvider(registration.config, {
+    projectRoot: registration.sourceDirectory,
+    session: `project:${registration.projectIdentity}`
+  });
   registration.provider = provider;
   return provider;
 }
@@ -163064,7 +166312,7 @@ async function embedTextForProject(projectIdentity, text, signal, purpose = "pas
   if (!current || current.generation !== generation || current.runtimeFingerprint !== registration.runtimeFingerprint) {
     return null;
   }
-  return { vector, modelId, generation };
+  return { vector, modelId, chunkModelId: registration.chunkModelId, generation };
 }
 async function embedBatchForProject(projectIdentity, texts, signal, purpose = "passage") {
   if (texts.length === 0) {
@@ -163089,31 +166337,81 @@ async function embedBatchForProject(projectIdentity, texts, signal, purpose = "p
   }
   return { vectors, modelId, generation };
 }
-async function embedTextsWindowBounded(projectIdentity, texts, signal) {
-  if (texts.length <= MAX_WINDOWS_PER_EMBED_CALL) {
-    return embedBatchForProject(projectIdentity, texts, signal);
+async function embedItemsForProject(projectIdentity, items, signal, db, sessionId = projectIdentity) {
+  const registration = projectRegistrations.get(projectIdentity);
+  if (!registration || registration.observationMode || items.length === 0)
+    return null;
+  const generation = registration.generation;
+  const modelId = registration.modelId;
+  const runtimeFingerprint = registration.runtimeFingerprint;
+  const provider = getOrCreateProjectProvider(registration);
+  if (!provider)
+    return null;
+  const rawConfig = registration.config;
+  const fingerprint = typeof rawConfig.synapse_fingerprint === "string" ? rawConfig.synapse_fingerprint : "";
+  const tableEpoch = typeof rawConfig.synapse_table_epoch === "number" ? rawConfig.synapse_table_epoch : undefined;
+  const isSynapse = registration.providerIdentity.startsWith("synapse:v1:") && fingerprint && tableEpoch !== undefined;
+  const ledgerKey = isSynapse ? getSynapseBatchRequestKey({
+    model: typeof rawConfig.model === "string" ? rawConfig.model : registration.modelId,
+    fingerprint,
+    tableEpoch,
+    items
+  }) : null;
+  if (db && ledgerKey) {
+    beginSynapseBatchLedger(db, {
+      sessionId,
+      projectPath: projectIdentity,
+      scope: items[0].id.split(":", 1)[0],
+      manifest: items.map(({ id, contentSha256: contentSha2562 }) => ({ id, contentSha256: contentSha2562 })),
+      requestKey: ledgerKey
+    });
   }
-  const vectors = [];
+  let vectors;
+  try {
+    if (provider.embedItems) {
+      vectors = await provider.embedItems(items, signal);
+    } else {
+      const positional = await provider.embedBatch(items.map((item) => item.text), signal, "passage");
+      vectors = new Map(items.flatMap((item, index) => {
+        const vector = positional[index];
+        return vector ? [[item.id, vector]] : [];
+      }));
+    }
+  } catch (error51) {
+    if (db && ledgerKey)
+      finishSynapseBatchLedger(db, sessionId, ledgerKey, "failed");
+    throw error51;
+  }
+  if (db && ledgerKey) {
+    finishSynapseBatchLedger(db, sessionId, ledgerKey, vectors.size === items.length ? "complete" : "partial");
+  }
+  const current = projectRegistrations.get(projectIdentity);
+  if (!current || current.generation !== generation || current.runtimeFingerprint !== runtimeFingerprint) {
+    return null;
+  }
+  return { vectors, modelId, generation };
+}
+async function embedItemsWindowBounded(projectIdentity, items, signal, db) {
+  if (items.length <= MAX_WINDOWS_PER_EMBED_CALL) {
+    return embedItemsForProject(projectIdentity, items, signal, db, projectIdentity);
+  }
+  const vectors = new Map;
   let modelId = null;
   let generation = null;
-  for (let start = 0;start < texts.length; start += MAX_WINDOWS_PER_EMBED_CALL) {
-    if (signal?.aborted)
-      return null;
-    const sub = texts.slice(start, start + MAX_WINDOWS_PER_EMBED_CALL);
-    const result = await embedBatchForProject(projectIdentity, sub, signal);
+  for (let start = 0;start < items.length; start += MAX_WINDOWS_PER_EMBED_CALL) {
+    const result = await embedItemsForProject(projectIdentity, items.slice(start, start + MAX_WINDOWS_PER_EMBED_CALL), signal, db, projectIdentity);
     if (!result)
       return null;
     if (modelId === null) {
       modelId = result.modelId;
       generation = result.generation;
-    } else if (result.modelId !== modelId || result.generation !== generation) {
+    } else if (modelId !== result.modelId || generation !== result.generation) {
       return null;
     }
-    vectors.push(...result.vectors);
+    for (const [id, vector] of result.vectors)
+      vectors.set(id, vector);
   }
-  if (modelId === null || generation === null)
-    return null;
-  return { vectors, modelId, generation };
+  return modelId === null || generation === null ? null : { vectors, modelId, generation };
 }
 function isUnembeddedMemoryRow(row) {
   if (row === null || typeof row !== "object")
@@ -163138,13 +166436,17 @@ async function embedUnembeddedMemoriesForProject(db, projectIdentity, batchSize
   if (memories.length === 0)
     return 0;
   try {
-    const result = await embedBatchForProject(projectIdentity, memories.map((memory) => memory.content));
+    const result = await embedItemsForProject(projectIdentity, memories.map((memory) => ({
+      id: `memory:${memory.id}`,
+      text: memory.content,
+      contentSha256: contentSha256(memory.content)
+    })), undefined, db, projectIdentity);
     if (!result)
       return 0;
     let embeddedCount = 0;
     db.transaction(() => {
-      for (const [index, memory] of memories.entries()) {
-        const embedding = result.vectors[index];
+      for (const memory of memories) {
+        const embedding = result.vectors.get(`memory:${memory.id}`);
         if (!embedding)
           continue;
         if (saveEmbeddingIfHashMatches(db, memory.id, embedding, result.modelId, memory.normalized_hash)) {
@@ -163152,6 +166454,7 @@ async function embedUnembeddedMemoriesForProject(db, projectIdentity, batchSize
         }
       }
     })();
+    enqueueShadowEmbeddingItems(projectIdentity, "memory", memories.filter((memory) => result.vectors.has(`memory:${memory.id}`)).map((memory) => String(memory.id)));
     return embeddedCount;
   } catch (error51) {
     log("[magic-context] failed to proactively embed missing memories:", error51);
@@ -163165,19 +166468,24 @@ async function embedCommitBatch(db, projectIdentity, batchSize) {
   const commits = loadUnembeddedCommits(db, projectIdentity, snapshot.modelId, Math.max(1, Math.floor(batchSize)));
   if (commits.length === 0)
     return 0;
-  const result = await embedBatchForProject(projectIdentity, commits.map((commit) => commit.message));
+  const result = await embedItemsForProject(projectIdentity, commits.map((commit) => ({
+    id: `commit:${commit.sha}`,
+    text: commit.message,
+    contentSha256: contentSha256(commit.message)
+  })), undefined, db, projectIdentity);
   if (!result)
     return 0;
   let embeddedCount = 0;
   db.transaction(() => {
-    for (const [index, commit] of commits.entries()) {
-      const embedding = result.vectors[index];
+    for (const commit of commits) {
+      const embedding = result.vectors.get(`commit:${commit.sha}`);
       if (!embedding)
         continue;
       saveCommitEmbedding(db, commit.sha, embedding, result.modelId);
       embeddedCount += 1;
     }
   })();
+  enqueueShadowEmbeddingItems(projectIdentity, "commit", commits.filter((commit) => result.vectors.has(`commit:${commit.sha}`)).map((commit) => commit.sha));
   return embeddedCount;
 }
 async function drainCommitBacklogForProject(db, projectIdentity, deadline) {
@@ -163250,9 +166558,11 @@ async function embedCandidateChunkBatch(db, projectIdentity, modelId, candidates
       windowCount += item.windows.length;
       i += 1;
     } while (i < prepared.length && windowCount + prepared[i].windows.length <= MAX_WINDOWS_PER_EMBED_CALL);
-    const texts = [];
-    for (const item of slice)
-      texts.push(...item.windows.map((w) => w.text));
+    const items = slice.flatMap((item) => item.windows.map((window) => ({
+      id: `chunk:${item.candidate.id}:${window.windowIndex}`,
+      text: window.text,
+      contentSha256: contentSha256(window.text)
+    })));
     const persistedIds = new Set;
     for (let attempt = 0;attempt < EMBED_SLICE_RETRY_ATTEMPTS; attempt++) {
       if (signal?.aborted)
@@ -163260,19 +166570,17 @@ async function embedCandidateChunkBatch(db, projectIdentity, modelId, candidates
       let result = null;
       const attemptStart = Date.now();
       try {
-        result = await embedTextsWindowBounded(projectIdentity, texts, signal);
+        result = await embedItemsWindowBounded(projectIdentity, items, signal, db);
       } catch (error51) {
         log("[magic-context] failed to proactively embed compartment chunks:", error51);
       }
       if (signal?.aborted)
         break;
       if (result) {
-        let offset = 0;
         for (const item of slice) {
-          const vectors = result.vectors.slice(offset, offset + item.windows.length);
-          offset += item.windows.length;
           if (persistedIds.has(item.candidate.id))
             continue;
+          const vectors = item.windows.map((window) => result.vectors.get(`chunk:${item.candidate.id}:${window.windowIndex}`));
           if (vectors.length !== item.windows.length || vectors.some((v) => !v)) {
             continue;
           }
@@ -163286,6 +166594,9 @@ async function embedCandidateChunkBatch(db, projectIdentity, modelId, candidates
           }));
           replaceCompartmentChunkEmbeddings(db, rows);
           persistedIds.add(item.candidate.id);
+          enqueueShadowEmbeddingItems(projectIdentity, "chunk", [
+            String(item.candidate.id)
+          ]);
         }
       }
       if (persistedIds.size === slice.length)
@@ -163454,7 +166765,24 @@ function createProvider2(config2) {
       maxInputTokens: config2.max_input_tokens
     });
   }
-  return new LocalEmbeddingProvider(config2.model, config2.max_input_tokens);
+  if (config2.provider === "local") {
+    return new LocalEmbeddingProvider(config2.model, config2.max_input_tokens);
+  }
+  if (config2.provider === "synapse") {
+    const synapse = config2;
+    return new SynapseEmbeddingProvider({
+      connectionFile: synapse.synapse_connection_file ?? "",
+      projectRoot: "",
+      session: "embedding",
+      model: synapse.model,
+      fingerprint: synapse.synapse_fingerprint,
+      tableEpoch: synapse.synapse_table_epoch,
+      dims: synapse.synapse_dims,
+      recommendedBatch: synapse.synapse_recommended_batch,
+      provenance: synapse.synapse_provenance
+    });
+  }
+  throw new Error("Unknown embedding provider");
 }
 function getOrCreateProvider() {
   if (provider) {
@@ -163479,7 +166807,7 @@ async function embedText(text, signal) {
 var SWEEP_MAX_WALL_CLOCK_MS2 = 10 * 60 * 1000;
 
 // ../plugin/src/plugin/embedding-bootstrap-helpers.ts
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 init_logger();
 var EMBEDDING_AFFECTING_KEYS = new Set([
   "embedding.api_key",
@@ -163489,7 +166817,11 @@ var EMBEDDING_AFFECTING_KEYS = new Set([
   "embedding.input_type",
   "embedding.truncate",
   "embedding.max_input_tokens",
-  "embedding.query_input_type"
+  "embedding.query_input_type",
+  "embedding.fallback_provider",
+  "subc",
+  "subc.connection_file",
+  "shadow_embedding"
 ]);
 var LITERAL_CONFIG_TOKEN_RE = /\{(?:env|file):[^}]+\}/;
 function embeddingConfigHasLiteralTokens(embedding) {
@@ -163502,7 +166834,13 @@ function embeddingConfigHasLiteralTokens(embedding) {
   }
   return false;
 }
-var EMBEDDING_AFFECTING_TOP_LEVEL_KEYS = new Set(["embedding", "memory", "experimental"]);
+var EMBEDDING_AFFECTING_TOP_LEVEL_KEYS = new Set([
+  "embedding",
+  "memory",
+  "experimental",
+  "subc",
+  "shadow_embedding"
+]);
 var EMBEDDING_WARNING_TERMS = [
   "api_key",
   "endpoint",
@@ -163510,11 +166848,13 @@ var EMBEDDING_WARNING_TERMS = [
   "provider",
   "embedding",
   "input_type",
-  "truncate"
+  "truncate",
+  "subc",
+  "shadow_embedding"
 ];
 var loggedFailureSignatures = new Map;
 function sha256Prefix2(value, length = 16) {
-  return createHash6("sha256").update(value).digest("hex").slice(0, length);
+  return createHash8("sha256").update(value).digest("hex").slice(0, length);
 }
 function warningLooksEmbeddingRelated(message) {
   const lower = message.toLowerCase();
@@ -163689,7 +167029,7 @@ function clearCompressionDepthRange(db, sessionId, startOrdinal, endOrdinal) {
 }
 
 // ../plugin/src/features/magic-context/storage-meta-shared.ts
-import { Buffer as Buffer2 } from "node:buffer";
+import { Buffer as Buffer3 } from "node:buffer";
 var SESSION_META_SELECT_COLUMNS = [
   "session_id",
   "last_response_time",
@@ -163822,14 +167162,14 @@ function isNumberOrNull(value) {
   return value === null || typeof value === "number";
 }
 function isBlobOrNull(value) {
-  return value === null || Buffer2.isBuffer(value) || value instanceof Uint8Array;
+  return value === null || Buffer3.isBuffer(value) || value instanceof Uint8Array;
 }
 function toBufferOrNull(value) {
   if (value === null)
     return null;
-  if (Buffer2.isBuffer(value))
+  if (Buffer3.isBuffer(value))
     return value;
-  return Buffer2.from(value.buffer, value.byteOffset, value.byteLength);
+  return Buffer3.from(value.buffer, value.byteOffset, value.byteLength);
 }
 function isSessionMetaRow(row) {
   if (row === null || typeof row !== "object")
@@ -163974,7 +167314,7 @@ function persistCachedM0(db, sessionId, payload) {
             cached_m0_system_hash = ?,
             cached_m0_model_key = ?,
             cached_m0_project_identity = ?
-         WHERE session_id = ?`).run(Buffer2.from(payload.m0Bytes), payload.projectMemoryEpoch, payload.workspaceFingerprint ?? null, payload.projectUserProfileVersion, payload.maxCompartmentSeq, payload.maxMemoryId, payload.maxMutationId, payload.maxMemoryMutationId ?? null, payload.m1Bytes ? Buffer2.from(payload.m1Bytes) : null, payload.projectDocsHash, payload.materializedAt, payload.sessionFactsVersion, payload.upgradeState, payload.systemHash ?? "", payload.modelKey ?? "", payload.projectIdentity ?? null, sessionId);
+         WHERE session_id = ?`).run(Buffer3.from(payload.m0Bytes), payload.projectMemoryEpoch, payload.workspaceFingerprint ?? null, payload.projectUserProfileVersion, payload.maxCompartmentSeq, payload.maxMemoryId, payload.maxMutationId, payload.maxMemoryMutationId ?? null, payload.m1Bytes ? Buffer3.from(payload.m1Bytes) : null, payload.projectDocsHash, payload.materializedAt, payload.sessionFactsVersion, payload.upgradeState, payload.systemHash ?? "", payload.modelKey ?? "", payload.projectIdentity ?? null, sessionId);
 }
 function clearCachedM0M1(db, sessionId) {
   ensureSessionMetaRow(db, sessionId);
@@ -171029,7 +174369,7 @@ function indexMessagesAfterOrdinal(db, sessionId, messages, _lastIndexedOrdinal,
   return inserted;
 }
 // ../plugin/src/features/magic-context/project-docs-hash.ts
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash9 } from "node:crypto";
 import { lstatSync, readFileSync as readFileSync5, statSync as statSync5 } from "node:fs";
 import path5 from "node:path";
 var PROJECT_DOC_FILES = ["ARCHITECTURE.md", "STRUCTURE.md"];
@@ -171127,7 +174467,7 @@ function hashCanonicalPieces(hashPieces) {
   if (hashPieces.length === 0) {
     return "";
   }
-  return createHash7("sha256").update(hashPieces.join(PROJECT_DOCS_DELIMITER), "utf8").digest("hex");
+  return createHash9("sha256").update(hashPieces.join(PROJECT_DOCS_DELIMITER), "utf8").digest("hex");
 }
 function readProjectDocsCanonical(projectDirectory) {
   const canonicalDirectory = path5.resolve(projectDirectory);
@@ -171172,14 +174512,19 @@ function countRows(db, table, sessionId) {
   const row = db.prepare(`SELECT COUNT(*) AS count FROM ${table} WHERE session_id = ?`).get(sessionId);
   return typeof row?.count === "number" ? row.count : 0;
 }
-function filterIdBlob(raw, includeMessageId) {
+function mapMessageId(filter, messageId) {
+  if (messageId === null)
+    return null;
+  return filter.mapMessageId?.(messageId) ?? messageId;
+}
+function filterIdBlob(raw, filter) {
   if (!raw)
     return "";
   try {
     const value = JSON.parse(raw);
     if (!Array.isArray(value))
       return "";
-    const filtered = value.filter((id) => typeof id === "string" && includeMessageId(id));
+    const filtered = value.filter((id) => typeof id === "string" && filter.includeMessageId(id)).map((id) => mapMessageId(filter, id));
     return filtered.length > 0 ? JSON.stringify(filtered) : "";
   } catch {
     return "";
@@ -171216,16 +174561,16 @@ function copySessionStateForClone(db, sourceSessionId, destinationSessionId, fil
       const endMessage = filter.resolveBoundaryOrdinal(row.end_message_id);
       if (startMessage === undefined || endMessage === undefined)
         continue;
-      insertCompartment.run(destinationSessionId, row.sequence, startMessage, endMessage, row.start_message_id, row.end_message_id, row.title, row.content, row.p1, row.p2, row.p3, row.p4, row.importance, row.episode_type, row.legacy, row.created_at, row.harness);
+      insertCompartment.run(destinationSessionId, row.sequence, startMessage, endMessage, mapMessageId(filter, row.start_message_id), mapMessageId(filter, row.end_message_id), row.title, row.content, row.p1, row.p2, row.p3, row.p4, row.importance, row.episode_type, row.legacy, row.created_at, row.harness);
       copiedCompartments.push({
         sequence: row.sequence,
         startMessage,
         endMessage,
-        startMessageId: row.start_message_id,
-        endMessageId: row.end_message_id
+        startMessageId: mapMessageId(filter, row.start_message_id) ?? row.start_message_id,
+        endMessageId: mapMessageId(filter, row.end_message_id) ?? row.end_message_id
       });
     }
-    const sourceTags = db.prepare(`SELECT message_id, type, status, byte_size, tag_number, harness,
+    const sourceTags = db.prepare(`SELECT id, message_id, type, status, byte_size, tag_number, harness,
                         entry_fingerprint, token_count, input_token_count,
                         reasoning_token_count, reasoning_byte_size, drop_mode, tool_name,
                         input_byte_size, caveman_depth, tool_owner_message_id
@@ -171237,6 +174582,7 @@ function copySessionStateForClone(db, sourceSessionId, destinationSessionId, fil
                  caveman_depth, tool_owner_message_id)
              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
     const copiedTagNumbers = [];
+    const copiedTagIds = new Map;
     for (const row of sourceTags) {
       if (!filter.includeTag({
         messageId: row.message_id,
@@ -171246,19 +174592,39 @@ function copySessionStateForClone(db, sourceSessionId, destinationSessionId, fil
       })) {
         continue;
       }
-      insertTag.run(destinationSessionId, row.message_id, row.type, row.status, row.byte_size, row.tag_number, row.harness, row.entry_fingerprint, row.token_count, row.input_token_count, row.reasoning_token_count, row.reasoning_byte_size, row.drop_mode, row.tool_name, row.input_byte_size, row.caveman_depth, row.tool_owner_message_id);
+      const insertResult = insertTag.run(destinationSessionId, mapMessageId(filter, row.message_id), row.type, row.status, row.byte_size, row.tag_number, row.harness, row.entry_fingerprint, row.token_count, row.input_token_count, row.reasoning_token_count, row.reasoning_byte_size, row.drop_mode, row.tool_name, row.input_byte_size, row.caveman_depth, mapMessageId(filter, row.tool_owner_message_id));
+      const insertedTagId = Number(insertResult.lastInsertRowid);
+      if (!Number.isSafeInteger(insertedTagId) || insertedTagId <= 0) {
+        throw new Error(`failed to obtain destination tag id for tag ${row.tag_number}`);
+      }
+      const sourceTagId = filter.mapTagId ? row.id : row.tag_number;
+      const destinationTagId = filter.mapTagId ? filter.mapTagId(sourceTagId, insertedTagId) : sourceTagId;
+      copiedTagIds.set(sourceTagId, destinationTagId);
       copiedTagNumbers.push(row.tag_number);
     }
     if (copiedTagNumbers.length > 0) {
-      const placeholders3 = copiedTagNumbers.map(() => "?").join(", ");
-      db.prepare(`INSERT INTO source_contents (tag_id, session_id, content, created_at, harness)
-                 SELECT tag_id, ?, content, created_at, harness
-                   FROM source_contents
-                  WHERE session_id = ? AND tag_id IN (${placeholders3})`).run(destinationSessionId, sourceSessionId, ...copiedTagNumbers);
-      db.prepare(`INSERT INTO pending_ops (session_id, tag_id, operation, queued_at, harness)
-                 SELECT ?, tag_id, operation, queued_at, harness
-                   FROM pending_ops
-                  WHERE session_id = ? AND tag_id IN (${placeholders3})`).run(destinationSessionId, sourceSessionId, ...copiedTagNumbers);
+      const sourceTagIds = [...copiedTagIds.keys()];
+      const placeholders3 = sourceTagIds.map(() => "?").join(", ");
+      const sourceContents = db.prepare(`SELECT tag_id, content, created_at, harness
+                       FROM source_contents
+                      WHERE session_id = ? AND tag_id IN (${placeholders3})`).all(sourceSessionId, ...sourceTagIds);
+      const insertSourceContent = db.prepare("INSERT INTO source_contents (tag_id, session_id, content, created_at, harness) VALUES (?, ?, ?, ?, ?)");
+      for (const row of sourceContents) {
+        const destinationTagId = copiedTagIds.get(row.tag_id);
+        if (destinationTagId === undefined)
+          continue;
+        insertSourceContent.run(destinationTagId, destinationSessionId, row.content, row.created_at, row.harness);
+      }
+      const pendingOps = db.prepare(`SELECT tag_id, operation, queued_at, harness
+                       FROM pending_ops
+                      WHERE session_id = ? AND tag_id IN (${placeholders3})`).all(sourceSessionId, ...sourceTagIds);
+      const insertPendingOp = db.prepare("INSERT INTO pending_ops (session_id, tag_id, operation, queued_at, harness) VALUES (?, ?, ?, ?, ?)");
+      for (const row of pendingOps) {
+        const destinationTagId = copiedTagIds.get(row.tag_id);
+        if (destinationTagId === undefined)
+          continue;
+        insertPendingOp.run(destinationSessionId, destinationTagId, row.operation, row.queued_at, row.harness);
+      }
     }
     const meta3 = db.prepare(`SELECT cleared_reasoning_through_tag, tool_reclaim_watermark,
                         pi_stable_id_scheme, stripped_placeholder_ids,
@@ -171294,7 +174660,7 @@ function copySessionStateForClone(db, sourceSessionId, destinationSessionId, fil
                 todo_synthetic_anchor_message_id = excluded.todo_synthetic_anchor_message_id,
                 todo_synthetic_state_json = excluded.todo_synthetic_state_json,
                 cached_m0_bytes = NULL,
-                cached_m1_bytes = NULL`).run(destinationSessionId, getHarness(), maxCopiedTag, clampWatermark(meta3?.cleared_reasoning_through_tag ?? null, maxCopiedTag), clampWatermark(meta3?.tool_reclaim_watermark ?? null, maxCopiedTag), typeof meta3?.pi_stable_id_scheme === "number" && Number.isFinite(meta3.pi_stable_id_scheme) ? meta3.pi_stable_id_scheme : null, filterIdBlob(meta3?.stripped_placeholder_ids ?? null, filter.includeMessageId), filterIdBlob(meta3?.stale_reduce_stripped_ids ?? null, filter.includeMessageId), filterIdBlob(meta3?.processed_image_stripped_ids ?? null, filter.includeMessageId), pendingMarker, migrateTodo ? meta3?.last_todo_state ?? "" : "", migrateTodo ? meta3?.todo_synthetic_call_id ?? "" : "", migrateTodo ? todoAnchor : "", migrateTodo ? meta3?.todo_synthetic_state_json ?? "" : "");
+                cached_m1_bytes = NULL`).run(destinationSessionId, getHarness(), maxCopiedTag, clampWatermark(meta3?.cleared_reasoning_through_tag ?? null, maxCopiedTag), clampWatermark(meta3?.tool_reclaim_watermark ?? null, maxCopiedTag), typeof meta3?.pi_stable_id_scheme === "number" && Number.isFinite(meta3.pi_stable_id_scheme) ? meta3.pi_stable_id_scheme : null, filterIdBlob(meta3?.stripped_placeholder_ids ?? null, filter), filterIdBlob(meta3?.stale_reduce_stripped_ids ?? null, filter), filterIdBlob(meta3?.processed_image_stripped_ids ?? null, filter), pendingMarker, migrateTodo ? meta3?.last_todo_state ?? "" : "", migrateTodo ? meta3?.todo_synthetic_call_id ?? "" : "", migrateTodo ? mapMessageId(filter, todoAnchor) ?? "" : "", migrateTodo ? meta3?.todo_synthetic_state_json ?? "" : "");
     const pendingOpsRow = db.prepare("SELECT COUNT(*) AS count FROM pending_ops WHERE session_id = ?").get(destinationSessionId);
     return {
       kind: "migrated",
@@ -171464,6 +174830,7 @@ function getMaxMemoryMutationIdForProjects(db, projectPaths) {
 }
 // ../plugin/src/features/magic-context/storage-meta-persisted.ts
 init_logger();
+var emergencyRecoveryArmedSessions = new Set;
 var CAS_RETRY_LIMIT = 5;
 var AUTO_SEARCH_NO_HINT_REASONS = new Set([
   "below-threshold",
@@ -172185,6 +175552,7 @@ function getOverflowState(db, sessionId, modelKey) {
   };
 }
 function recordOverflowDetected(db, sessionId, reportedLimit, modelKey, origin = "provider_overflow") {
+  emergencyRecoveryArmedSessions.add(sessionId);
   db.transaction(() => {
     ensureSessionMetaRow(db, sessionId);
     if (typeof reportedLimit === "number" && reportedLimit > 0) {
@@ -172203,6 +175571,7 @@ function clearEmergencyRecovery(db, sessionId) {
       db.prepare("UPDATE session_meta SET needs_emergency_recovery = 0, emergency_recovery_origin = '' WHERE session_id = ?").run(sessionId);
     }
   })();
+  emergencyRecoveryArmedSessions.delete(sessionId);
 }
 function clearDetectedContextLimit(db, sessionId) {
   db.transaction(() => {
@@ -172402,7 +175771,7 @@ function getSessionWorkMetrics(db, sessionId) {
   };
 }
 // ../plugin/src/features/magic-context/storage-meta-session.ts
-import { Buffer as Buffer3 } from "node:buffer";
+import { Buffer as Buffer4 } from "node:buffer";
 
 // ../plugin/src/features/magic-context/resolve-subagent-fallback.ts
 init_logger();
@@ -172489,7 +175858,7 @@ function updateSessionMeta(db, sessionId, updates) {
       values.push(NULL_BIND_META_KEYS.has(key) ? null : "");
     } else if ((key === "cachedM0Bytes" || key === "cachedM1Bytes") && value instanceof Uint8Array) {
       setClauses.push(`${column} = ?`);
-      values.push(Buffer3.from(value.buffer, value.byteOffset, value.byteLength));
+      values.push(Buffer4.from(value.buffer, value.byteOffset, value.byteLength));
     } else if (BOOLEAN_META_KEYS.has(key)) {
       setClauses.push(`${column} = ?`);
       values.push(value ? 1 : 0);
@@ -174743,18 +178112,23 @@ async function embedUnembeddedCommits(db, projectPath) {
         break;
       let embeddedThisBatch = 0;
       try {
-        const result = await embedBatchForProject(projectPath, rows.map((row) => row.message));
+        const result = await embedItemsForProject(projectPath, rows.map((row) => ({
+          id: `commit:${row.sha}`,
+          text: row.message,
+          contentSha256: contentSha256(row.message)
+        })), undefined, db, projectPath);
         if (!result)
           break;
         db.transaction(() => {
-          for (const [index, row] of rows.entries()) {
-            const embedding2 = result.vectors[index];
+          for (const row of rows) {
+            const embedding2 = result.vectors.get(`commit:${row.sha}`);
             if (!embedding2)
               continue;
             saveCommitEmbedding(db, row.sha, embedding2, result.modelId);
             embeddedThisBatch += 1;
           }
         })();
+        enqueueShadowEmbeddingItems(projectPath, "commit", rows.filter((row) => result.vectors.has(`commit:${row.sha}`)).map((row) => row.sha));
       } catch (error51) {
         log(`[git-commits] embed batch failed for ${projectPath}: ${error51 instanceof Error ? error51.message : String(error51)}`);
         break;
@@ -174962,6 +178336,93 @@ function containsProbeVerbatim(text, probes) {
   return probes.some((probe) => haystack.includes(probe.toLowerCase()));
 }
 
+// ../plugin/src/features/magic-context/search-measurement.ts
+import { createHash as createHash10 } from "node:crypto";
+function resultId(result) {
+  switch (result.source) {
+    case "memory":
+      return `memory:${result.memoryId}`;
+    case "message":
+      return `message:${result.messageId}`;
+    case "compartment":
+      return `chunk:${result.compartmentId}`;
+    case "git_commit":
+      return `commit:${result.sha}`;
+    case "primer":
+      return `primer:${result.primerId}`;
+    case "note":
+      return `note:${result.noteId}`;
+  }
+}
+async function recordShadowMeasurement(args) {
+  const shadowCohort = getShadowEmbeddingMeasurementCohort(args.projectPath);
+  if (!shadowCohort)
+    return;
+  const primaryCohort = getPrimaryEmbeddingMeasurementCohort(args.projectPath);
+  const shadowStartedAt = Date.now();
+  let shadowFailed = false;
+  let shadowResults = [];
+  try {
+    const vector = await embedShadowTextForProject(args.projectPath, args.query);
+    if (!vector) {
+      shadowFailed = true;
+    } else {
+      shadowResults = await args.search(args.db, args.sessionId, args.projectPath, args.query, {
+        ...args.options,
+        embedQuery: async () => vector,
+        isEmbeddingRuntimeEnabled: () => true,
+        embeddingEnabled: true,
+        embeddingModelIdOverride: shadowCohort.modelId,
+        chunkModelIdOverride: shadowCohort.chunkModelId,
+        measurementDisabled: true,
+        countRetrievals: false
+      });
+    }
+  } catch {
+    shadowFailed = true;
+  }
+  const primaryModelId = args.primaryQuery?.modelId ?? primaryCohort?.modelId ?? "";
+  const primaryFingerprint = primaryCohort?.fingerprint ?? "";
+  const primaryEpoch = primaryCohort?.epoch ?? 0;
+  const cohortKey = JSON.stringify({
+    primaryFingerprint,
+    primaryEpoch,
+    shadowFingerprint: shadowCohort.fingerprint,
+    shadowEpoch: shadowCohort.epoch
+  });
+  const primaryIds = args.primaryResults.map(resultId);
+  const shadowIds = shadowResults.map(resultId);
+  const corpusHash = sha2562(JSON.stringify({ query: args.query, primaryIds, shadowIds }));
+  recordEmbeddingMeasurement(args.db, {
+    sessionId: args.sessionId,
+    projectPath: args.projectPath,
+    queryText: args.query,
+    cohortKey,
+    primaryResultIds: primaryIds,
+    shadowResultIds: shadowIds,
+    primaryLatencyMs: args.primaryLatencyMs,
+    shadowLatencyMs: Date.now() - shadowStartedAt,
+    primaryFailed: args.primaryQuery === null,
+    shadowFailed,
+    primaryModelId,
+    shadowModelId: shadowCohort.modelId,
+    primaryFingerprint,
+    shadowFingerprint: shadowCohort.fingerprint,
+    primaryEpoch,
+    shadowEpoch: shadowCohort.epoch,
+    corpusHash,
+    coverage: {
+      primaryResultCount: primaryIds.length,
+      shadowResultCount: shadowIds.length,
+      primaryAnswered: args.primaryQuery !== null,
+      shadowAnswered: !shadowFailed
+    }
+  });
+}
+function sha2562(value) {
+  return createHash10("sha256").update(value).digest("hex");
+}
+
 // ../plugin/src/features/magic-context/search.ts
 var DEFAULT_UNIFIED_SEARCH_LIMIT = 10;
 var FTS_SEMANTIC_CANDIDATE_LIMIT = 50;
@@ -175719,6 +179180,7 @@ function resolveSources(sources) {
 }
 async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
   const trimmedQuery = query.trim();
+  const measurementStartedAt = Date.now();
   if (trimmedQuery.length === 0) {
     return [];
   }
@@ -175751,11 +179213,14 @@ async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
     maxOrdinal: options.maxMessageOrdinal,
     probes: messageProbes
   }) : [];
-  const queryEmbedding = await queryEmbeddingPromise;
-  const workspace = resolveSearchWorkspaceContext(db, projectPath);
+  const capturedQuery = await queryEmbeddingPromise;
   const embeddingSnapshot = getProjectEmbeddingSnapshot(projectPath);
-  const embeddingModelId = embeddingSnapshot?.modelId;
-  const chunkModelId = embeddingSnapshot?.chunkModelId;
+  const queryContract = capturedQuery instanceof Float32Array || capturedQuery === null ? null : capturedQuery;
+  const generationIsCurrent = queryContract === null || embeddingSnapshot !== null && embeddingSnapshot.generation === queryContract.generation;
+  const queryEmbedding = generationIsCurrent ? queryContract?.vector ?? (capturedQuery instanceof Float32Array ? capturedQuery : null) : null;
+  const workspace = resolveSearchWorkspaceContext(db, projectPath);
+  const embeddingModelId = queryContract?.modelId ?? options.embeddingModelIdOverride ?? embeddingSnapshot?.modelId;
+  const chunkModelId = queryContract?.chunkModelId ?? options.chunkModelIdOverride ?? embeddingSnapshot?.chunkModelId;
   const compartmentResults = runCompartmentChunks ? searchCompartmentChunks({
     db,
     sessionId,
@@ -175814,6 +179279,19 @@ async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
     ...gitCommitResults,
     ...noteResults
   ].sort(compareUnifiedResults).slice(0, limit);
+  if (!options.measurementDisabled) {
+    recordShadowMeasurement({
+      db,
+      sessionId,
+      projectPath,
+      query: trimmedQuery,
+      options,
+      primaryResults: results,
+      primaryQuery: queryContract,
+      primaryLatencyMs: Date.now() - measurementStartedAt,
+      search: unifiedSearch
+    });
+  }
   const countRetrievals = options.countRetrievals ?? true;
   if (countRetrievals) {
     const memoryIds = results.filter((result) => result.source === "memory").map((result) => result.memoryId);
@@ -176579,7 +180057,7 @@ import {
 } from "@earendil-works/pi-tui";
 
 // ../plugin/src/hooks/magic-context/todo-view.ts
-import { createHash as createHash8 } from "node:crypto";
+import { createHash as createHash11 } from "node:crypto";
 var TODO_STATUS_PENDING = "pending";
 var TODO_STATUS_IN_PROGRESS = "in_progress";
 var TODO_STATUS_COMPLETED = "completed";
@@ -176647,7 +180125,7 @@ function buildSyntheticTodoPart(stateJson) {
   };
 }
 function computeSyntheticCallId(stateJson) {
-  const hash2 = createHash8("sha256").update(stateJson).digest("hex").slice(0, 16);
+  const hash2 = createHash11("sha256").update(stateJson).digest("hex").slice(0, 16);
   return `${SYNTHETIC_CALL_ID_PREFIX}${hash2}`;
 }
 function parseTodoState(stateJson) {