@cortexkit/opencode-magic-context 0.46.0 → 0.47.0

package/dist/index.js

@@ -21,7 +21,7 @@ import {
   record,
   DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE,
   DEFAULT_HISTORIAN_TIMEOUT_MS
-} from "./index-yasgb8ej.js";
+} from "./index-m5fe6jch.js";
 import {
   denyTaskRoutingToCallerAgents,
   buildHiddenAgentRegistrations,
@@ -40,9 +40,6 @@ import {
   dreamerRunConfig,
   pluginConfigReader,
   createDreamerOutputCapSampler,
-  observeSessionActivity,
-  backfillSessionActivity,
-  recordSessionProjectIdentity,
   COMPARTMENT_AGENT_SYSTEM_PROMPT,
   HISTORIAN_EDITOR_SYSTEM_PROMPT,
   COMPARTMENT_STRUCTURAL_SYSTEM_PROMPT,
@@ -52,7 +49,6 @@ import {
   invalidateAutoEmbedSession,
   getEmbedDrainUiStatus,
   clearEmbedSessionState,
-  deleteIndexedMessage,
   getProtectionWindowForSession,
   getPersistedReasoningWatermark,
   setPersistedReasoningWatermark,
@@ -68,7 +64,6 @@ import {
   clearDetectedContextLimit,
   getPersistedCompactionMarkerState,
   removeStrippedPlaceholderId,
-  armThinkingBindingRecovery,
   getPendingCompactionMarkerState,
   clearPendingCompactionMarkerStateIf,
   getSessionsWithPendingMarker,
@@ -86,14 +81,11 @@ import {
   recordPromptSessionError,
   createPromptSurfaceRuntime,
   setKeepSubagents,
-  getProjectEmbeddingSnapshot,
-  getEmbeddingCoverageStatus,
-  getAutoEmbeddingSessionCoverage,
   removeCompactionMarkerForSession,
   checkCompactionMarkerConsistency,
   clearInjectionCache,
   clearNoteNudgeTriggerOnly
-} from "./index-p821bjdb.js";
+} from "./index-6d9e1m08.js";
 import"./index-sd3egckz.js";
 import {
   reloadWindowOverlay,
@@ -104,8 +96,8 @@ import {
   deriveHistorianChunkTokens2,
   resolveKnownHistorianContextLimit2,
   resolveHistorianContextLimit2
-} from "./index-0d3g3461.js";
-import"./index-q4yp4b52.js";
+} from "./index-0c82743p.js";
+import"./index-rrbbspwh.js";
 import {
   resolveOpenCodeDbPath,
   openCodeDbPathExists,
@@ -113,7 +105,7 @@ import {
   claimOpenCodeDbDiagnosticOnce,
   closeQuietly
 } from "./index-b35pxds2.js";
-import"./index-fg34g6a5.js";
+import"./index-wx8a6bw3.js";
 import {
   createSubcCheckoutClaimGate,
   openCodeEventSessionId,
@@ -131,6 +123,8 @@ import {
   createDbLkgPersistence,
   startDreamScheduleTimer,
   ensureProjectRegisteredFromOpenCodeDirectory,
+  recordOpenCodeProvenInputFloor,
+  resolveOpenCodeProvenInputFloor,
   resolveContextWindowGeometry,
   resolveContextLimit,
   resolveExecuteThresholdDetail,
@@ -161,6 +155,8 @@ import {
   clearTransformDecisionSession,
   scheduleOpenCodeTransformDecisionWrite,
   maybeDeliverChannel2,
+  armLatestThinkingRecovery,
+  armBindingRecoverySafely,
   clearMessageTokensCache,
   createTransform,
   createSubcModuleClient,
@@ -180,22 +176,13 @@ import {
   createCtxSearchTools,
   parameterDescriptionsFor,
   MagicContextRpcServer
-} from "./index-qr6r7akd.js";
+} from "./index-w2t4ah5j.js";
 import {
   formatFailClosedBlockingMessage,
   createFailClosedController,
   recordHookInitFailure,
   clearHookInitFailure,
   getLastHookInitFailure,
-  setHomeProjectPermission,
-  ProjectIdentityError,
-  resolveProjectIdentityStrict,
-  takeDubiousOwnershipProjectIdentityWarning,
-  resolveProjectIdentity,
-  resolveProjectIdentityForSession,
-  beginBootQuietPeriod,
-  bootQuietRemainingMs,
-  scheduleAfterBootQuiet,
   startBootDeadline,
   getSchemaFenceRejection,
   setSqlitePragmaConfig,
@@ -204,7 +191,27 @@ import {
   openDatabaseAsync,
   isDatabasePersisted,
   getDatabasePersistenceError
-} from "./index-r5hmbx3t.js";
+} from "./index-rrrsepyw.js";
+import {
+  setHomeProjectPermission,
+  ProjectIdentityError,
+  resolveProjectIdentityStrict,
+  takeDubiousOwnershipProjectIdentityWarning,
+  resolveProjectIdentity,
+  resolveProjectIdentityForSession,
+  beginBootQuietPeriod,
+  bootQuietRemainingMs,
+  scheduleAfterBootQuiet
+} from "./index-x3kwrmqk.js";
+import {
+  observeSessionActivity,
+  backfillSessionActivity,
+  recordSessionProjectIdentity,
+  deleteIndexedMessage,
+  getProjectEmbeddingSnapshot,
+  getEmbeddingCoverageStatus,
+  getAutoEmbeddingSessionCoverage
+} from "./index-fnn5pjtt.js";
 import {
   deleteTemporalDecision,
   getCurrentToolSetHash,
@@ -221,21 +228,25 @@ import {
   recordToolParameters,
   createDroppedInputToolExecuteBeforeHook,
   detectThinkingBindingMismatch,
+  detectLatestTurnThinkingMismatch,
   isPrefixBoundThinkingModel,
   detectOverflow,
+  isAnthropicFamilyRoute,
   readRawSessionMessages2
-} from "./index-3h0ybwah.js";
+} from "./index-bb36vgr3.js";
 import {
-  isEmbeddingHostBusy,
-  sendCommandResult2,
-  sendStatusNotification2
-} from "./index-7qw742ev.js";
+  isEmbeddingHostBusy
+} from "./index-yr3zj7e7.js";
 import"./index-fzbvakh0.js";
 import {
   observeOpenCodeTurnEvent,
   clearTrackedOpenCodeSession,
   findLastAssistantModelFromOpenCodeDb
-} from "./index-majxda46.js";
+} from "./index-6wkcswft.js";
+import {
+  sendCommandResult2,
+  sendStatusNotification2
+} from "./index-adwfkpex.js";
 import {
   detectConflicts,
   resolveCompactionForBoot
@@ -243,7 +254,7 @@ import {
 import {
   sendConflictWarning2,
   cleanupConflictWarnings2
-} from "./index-sfnj6h8h.js";
+} from "./index-9pk9exrb.js";
 import"./index-1zx87sdm.js";
 import {
   resolveHistorianModel2,
@@ -257,16 +268,17 @@ import {
 import {
   pushNotification2
 } from "./index-x8a7jmkh.js";
+import"./index-92bp57hg.js";
 import {
   createTagger,
   cavemanWordRulesForLanguage,
   setCtxReduceRegisteredGlobally,
   clearToolPermissionDenied,
   resetDegradedCacheCount2
-} from "./index-k4404na5.js";
+} from "./index-cwf6s3ay.js";
 import {
   runManagedRecomp2
-} from "./index-j7fvnjye.js";
+} from "./index-gg8j07zz.js";
 import {
   isValidSemver,
   compareSemverCore
@@ -274,7 +286,7 @@ import {
 import"./index-fmsr7v69.js";
 import {
   runManagedWrapup2
-} from "./index-e2dtv0ra.js";
+} from "./index-5a2r0p9f.js";
 import {
   __toESM,
   __commonJS
@@ -9398,14 +9410,6 @@ function captureWindowReport(input) {
 }
 
 // src/hooks/magic-context/context-limit-resolution.ts
-function provenFloorForModel(storedFloor, storedModelKey, modelKey) {
-  if (typeof storedFloor !== "number" || !Number.isFinite(storedFloor) || storedFloor <= 0) {
-    return 0;
-  }
-  if (!storedModelKey || !modelKey)
-    return 0;
-  return piModelRefToCanonical(storedModelKey) === piModelRefToCanonical(modelKey) ? storedFloor : 0;
-}
 function describeContextLimitChange(previous, next) {
   if (previous.limit === next.limit && previous.modelKey === next.modelKey)
     return null;
@@ -9540,11 +9544,20 @@ function createEventHandler2(deps) {
       }
       recordPromptSessionError(errInfo.sessionID, errInfo.error);
       try {
+        if (detectLatestTurnThinkingMismatch(errInfo.error)) {
+          const model = findLastAssistantModelFromOpenCodeDb(errInfo.sessionID);
+          if (!deps.compactionOff && isAnthropicFamilyRoute(model?.providerID, model?.modelID)) {
+            armLatestThinkingRecovery(deps.db, errInfo.sessionID);
+            dropSlot(errInfo.sessionID, "latest-thinking-recovery-arm");
+            deps.onSessionCacheInvalidated?.(errInfo.sessionID);
+          }
+          return;
+        }
         const bindingMismatch = detectThinkingBindingMismatch(errInfo.error);
         if (bindingMismatch.isBindingMismatch) {
           const model = findLastAssistantModelFromOpenCodeDb(errInfo.sessionID);
           if (deps.thinkingBindingRecoveryEnabled !== false && !deps.compactionOff && isPrefixBoundThinkingModel(model?.providerID, model?.modelID)) {
-            armThinkingBindingRecovery(deps.db, errInfo.sessionID);
+            armBindingRecoverySafely(deps.db, errInfo.sessionID);
             sessionLog(errInfo.sessionID, `thinking binding recovery armed from session.error (provider paths: failing=${bindingMismatch.failingBlockPath ?? "?"} firstChanged=${bindingMismatch.firstChangedPath ?? "?"})`);
             dropSlot(errInfo.sessionID, "thinking-binding-recovery-arm");
             deps.onSessionCacheInvalidated?.(errInfo.sessionID);
@@ -9651,10 +9664,16 @@ function createEventHandler2(deps) {
       }
       let messageHadOverflowError = false;
       if (info.error !== undefined && info.error !== null) {
+        if (detectLatestTurnThinkingMismatch(info.error) && !deps.compactionOff && isAnthropicFamilyRoute(info.providerID, info.modelID)) {
+          armLatestThinkingRecovery(deps.db, info.sessionID);
+          dropSlot(info.sessionID, "latest-thinking-recovery-arm");
+          deps.onSessionCacheInvalidated?.(info.sessionID);
+          return;
+        }
         const bindingMismatch = detectThinkingBindingMismatch(info.error);
         if (bindingMismatch.isBindingMismatch && deps.thinkingBindingRecoveryEnabled !== false && !deps.compactionOff && isPrefixBoundThinkingModel(info.providerID, info.modelID)) {
           try {
-            armThinkingBindingRecovery(deps.db, info.sessionID);
+            armBindingRecoverySafely(deps.db, info.sessionID);
             sessionLog(info.sessionID, `thinking binding recovery armed from message.updated (provider paths: failing=${bindingMismatch.failingBlockPath ?? "?"} firstChanged=${bindingMismatch.firstChangedPath ?? "?"})`);
             dropSlot(info.sessionID, "thinking-binding-recovery-arm");
             deps.onSessionCacheInvalidated?.(info.sessionID);
@@ -9786,7 +9805,7 @@ function createEventHandler2(deps) {
         let refreshLimitsAfterRecording;
         if (hasUsageTokens) {
           const pressureInputTokens = totalInputTokens;
-          const requestSucceeded = !messageHadOverflowError;
+          const requestSucceeded = !messageHadOverflowError && !responseFailed;
           const successfulUsageProof = requestSucceeded && !aboveTrustedWall;
           if (requestSucceeded) {
             const rawOverflow = getOverflowState(deps.db, info.sessionID);
@@ -9801,7 +9820,7 @@ function createEventHandler2(deps) {
           if (!responseFailed) {
             updates.lastResponseTime = Math.max(sessionMeta.lastResponseTime, responseTime);
           }
-          const observedSafeInputTokens = provenFloorForModel(sessionMeta.observedSafeInputTokens, sessionMeta.lastObservedModelKey, modelKey);
+          const observedSafeInputTokens = resolveOpenCodeProvenInputFloor(deps.db, info.sessionID, modelKey);
           const provenSafeInputTokens = successfulUsageProof ? Math.max(observedSafeInputTokens, pressureInputTokens) : observedSafeInputTokens;
           const readCatalogLimit = () => info.providerID && info.modelID ? getSdkContextLimit(info.providerID, info.modelID) : undefined;
           const resolvePressure = () => {
@@ -9890,6 +9909,9 @@ function createEventHandler2(deps) {
           };
         }
         updateSessionMeta(deps.db, info.sessionID, updates);
+        if (modelKey && updates.observedSafeInputTokens !== undefined) {
+          recordOpenCodeProvenInputFloor(deps.db, info.sessionID, modelKey, updates.observedSafeInputTokens);
+        }
         if (refreshLimitsAfterRecording) {
           await refreshLimitsAfterRecording();
         }
@@ -10343,7 +10365,7 @@ function createMagicContextHook(deps) {
     protectedTokens: deps.config.protected_tokens,
     protectedTokenTierOverrides: deps.config.protectedTokenTierOverrides,
     protectedTools: deps.config.protected_tools,
-    clearReasoningAge: deps.config.clear_reasoning_age ?? 50,
+    keepReasoningTokens: deps.config.keep_reasoning_tokens,
     commitClusterTrigger: bootHistorian.commitClusterTrigger,
     historyRefreshSessions,
     deferredHistoryRefreshSessions,
@@ -10794,10 +10816,546 @@ async function createSessionHooksAsync(args) {
   };
 }
 
+// src/plugin/host-stall-profiler.ts
+import { chmodSync, existsSync as existsSync5, readdirSync, readFileSync as readFileSync5, unlinkSync } from "node:fs";
+import * as path4 from "node:path";
+
+// src/plugin/host-stall-profiler-report.ts
+import { readFileSync as readFileSync4 } from "node:fs";
+import * as path3 from "node:path";
+var MAX_STACK_DEPTH = 64;
+var TOP_STACK_COUNT = 30;
+var TOP_FRAME_COUNT = 30;
+var UNKNOWN_POSITION = 4294967295;
+var BACKGROUND_OWNERS = new Set(["native", "runtime", "opencode"]);
+var packageNameCache = new Map;
+function urlToPath(url) {
+  if (url.startsWith("file://")) {
+    try {
+      return decodeURIComponent(new URL(url).pathname);
+    } catch {
+      return url.slice("file://".length);
+    }
+  }
+  return url;
+}
+function nearestPackageName(filePath) {
+  let dir = path3.dirname(filePath);
+  const visited = [];
+  for (let depth = 0;depth < 12; depth++) {
+    const cached = packageNameCache.get(dir);
+    if (cached !== undefined) {
+      for (const seen of visited)
+        packageNameCache.set(seen, cached);
+      return cached;
+    }
+    visited.push(dir);
+    try {
+      const parsed = JSON.parse(readFileSync4(path3.join(dir, "package.json"), "utf8"));
+      const name = typeof parsed.name === "string" && parsed.name ? parsed.name : null;
+      if (name) {
+        for (const seen of visited)
+          packageNameCache.set(seen, name);
+        return name;
+      }
+    } catch {}
+    const parent = path3.dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  for (const seen of visited)
+    packageNameCache.set(seen, null);
+  return null;
+}
+function sourceOwner(sourceURL) {
+  if (!sourceURL)
+    return "native";
+  if (/^(?:node|bun|builtin|internal):/.test(sourceURL))
+    return "runtime";
+  if (sourceURL.includes("$bunfs") || sourceURL.includes("~BUN"))
+    return "opencode";
+  const filePath = urlToPath(sourceURL).replaceAll("\\", "/");
+  const modules = [...filePath.matchAll(/\/node_modules\/((?:@[^/]+\/)?[^/]+)/g)];
+  const innermost = modules.at(-1);
+  if (innermost)
+    return `npm:${innermost[1]}`;
+  const pluginDir = filePath.match(/\/plugins?\/([^/]+)$/);
+  if (pluginDir && /\/(?:\.?opencode)\/plugins?\//.test(filePath)) {
+    return `plugin:${pluginDir[1]}`;
+  }
+  const name = nearestPackageName(filePath);
+  return name ? `pkg:${name}` : `file:${filePath}`;
+}
+function frameLabel(frame) {
+  const name = frame.name && frame.name.length > 0 ? frame.name : "(anonymous)";
+  if (!frame.sourceURL)
+    return `${name} [native]`;
+  const line = typeof frame.line === "number" && frame.line !== UNKNOWN_POSITION ? `:${frame.line}` : "";
+  return `${name} ${frame.sourceURL}${line}`;
+}
+function attributeSample(frames) {
+  for (const frame of frames) {
+    if (!BACKGROUND_OWNERS.has(frame.owner))
+      return frame.owner;
+  }
+  for (const frame of frames) {
+    if (frame.owner !== "native")
+      return frame.owner;
+  }
+  return "native";
+}
+function bump(map, key, init) {
+  const existing = map.get(key);
+  if (existing)
+    existing.samples += 1;
+  else
+    map.set(key, { ...init(), samples: 1 });
+}
+function topBySamples(values, limit) {
+  return [...values].sort((a, b) => b.samples - a.samples).slice(0, limit);
+}
+function aggregateTraces(traces) {
+  const ownerOf = new Map;
+  const owned = (frame) => {
+    const url = frame.sourceURL ?? "";
+    let owner = ownerOf.get(url);
+    if (owner === undefined) {
+      owner = sourceOwner(frame.sourceURL);
+      ownerOf.set(url, owner);
+    }
+    return { label: frameLabel(frame), owner };
+  };
+  const owners = new Map;
+  const topFrames = new Map;
+  const topJsFrames = new Map;
+  const stacks = new Map;
+  let samples = 0;
+  for (const trace of traces) {
+    const raw = Array.isArray(trace.frames) ? trace.frames : [];
+    if (raw.length === 0)
+      continue;
+    samples += 1;
+    const frames = raw.slice(0, MAX_STACK_DEPTH).map(owned);
+    const owner = attributeSample(frames);
+    bump(owners, owner, () => ({ owner }));
+    const leaf = frames[0];
+    bump(topFrames, `${leaf.owner}\x00${leaf.label}`, () => ({
+      frame: leaf.label,
+      owner: leaf.owner
+    }));
+    const jsIndex = raw.findIndex((frame, index) => index < MAX_STACK_DEPTH && !!frame.sourceURL);
+    if (jsIndex >= 0) {
+      const js = frames[jsIndex];
+      bump(topJsFrames, `${js.owner}\x00${js.label}`, () => ({
+        frame: js.label,
+        owner: js.owner
+      }));
+    }
+    const labels = frames.map((frame) => `${frame.label} (${frame.owner})`);
+    if (raw.length > MAX_STACK_DEPTH) {
+      labels.push(`… ${raw.length - MAX_STACK_DEPTH} outer frames omitted`);
+    }
+    bump(stacks, labels.join(`
+`), () => ({ owner, frames: labels }));
+  }
+  return {
+    samples,
+    owners: topBySamples(owners.values(), Number.POSITIVE_INFINITY).map((entry) => ({
+      ...entry,
+      percent: samples === 0 ? 0 : Math.round(entry.samples / samples * 1000) / 10
+    })),
+    top_frames: topBySamples(topFrames.values(), TOP_FRAME_COUNT),
+    top_js_frames: topBySamples(topJsFrames.values(), TOP_FRAME_COUNT),
+    top_stacks: topBySamples(stacks.values(), TOP_STACK_COUNT)
+  };
+}
+
+// src/plugin/host-stall-profiler.ts
+var HOST_PROFILER_DIRNAME = "host-profiler";
+var HOST_PROFILER_ENABLE_FILENAME = "enable";
+var SWITCH_POLL_MS = 30000;
+var WATCHDOG_INTERVAL_MS = 250;
+var DEFAULT_STALL_THRESHOLD_MS = 3000;
+var DEFAULT_SAMPLE_INTERVAL_MS = 10;
+var MAX_REPORT_FILES = 50;
+var MAX_SAMPLES_PER_WINDOW = 20000;
+var MEMORY_SNAPSHOT_EVERY_TICKS = 4;
+var CALIBRATION_CHUNK_MS = 3;
+var CALIBRATION_MAX_CHUNKS = 30;
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function parseEnableFile(content) {
+  const options = {
+    thresholdMs: DEFAULT_STALL_THRESHOLD_MS,
+    sampleIntervalMs: DEFAULT_SAMPLE_INTERVAL_MS
+  };
+  const trimmed = content.trim();
+  if (trimmed === "")
+    return { options, error: null };
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return { options, error: "enable file is not a JSON object" };
+    }
+    if (typeof parsed.threshold_ms === "number" && Number.isFinite(parsed.threshold_ms)) {
+      options.thresholdMs = clamp(parsed.threshold_ms, 500, 600000);
+    }
+    if (typeof parsed.sample_interval_ms === "number" && Number.isFinite(parsed.sample_interval_ms)) {
+      options.sampleIntervalMs = clamp(parsed.sample_interval_ms, 1, 100);
+    }
+    return { options, error: null };
+  } catch (error) {
+    return {
+      options,
+      error: `enable file is not valid JSON (${error instanceof Error ? error.message : String(error)})`
+    };
+  }
+}
+function asJscApi(module) {
+  const candidate = module ?? null;
+  for (const value of [candidate, candidate?.default]) {
+    const api = value;
+    if (api && typeof api.startSamplingProfiler === "function" && typeof api.samplingProfilerStackTraces === "function" && typeof api.profile === "function") {
+      return api;
+    }
+  }
+  return null;
+}
+function thin(items, limit) {
+  if (items.length <= limit)
+    return items;
+  const stride = items.length / limit;
+  const out = [];
+  for (let i = 0;i < limit; i++)
+    out.push(items[Math.floor(i * stride)]);
+  return out;
+}
+function reportFileStamp(epochMs) {
+  return new Date(epochMs).toISOString().replaceAll(":", "-");
+}
+function createHostStallProfiler(deps) {
+  let jsc = null;
+  let unavailable = false;
+  let pollTimer = null;
+  let watchdog = null;
+  let options = {
+    thresholdMs: DEFAULT_STALL_THRESHOLD_MS,
+    sampleIntervalMs: DEFAULT_SAMPLE_INTERVAL_MS
+  };
+  let lastTickAt = 0;
+  let tickCount = 0;
+  let memoryBefore = null;
+  let clockOffsetMs = null;
+  let checking = null;
+  const loggedOnce = new Set;
+  const safeLog = (message) => {
+    try {
+      deps.log(message);
+    } catch {}
+  };
+  const logOnce = (key, message, error) => {
+    if (loggedOnce.has(key))
+      return;
+    loggedOnce.add(key);
+    const detail = error === undefined ? "" : `: ${error instanceof Error ? error.message : String(error)}`;
+    safeLog(`[magic-context] host stall profiler: ${message}${detail}`);
+  };
+  const drain = (api) => {
+    const raw = api.samplingProfilerStackTraces();
+    return Array.isArray(raw?.traces) ? raw.traces : [];
+  };
+  const pauseSampler = (api, intervalMs) => {
+    try {
+      drain(api);
+    } catch {}
+    api.profile(() => {
+      return;
+    }, Math.round(intervalMs * 1000));
+    drain(api);
+  };
+  const calibrate = (api) => {
+    pauseSampler(api, 1);
+    api.startSamplingProfiler();
+    let offset = null;
+    for (let chunk = 0;chunk < CALIBRATION_MAX_CHUNKS && offset === null; chunk++) {
+      const start = deps.now();
+      let end = start;
+      for (let i = 0;i < 50000000 && end - start < CALIBRATION_CHUNK_MS; i++) {
+        end = deps.now();
+      }
+      const stamps = drain(api).map((trace) => trace.timestamp).filter((value) => typeof value === "number" && Number.isFinite(value)).map((seconds) => seconds * 1000);
+      if (stamps.length >= 2) {
+        offset = (Math.max(...stamps) - end + (Math.min(...stamps) - start)) / 2;
+      }
+    }
+    pauseSampler(api, 1);
+    return offset;
+  };
+  const snapshot = (api) => {
+    const read = (fn) => {
+      try {
+        return fn();
+      } catch {
+        return null;
+      }
+    };
+    return {
+      at: new Date(deps.wallNow()).toISOString(),
+      heap_size_bytes: read(() => api.heapSize?.() ?? null),
+      jsc_memory: read(() => api.memoryUsage?.() ?? null),
+      rss_bytes: read(() => deps.rss()),
+      percent_available_memory_in_use: read(() => api.percentAvailableMemoryInUse?.() ?? null)
+    };
+  };
+  const writeReport = (report, endWallMs) => {
+    const dir = deps.profilerDir();
+    ensureStorageDirectorySync(dir, true);
+    chmodSync(dir, 448);
+    const stamp = reportFileStamp(endWallMs);
+    let name = `stall-${stamp}.json`;
+    for (let n = 1;existsSync5(path4.join(dir, name)); n++)
+      name = `stall-${stamp}-${n}.json`;
+    const finalPath = path4.join(dir, name);
+    writeStorageFileAtomicSync(finalPath, `${JSON.stringify(report, null, 2)}
+`, true);
+    const reports = readdirSync(dir).filter((entry) => /^stall-.*\.json$/.test(entry)).sort();
+    for (const stale of reports.slice(0, Math.max(0, reports.length - MAX_REPORT_FILES))) {
+      try {
+        unlinkSync(path4.join(dir, stale));
+      } catch (error) {
+        logOnce("prune", "could not prune an old report", error);
+      }
+    }
+    return finalPath;
+  };
+  const recordStall = (api, startMs, endMs, traces) => {
+    const after = snapshot(api);
+    const gapMs = endMs - startMs;
+    let windowed = traces;
+    let windowFilter = "since-last-collection";
+    if (clockOffsetMs !== null) {
+      const slackMs = 2 * options.sampleIntervalMs + 20;
+      const lo = startMs + clockOffsetMs - slackMs;
+      const hi = endMs + clockOffsetMs + slackMs;
+      const inWindow = traces.filter((trace) => {
+        const at = typeof trace.timestamp === "number" ? trace.timestamp * 1000 : Number.NaN;
+        return at >= lo && at <= hi;
+      });
+      if (inWindow.length > 0 || traces.length === 0) {
+        windowed = inWindow;
+        windowFilter = "timestamp";
+      } else {
+        windowFilter = "since-last-collection (timestamp filter matched no sample)";
+      }
+    }
+    const kept = thin(windowed, MAX_SAMPLES_PER_WINDOW);
+    const aggregate = aggregateTraces(kept);
+    const endWallMs = deps.wallNow();
+    const startWallMs = endWallMs - gapMs;
+    const report = {
+      kind: "magic-context-host-stall",
+      schema_version: 1,
+      pid: deps.pid,
+      bun_version: deps.bunVersion,
+      platform: process.platform,
+      window: {
+        start: new Date(startWallMs).toISOString(),
+        end: new Date(endWallMs).toISOString(),
+        duration_ms: Math.round(gapMs),
+        lag_ms: Math.round(gapMs - WATCHDOG_INTERVAL_MS),
+        threshold_ms: options.thresholdMs
+      },
+      sampling: {
+        interval_ms: options.sampleIntervalMs,
+        samples_collected: traces.length,
+        samples_in_window: windowed.length,
+        samples_aggregated: kept.length,
+        window_filter: windowFilter,
+        note: aggregate.samples === 0 ? "No JavaScript samples in the window: the main thread was not executing inside the JavaScript VM (idle wait, process suspension, or native work outside any JS call)." : undefined
+      },
+      memory: { before: memoryBefore, after },
+      owners: aggregate.owners,
+      top_frames: aggregate.top_frames,
+      top_js_frames: aggregate.top_js_frames,
+      top_stacks: aggregate.top_stacks
+    };
+    const file = writeReport(report, endWallMs);
+    const top = aggregate.owners[0];
+    safeLog(`[magic-context] host stall profiler: ${Math.round(gapMs)}ms main-thread stall, ${aggregate.samples} samples, top owner ${top ? `${top.owner} (${top.percent}%)` : "none"} → ${file}`);
+    memoryBefore = after;
+  };
+  const tick = () => {
+    const api = jsc;
+    if (!api || watchdog === null)
+      return;
+    try {
+      const now = deps.now();
+      const startMs = lastTickAt;
+      lastTickAt = now;
+      const traces = drain(api);
+      if (now - startMs > options.thresholdMs) {
+        try {
+          recordStall(api, startMs, now, traces);
+        } catch (error) {
+          logOnce("report", "could not write a stall report", error);
+        }
+      }
+      tickCount += 1;
+      if (tickCount % MEMORY_SNAPSHOT_EVERY_TICKS === 0)
+        memoryBefore = snapshot(api);
+    } catch (error) {
+      logOnce("tick", "watchdog tick failed", error);
+    }
+  };
+  const enable = (api, next) => {
+    const startedAt = deps.now();
+    try {
+      options = next;
+      clockOffsetMs = calibrate(api);
+      pauseSampler(api, options.sampleIntervalMs);
+      api.startSamplingProfiler();
+      lastTickAt = deps.now();
+      tickCount = 0;
+      memoryBefore = snapshot(api);
+      watchdog = deps.setInterval(tick, WATCHDOG_INTERVAL_MS);
+      safeLog(`[magic-context] host stall profiler enabled: threshold ${options.thresholdMs}ms, sample interval ${options.sampleIntervalMs}ms, clock calibration ${clockOffsetMs === null ? "unavailable" : "ok"}, setup ${Math.round(deps.now() - startedAt)}ms, reports in ${deps.profilerDir()}`);
+    } catch (error) {
+      watchdog = null;
+      try {
+        pauseSampler(api, options.sampleIntervalMs);
+      } catch {}
+      logOnce("enable", "could not start", error);
+    }
+  };
+  const disable = (reason) => {
+    if (watchdog !== null)
+      deps.clearInterval(watchdog);
+    watchdog = null;
+    memoryBefore = null;
+    if (jsc) {
+      try {
+        pauseSampler(jsc, options.sampleIntervalMs);
+      } catch (error) {
+        logOnce("disable", "could not pause the sampler", error);
+      }
+    }
+    safeLog(`[magic-context] host stall profiler disabled: ${reason}`);
+  };
+  const ensureJsc = async () => {
+    if (jsc)
+      return jsc;
+    try {
+      const api = asJscApi(await deps.loadJsc());
+      if (!api)
+        throw new Error("bun:jsc lacks the sampling profiler API");
+      jsc = api;
+      return api;
+    } catch (error) {
+      unavailable = true;
+      if (pollTimer !== null)
+        deps.clearInterval(pollTimer);
+      pollTimer = null;
+      logOnce("jsc", "bun:jsc is unavailable, profiler disabled for this process", error);
+      return null;
+    }
+  };
+  const runCheck = async () => {
+    if (unavailable)
+      return;
+    try {
+      const enablePath = path4.join(deps.profilerDir(), HOST_PROFILER_ENABLE_FILENAME);
+      if (!existsSync5(enablePath)) {
+        if (watchdog !== null)
+          disable("enable file removed");
+        return;
+      }
+      const parsed = parseEnableFile(readFileSync5(enablePath, "utf8"));
+      if (parsed.error)
+        logOnce(`options:${parsed.error}`, parsed.error);
+      if (watchdog !== null) {
+        if (jsc && parsed.options.sampleIntervalMs !== options.sampleIntervalMs) {
+          pauseSampler(jsc, parsed.options.sampleIntervalMs);
+          jsc.startSamplingProfiler();
+        }
+        options = parsed.options;
+        return;
+      }
+      const api = await ensureJsc();
+      if (!api || watchdog !== null || !existsSync5(enablePath))
+        return;
+      enable(api, parsed.options);
+    } catch (error) {
+      logOnce("check", "enable-file check failed", error);
+    }
+  };
+  const checkNow = () => {
+    if (!checking) {
+      checking = runCheck().finally(() => {
+        checking = null;
+      });
+    }
+    return checking;
+  };
+  return {
+    start() {
+      if (pollTimer !== null || unavailable)
+        return;
+      pollTimer = deps.setInterval(() => void checkNow(), SWITCH_POLL_MS);
+      checkNow();
+    },
+    checkNow,
+    stop() {
+      if (pollTimer !== null)
+        deps.clearInterval(pollTimer);
+      pollTimer = null;
+      if (watchdog !== null)
+        disable("stopped");
+    },
+    isActive: () => watchdog !== null,
+    isUnavailable: () => unavailable
+  };
+}
+function hostStallProfilerDir() {
+  return path4.join(getMagicContextStorageDir(), HOST_PROFILER_DIRNAME);
+}
+function defaultDeps() {
+  return {
+    profilerDir: hostStallProfilerDir,
+    loadJsc: () => import("bun:jsc"),
+    now: () => performance.now(),
+    wallNow: () => Date.now(),
+    setInterval: (callback, ms) => {
+      const handle = setInterval(callback, ms);
+      handle.unref?.();
+      return handle;
+    },
+    clearInterval: (handle) => clearInterval(handle),
+    rss: () => process.memoryUsage.rss(),
+    log,
+    pid: process.pid,
+    bunVersion: process.versions.bun ?? null
+  };
+}
+var PROCESS_PROFILER_KEY = Symbol.for("cortexkit.magic-context.host-stall-profiler");
+function startHostStallProfilerSwitch() {
+  try {
+    const holder = globalThis;
+    if (holder[PROCESS_PROFILER_KEY])
+      return;
+    const handle = createHostStallProfiler(defaultDeps());
+    holder[PROCESS_PROFILER_KEY] = handle;
+    handle.start();
+  } catch (error) {
+    log("[magic-context] host stall profiler: could not start the enable-file switch", error);
+  }
+}
+
 // src/plugin/instance-disposal.ts
-import path3 from "node:path";
+import path5 from "node:path";
 function isDisposedInstanceDirectory(ownDirectory, disposedDirectory) {
-  return path3.resolve(disposedDirectory) === path3.resolve(ownDirectory);
+  return path5.resolve(disposedDirectory) === path5.resolve(ownDirectory);
 }
 
 // src/plugin/native-compaction-guard.ts
@@ -10981,26 +11539,26 @@ function unregisterExitAbort(controller) {
 }
 
 // src/v2/hooks/update-check.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "node:fs";
-import { dirname as dirname3, join as join5 } from "node:path";
+import { existsSync as existsSync6, readFileSync as readFileSync6 } from "node:fs";
+import { dirname as dirname4, join as join7 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var cachedPackageInfo;
 function packageInfo() {
   if (cachedPackageInfo)
     return cachedPackageInfo;
-  let directory = dirname3(fileURLToPath2(import.meta.url));
+  let directory = dirname4(fileURLToPath2(import.meta.url));
   for (;; ) {
     try {
-      const pkg = JSON.parse(readFileSync4(join5(directory, "package.json"), "utf8"));
+      const pkg = JSON.parse(readFileSync6(join7(directory, "package.json"), "utf8"));
       if (pkg.name === "@cortexkit/opencode-magic-context" && typeof pkg.version === "string") {
         cachedPackageInfo = {
           version: pkg.version,
-          development: existsSync5(join5(directory, "src/v2/server.ts"))
+          development: existsSync6(join7(directory, "src/v2/server.ts"))
         };
         return cachedPackageInfo;
       }
     } catch {}
-    const parent = dirname3(directory);
+    const parent = dirname4(directory);
     if (parent === directory)
       throw new Error("Magic Context package manifest is unavailable");
     directory = parent;
@@ -11065,7 +11623,7 @@ async function setup(context) {
     log("v2 setup() called on a host without session.hook; v1 server lane owns this host, v2 lane inert");
     return async () => {};
   }
-  const { registerContext } = await import("./context-8dkpszy5.js");
+  const { registerContext } = await import("./context-wq4ffwyb.js");
   setHarness("opencode2");
   bindStaleBuildNotice({}, import.meta.url, "opencode2");
   const duties = await registerContext(context);
@@ -11093,6 +11651,7 @@ var server = async (ctx) => {
   let deadlinePhase = null;
   emitBootEnteringBreadcrumb(process.pid, ctx.directory, log, flushLogger);
   setHarness("opencode");
+  startHostStallProfilerSwitch();
   const configStartedAt = performance.now();
   beginBootQuietPeriod();
   const configMigrationWarnings = migrateMagicContextConfigLocations(ctx.directory, {
@@ -11135,7 +11694,7 @@ var server = async (ctx) => {
     if (hasBannerEntries)
       setTimeout(async () => {
         try {
-          const { sendStatusNotification } = await importPluginModule(() => import("./send-session-notification-dyw42dtr.js"));
+          const { sendStatusNotification } = await importPluginModule(() => import("./send-session-notification-0m68ms3n.js"));
           const clientWithSessions = ctx.client;
           const sessions = await Promise.resolve(clientWithSessions.session?.list?.()).catch(() => null);
           const sessionList = Array.isArray(sessions) ? sessions : sessions?.data;
@@ -11152,7 +11711,7 @@ var server = async (ctx) => {
     log(`[magic-context] opencode_db_missing path=${openCodeDbResolution.path} source=${openCodeDbResolution.source}`);
     setTimeout(async () => {
       try {
-        const { sendStatusNotification } = await importPluginModule(() => import("./send-session-notification-dyw42dtr.js"));
+        const { sendStatusNotification } = await importPluginModule(() => import("./send-session-notification-0m68ms3n.js"));
         const clientWithSessions = ctx.client;
         const sessions = await Promise.resolve(clientWithSessions.session?.list?.()).catch(() => null);
         const sessionList = Array.isArray(sessions) ? sessions : sessions?.data;
@@ -11427,12 +11986,12 @@ var server = async (ctx) => {
   {
     const fence = getSchemaFenceRejection();
     if (fence) {
-      importPluginModule(() => import("./conflict-warning-hook-7fj2b9jw.js")).then(({ sendSchemaFenceWarning }) => sendSchemaFenceWarning(ctx.client, ctx.directory, fence)).catch((error) => log("[magic-context] schema-fence warning unavailable:", error));
+      importPluginModule(() => import("./conflict-warning-hook-z44ynfz7.js")).then(({ sendSchemaFenceWarning }) => sendSchemaFenceWarning(ctx.client, ctx.directory, fence)).catch((error) => log("[magic-context] schema-fence warning unavailable:", error));
     }
   }
   const serverUrl = ctx.serverUrl;
   const serverUrlStr = serverUrl instanceof URL ? serverUrl.toString().replace(/\/$/, "") : typeof serverUrl === "string" ? serverUrl.replace(/\/$/, "") : undefined;
-  importPluginModule(() => import("./send-session-notification-dyw42dtr.js")).then(({ setNotificationServerUrl }) => {
+  importPluginModule(() => import("./send-session-notification-0m68ms3n.js")).then(({ setNotificationServerUrl }) => {
     setNotificationServerUrl(serverUrlStr);
   }).catch((error) => log("[magic-context] notification transport unavailable:", error));
   if (conflictResult?.hasConflict) {
@@ -11455,7 +12014,7 @@ var server = async (ctx) => {
       }) => {
         if (!shouldShowAnnouncement())
           return;
-        return importPluginModule(() => import("./conflict-warning-hook-7fj2b9jw.js")).then(({ sendStartupAnnouncement }) => sendStartupAnnouncement(ctx.client, ctx.directory, ANNOUNCEMENT_VERSION, ANNOUNCEMENT_FEATURES, ANNOUNCEMENT_FOOTER, markAnnouncementSeen));
+        return importPluginModule(() => import("./conflict-warning-hook-z44ynfz7.js")).then(({ sendStartupAnnouncement }) => sendStartupAnnouncement(ctx.client, ctx.directory, ANNOUNCEMENT_VERSION, ANNOUNCEMENT_FEATURES, ANNOUNCEMENT_FOOTER, markAnnouncementSeen));
       }).catch(() => {});
     }, 8000);
   }
@@ -11537,8 +12096,8 @@ var server = async (ctx) => {
         gate: checkoutClaimGate,
         projectRoot: ctx.directory,
         onRefusal: async (sessionId, message) => {
-          const { sendStatusNotification } = await importPluginModule(() => import("./send-session-notification-dyw42dtr.js"));
-          const { abortSessionFailClosed } = await importPluginModule(() => import("./transform-postprocess-phase-tz3pat2p.js"));
+          const { sendStatusNotification } = await importPluginModule(() => import("./send-session-notification-0m68ms3n.js"));
+          const { abortSessionFailClosed } = await importPluginModule(() => import("./transform-postprocess-phase-z5hzpsxv.js"));
           await sendStatusNotification(ctx.client, sessionId, message, {
             toastDurationMs: 15000
           });
@@ -11550,8 +12109,8 @@ var server = async (ctx) => {
       tryReopenStorage,
       rustReplayParticipant: () => magicContextRuntime.magicContext?.getRustReplayParticipant?.() ?? null,
       onStorageBusyRefusal: async (sessionId, message) => {
-        const { sendStatusNotification } = await importPluginModule(() => import("./send-session-notification-dyw42dtr.js"));
-        const { abortSessionFailClosed } = await importPluginModule(() => import("./transform-postprocess-phase-tz3pat2p.js"));
+        const { sendStatusNotification } = await importPluginModule(() => import("./send-session-notification-0m68ms3n.js"));
+        const { abortSessionFailClosed } = await importPluginModule(() => import("./transform-postprocess-phase-z5hzpsxv.js"));
         await sendStatusNotification(ctx.client, sessionId, message, {
           toastDurationMs: 15000
         });