@cortexkit/opencode-magic-context 0.45.0 → 0.46.1

package/dist/v2/recomp-orchestrator-8ejxvrzz.js

@@ -0,0 +1,39 @@
+import {
+  isRecompFailure2,
+  isRecompSkip2,
+  extractRecompReason2,
+  setRecompStarting2,
+  setRecompNote2,
+  setRecompTerminal2,
+  buildRecompDeps2,
+  runManagedRecomp2
+} from "./server-jc7y02q0.js";
+import"./server-mcfawjgc.js";
+import"./server-3n4q9xme.js";
+import"./server-c5gz8wph.js";
+import"./server-y8maxeft.js";
+import"./server-xa4xe3rv.js";
+import"./server-e29d7p7c.js";
+import"./server-frbm99q5.js";
+import"./server-qp5hx1ad.js";
+import"./server-wvjvfhck.js";
+import"./server-1zx87sdm.js";
+import"./server-g0fjrkta.js";
+import"./server-vs5gpnd4.js";
+import"./server-ajzeteqw.js";
+import"./server-51dv1pr5.js";
+import"./server-14vq4kpm.js";
+import"./server-fg34g6a5.js";
+import"./server-x8a7jmkh.js";
+import"./server-6r257mf5.js";
+import"./server-1qbnzc80.js";
+export {
+  buildRecompDeps2 as buildRecompDeps,
+  extractRecompReason2 as extractRecompReason,
+  isRecompFailure2 as isRecompFailure,
+  isRecompSkip2 as isRecompSkip,
+  runManagedRecomp2 as runManagedRecomp,
+  setRecompNote2 as setRecompNote,
+  setRecompStarting2 as setRecompStarting,
+  setRecompTerminal2 as setRecompTerminal
+};

package/dist/v2/{safe-notification-target-wtj0bbc2.js → safe-notification-target-eb1n1vfb.js}

@@ -1,8 +1,8 @@
 import {
   isDefaultSessionTitle2,
   waitForSafeNotificationTarget2
-} from "./server-5317ykaf.js";
-import"./server-ckpc8pxy.js";
+} from "./server-6r257mf5.js";
+import"./server-1qbnzc80.js";
 export {
   isDefaultSessionTitle2 as isDefaultSessionTitle,
   waitForSafeNotificationTarget2 as waitForSafeNotificationTarget

package/dist/v2/{send-session-notification-mq9frrtm.js → send-session-notification-qs0j78v6.js}

@@ -8,12 +8,12 @@ import {
   clearIgnoredMessages2,
   observeIgnoredNotificationEvent2,
   sendStatusNotification2
-} from "./server-z19x7eqz.js";
-import"./server-w99cyt6a.js";
-import"./server-qpg6wf72.js";
-import"./server-a4m2b1yv.js";
-import"./server-5317ykaf.js";
-import"./server-ckpc8pxy.js";
+} from "./server-mcfawjgc.js";
+import"./server-wvjvfhck.js";
+import"./server-ajzeteqw.js";
+import"./server-fg34g6a5.js";
+import"./server-6r257mf5.js";
+import"./server-1qbnzc80.js";
 export {
   MAX_QUEUED_IGNORED_NOTIFICATIONS2 as MAX_QUEUED_IGNORED_NOTIFICATIONS,
   __ignoredNotificationTest2 as __ignoredNotificationTest,

package/dist/v2/server-14vq4kpm.js

@@ -0,0 +1,30 @@
+import {
+  log
+} from "./server-1qbnzc80.js";
+
+// src/shared/write-transaction-timing.ts
+var SLOW_WRITE_TRANSACTION_THRESHOLD_MS = 1000;
+function logSlowWriteTransaction(site, startedAt, thresholdMs = SLOW_WRITE_TRANSACTION_THRESHOLD_MS, completedAtMs = performance.now(), steps) {
+  try {
+    const durationMs = completedAtMs - startedAt;
+    if (durationMs < thresholdMs)
+      return;
+    const detail = steps ? Object.entries(steps).map(([name, ms]) => `${name}=${ms.toFixed(1)}ms`).join(" ") : "";
+    log(`[magic-context] slow write transaction: site=${site} held=${durationMs.toFixed(1)}ms${detail ? ` ${detail}` : ""}`);
+  } catch {}
+}
+
+class WriteTransactionSteps {
+  durations = {};
+  last = performance.now();
+  mark(name) {
+    const now = performance.now();
+    this.durations[name] = now - this.last;
+    this.last = now;
+  }
+  reset() {
+    this.last = performance.now();
+  }
+}
+
+export { logSlowWriteTransaction, WriteTransactionSteps };

package/dist/v2/server-1bc61ans.js

@@ -0,0 +1,154 @@
+// src/shared/storage-permissions.ts
+import { randomBytes } from "node:crypto";
+import {
+  chmodSync,
+  closeSync,
+  createWriteStream,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readdirSync,
+  readlinkSync,
+  readSync,
+  renameSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+  writeSync
+} from "node:fs";
+import { open as openAsync, writeFile as writeFileAsync } from "node:fs/promises";
+import { dirname, join } from "node:path";
+var enforcePrivateStoragePermissions = true;
+function setStoragePrivatePermissionEnforcement(enforce) {
+  enforcePrivateStoragePermissions = enforce;
+}
+function shouldEnforcePrivateStoragePermissions() {
+  return enforcePrivateStoragePermissions;
+}
+function ensureStorageDirectorySync(directory, forcePrivate = false, recursive = true) {
+  const privateMode = forcePrivate || shouldEnforcePrivateStoragePermissions();
+  mkdirSync(directory, {
+    recursive,
+    ...privateMode ? { mode: 448 } : {}
+  });
+}
+function writeStorageFileSync(filePath, content, options = {}) {
+  const { forcePrivate = false, ...writeOptions } = options;
+  const privateMode = forcePrivate || shouldEnforcePrivateStoragePermissions();
+  writeFileSync(filePath, content, {
+    ...writeOptions,
+    ...privateMode ? { mode: 384 } : {}
+  });
+}
+function writeStorageFileAtomicSync(filePath, content, forcePrivate = false) {
+  ensureStorageDirectorySync(dirname(filePath), forcePrivate);
+  const tempPath = `${filePath}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+  try {
+    writeStorageFileSync(tempPath, content, { flag: "wx", forcePrivate });
+    renameSync(tempPath, filePath);
+  } catch (error) {
+    rmSync(tempPath, { force: true });
+    throw error;
+  }
+}
+function copyStorageFileSync(sourcePath, destinationPath, forcePrivate = false) {
+  ensureStorageDirectorySync(dirname(destinationPath), forcePrivate);
+  const privateMode = forcePrivate || shouldEnforcePrivateStoragePermissions();
+  const sourceFd = openSync(sourcePath, "r");
+  let destinationFd;
+  try {
+    destinationFd = openSync(destinationPath, "wx", privateMode ? 384 : 438);
+    const buffer = Buffer.allocUnsafe(1024 * 1024);
+    for (;; ) {
+      const bytesRead = readSync(sourceFd, buffer, 0, buffer.length, null);
+      if (bytesRead === 0)
+        break;
+      let offset = 0;
+      while (offset < bytesRead) {
+        offset += writeSync(destinationFd, buffer, offset, bytesRead - offset);
+      }
+    }
+  } catch (error) {
+    if (destinationFd !== undefined)
+      rmSync(destinationPath, { force: true });
+    throw error;
+  } finally {
+    closeSync(sourceFd);
+    if (destinationFd !== undefined)
+      closeSync(destinationFd);
+  }
+}
+function copyStorageTreeSync(sourcePath, destinationPath, forcePrivate = false) {
+  const stat = lstatSync(sourcePath);
+  if (stat.isSymbolicLink()) {
+    ensureStorageDirectorySync(dirname(destinationPath), forcePrivate);
+    symlinkSync(readlinkSync(sourcePath), destinationPath);
+    return;
+  }
+  if (!stat.isDirectory()) {
+    copyStorageFileSync(sourcePath, destinationPath, forcePrivate);
+    return;
+  }
+  ensureStorageDirectorySync(destinationPath, forcePrivate);
+  for (const entry of readdirSync(sourcePath)) {
+    copyStorageTreeSync(join(sourcePath, entry), join(destinationPath, entry), forcePrivate);
+  }
+}
+async function writeStorageFileAsync(filePath, content, forcePrivate = false) {
+  const privateMode = forcePrivate || shouldEnforcePrivateStoragePermissions();
+  ensureStorageDirectorySync(dirname(filePath), privateMode);
+  await writeFileAsync(filePath, content, privateMode ? { mode: 384 } : undefined);
+}
+async function writeStorageFileHandleAsync(handle, content) {
+  await handle.writeFile(content);
+}
+function createStorageWriteStream(filePath, forcePrivate = false) {
+  const privateMode = forcePrivate || shouldEnforcePrivateStoragePermissions();
+  return createWriteStream(filePath, privateMode ? { mode: 384 } : undefined);
+}
+async function createStorageFileHandleAsync(filePath, flags, forcePrivate = false) {
+  const privateMode = forcePrivate || shouldEnforcePrivateStoragePermissions();
+  return openAsync(filePath, flags, privateMode ? 384 : undefined);
+}
+function tightenStorageTreeSync(root) {
+  if (!shouldEnforcePrivateStoragePermissions() || process.platform === "win32") {
+    return { tightened: 0, failures: 0 };
+  }
+  let tightened = 0;
+  let failures = 0;
+  const visit = (entryPath) => {
+    let stat;
+    try {
+      stat = lstatSync(entryPath);
+    } catch {
+      failures++;
+      return;
+    }
+    if (stat.isSymbolicLink())
+      return;
+    const mode = stat.isDirectory() ? 448 : 384;
+    if ((stat.mode & 63) !== 0 || (stat.mode & 511) !== mode) {
+      try {
+        chmodSync(entryPath, mode);
+        tightened++;
+      } catch {
+        failures++;
+      }
+    }
+    if (!stat.isDirectory())
+      return;
+    let entries;
+    try {
+      entries = readdirSync(entryPath);
+    } catch {
+      failures++;
+      return;
+    }
+    for (const entry of entries)
+      visit(join(entryPath, entry));
+  };
+  visit(root);
+  return { tightened, failures };
+}
+
+export { setStoragePrivatePermissionEnforcement, shouldEnforcePrivateStoragePermissions, ensureStorageDirectorySync, writeStorageFileSync, writeStorageFileAtomicSync, copyStorageFileSync, copyStorageTreeSync, writeStorageFileAsync, writeStorageFileHandleAsync, createStorageWriteStream, createStorageFileHandleAsync, tightenStorageTreeSync };

package/dist/v2/{server-n96ag4rk.js → server-1zx87sdm.js}

@@ -608,6 +608,10 @@ function resolveDecisionCalibration(providerId, modelId) {
     source: ratios.matchedByModelId ? "model-id" : ratios.derivedFrom ? "family-fallback" : "seed"
   });
 }
+function hasMeasuredDecisionCalibration(seed) {
+  const measured = calibrationForModelKey(seed.modelKey);
+  return seed.seeded && seed.source === "seed" && measured.seeded && measured.source === "seed";
+}
 function providerMass(raw, seed, fit = false) {
   const { system = 0, tools = 0, prose = 0 } = raw;
   if ([system, tools, prose].some((count) => !Number.isFinite(count) || count < 0) || [seed.systemRatio, seed.toolsRatio, seed.proseRatio].some((ratio) => !Number.isFinite(ratio) || ratio <= 0)) {
@@ -630,4 +634,4 @@ function historyLocalBudget(providerTokens, modelKey) {
   return ratio === 1 ? providerTokens : localBudget(providerTokens, ratio);
 }
 
-export { UNKNOWN_FIT_RATIO, resolveModelCalibration, calibrateBuckets, resolveDecisionCalibration, providerMass, localBudget, calibrationForModelKey, historyLocalBudget };
+export { UNKNOWN_FIT_RATIO, resolveModelCalibration, calibrateBuckets, resolveDecisionCalibration, hasMeasuredDecisionCalibration, providerMass, localBudget, calibrationForModelKey, historyLocalBudget };

package/dist/v2/server-3n4q9xme.js

@@ -0,0 +1,79 @@
+import {
+  log
+} from "./server-1qbnzc80.js";
+import {
+  getSdkWindowGeometry,
+  getSdkContextLimit,
+  getSdkInputLimit
+} from "./server-y8maxeft.js";
+import {
+  localBudget,
+  calibrationForModelKey
+} from "./server-1zx87sdm.js";
+
+// src/hooks/magic-context/derive-budgets.ts
+var TRIGGER_BUDGET_PERCENTAGE = 0.05;
+var TRIGGER_BUDGET_MIN = 5000;
+var TRIGGER_BUDGET_MAX = 50000;
+var HISTORIAN_CHUNK_PERCENTAGE = 0.25;
+var HISTORIAN_CHUNK_MIN = 8000;
+var HISTORIAN_CHUNK_MAX = 50000;
+var DEFAULT_HISTORIAN_CONTEXT_FALLBACK = 128000;
+function deriveTriggerBudget2(mainContextLimit, executeThresholdPercentage) {
+  if (!Number.isFinite(mainContextLimit) || mainContextLimit <= 0) {
+    return TRIGGER_BUDGET_MIN;
+  }
+  const thresholdFraction = Math.max(0, executeThresholdPercentage) / 100;
+  const usable = mainContextLimit * thresholdFraction;
+  const derived = Math.round(usable * TRIGGER_BUDGET_PERCENTAGE);
+  return Math.max(TRIGGER_BUDGET_MIN, Math.min(TRIGGER_BUDGET_MAX, derived));
+}
+function deriveHistorianChunkTokens2(historianContextLimit) {
+  if (!Number.isFinite(historianContextLimit) || historianContextLimit <= 0) {
+    return HISTORIAN_CHUNK_MIN;
+  }
+  const derived = Math.round(historianContextLimit * HISTORIAN_CHUNK_PERCENTAGE);
+  return Math.max(HISTORIAN_CHUNK_MIN, Math.min(HISTORIAN_CHUNK_MAX, derived));
+}
+function resolveKnownHistorianContextLimit2(historianModelOverride) {
+  if (typeof historianModelOverride !== "string" || !historianModelOverride.includes("/")) {
+    return;
+  }
+  const [providerID, ...rest] = historianModelOverride.split("/");
+  const modelID = rest.join("/");
+  if (!providerID || !modelID)
+    return;
+  const limit = getSdkContextLimit(providerID, modelID, undefined, { reservation: "none" });
+  return typeof limit === "number" && limit > 0 ? limit : undefined;
+}
+function resolveHistorianProducerLimits2(modelKey) {
+  if (!modelKey?.includes("/"))
+    return {};
+  const [provider, ...parts] = modelKey.split("/");
+  const model = parts.join("/");
+  if (!provider || !model)
+    return {};
+  const input = getSdkInputLimit(provider, model);
+  const window = getSdkWindowGeometry(provider, model)?.derivation.window;
+  const context = window ?? (input === undefined ? resolveKnownHistorianContextLimit2(modelKey) : undefined);
+  return {
+    ...context !== undefined ? { context } : {},
+    ...input !== undefined ? { input } : {}
+  };
+}
+function resolveHistorianContextLimit2(historianModelOverride) {
+  if (typeof historianModelOverride === "string" && historianModelOverride.includes("/")) {
+    return resolveKnownHistorianContextLimit2(historianModelOverride) ?? DEFAULT_HISTORIAN_CONTEXT_FALLBACK;
+  }
+  if (typeof historianModelOverride === "string" && historianModelOverride.trim() !== "") {
+    log(`[magic-context] historian.model "${historianModelOverride}" lacks provider prefix ("provider/model-id"); using the default context limit for chunk-budget derivation.`);
+  }
+  return DEFAULT_HISTORIAN_CONTEXT_FALLBACK;
+}
+function producerSourceLocalBudget2(providerTokens, modelKey) {
+  const seed = calibrationForModelKey(modelKey);
+  const ratio = Math.max(seed.proseRatio, seed.toolsRatio);
+  return ratio === 1 ? providerTokens : localBudget(providerTokens, ratio);
+}
+
+export { deriveTriggerBudget2, deriveHistorianChunkTokens2, resolveKnownHistorianContextLimit2, resolveHistorianProducerLimits2, resolveHistorianContextLimit2, producerSourceLocalBudget2 };

package/dist/v2/{server-rhdgxp1t.js → server-51dv1pr5.js}

@@ -1,6 +1,6 @@
 import {
   log
-} from "./server-ckpc8pxy.js";
+} from "./server-1qbnzc80.js";
 
 // src/shared/internal-initiator-marker.ts
 var OMO_INTERNAL_INITIATOR_MARKER = "<!-- OMO_INTERNAL_INITIATOR -->";
@@ -326,6 +326,12 @@ function getTokenEstimatorFingerprint() {
   estimatorFingerprint = fingerprint;
   return fingerprint;
 }
+function hasTokenizerForFit() {
+  return getTokenizer() !== undefined;
+}
+function tokenCountUsesByteBound(text) {
+  return text.length > 1024 * 1024 || /[\p{L}\p{N}]{16385}/u.test(text);
+}
 function estimateTokens(text) {
   if (!text)
     return 0;
@@ -341,6 +347,61 @@ function estimateTokens(text) {
     return estimateTokensHeuristically(text);
   }
 }
+function createTokenCountMemo(maxEntries, maxBytes) {
+  const counts = new Map;
+  let bytes = 0;
+  return (text) => {
+    const cached = counts.get(text);
+    if (cached && cached.tokenizer === getTokenizer())
+      return cached.tokens;
+    const tokens = estimateTokens(text);
+    if (cached) {
+      bytes -= text.length * 2;
+      counts.delete(text);
+    }
+    if (text.length * 2 <= maxBytes) {
+      while (counts.size >= maxEntries || bytes + text.length * 2 > maxBytes) {
+        const oldest = counts.keys().next().value;
+        if (oldest === undefined)
+          break;
+        bytes -= oldest.length * 2;
+        counts.delete(oldest);
+      }
+      counts.set(text, { tokenizer: getTokenizer(), tokens });
+      bytes += text.length * 2;
+    }
+    return tokens;
+  };
+}
+var promptTokenCounts = new Map;
+var promptTokenCountBytes = 0;
+var PROMPT_TOKEN_COUNT_BYTES = 8 * 1024 * 1024;
+function estimateFixedPromptTokens(text) {
+  const activeTokenizer = getTokenizer();
+  const cached = promptTokenCounts.get(text);
+  if (cached && cached.tokenizer === activeTokenizer) {
+    promptTokenCounts.delete(text);
+    promptTokenCounts.set(text, cached);
+    return cached.tokens;
+  }
+  const tokens = estimateTokens(text);
+  if (cached) {
+    promptTokenCountBytes -= text.length * 2;
+    promptTokenCounts.delete(text);
+  }
+  if (text.length * 2 <= PROMPT_TOKEN_COUNT_BYTES) {
+    while (promptTokenCounts.size >= 64 || promptTokenCountBytes + text.length * 2 > PROMPT_TOKEN_COUNT_BYTES) {
+      const oldest = promptTokenCounts.keys().next().value;
+      if (oldest === undefined)
+        break;
+      promptTokenCountBytes -= oldest.length * 2;
+      promptTokenCounts.delete(oldest);
+    }
+    promptTokenCounts.set(text, { tokenizer: getTokenizer(), tokens });
+    promptTokenCountBytes += text.length * 2;
+  }
+  return tokens;
+}
 function normalizeText(text) {
   return text.replace(/\s+/g, " ").trim();
 }
@@ -395,4 +456,4 @@ function mergeCommitHashes(existing, next) {
   return merged;
 }
 
-export { textMentionsRecentCommit, OMO_INTERNAL_INITIATOR_MARKER, isSystemDirective, removeSystemReminders, hasMeaningfulUserText2, extractTexts2, extractToolResultBodyTokens, extractToolCallSummaries, getTokenizerNativeMemoryStats, preloadTokenizer, getTokenEstimatorFingerprint, estimateTokens, normalizeText, compactRole, formatBlock, compactTextForSummary, mergeCommitHashes };
+export { textMentionsRecentCommit, OMO_INTERNAL_INITIATOR_MARKER, isSystemDirective, removeSystemReminders, hasMeaningfulUserText2, extractTexts2, extractToolResultBodyTokens, extractToolCallSummaries, getTokenizerNativeMemoryStats, preloadTokenizer, getTokenEstimatorFingerprint, hasTokenizerForFit, tokenCountUsesByteBound, estimateTokens, createTokenCountMemo, estimateFixedPromptTokens, normalizeText, compactRole, formatBlock, compactTextForSummary, mergeCommitHashes };

package/dist/v2/{server-5317ykaf.js → server-6r257mf5.js}

@@ -1,6 +1,6 @@
 import {
   log
-} from "./server-ckpc8pxy.js";
+} from "./server-1qbnzc80.js";
 
 // src/shared/safe-notification-target.ts
 var DEFAULT_TITLE_RE = /^(New session - |Child session - )\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;

package/dist/v2/server-84w6rvvf.js

@@ -0,0 +1,14 @@
+// src/hooks/auto-update-checker/semver.ts
+function isValidSemver(version) {
+  return /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(version);
+}
+function compareSemverCore(a, b) {
+  if (!isValidSemver(a) || !isValidSemver(b))
+    return null;
+  const core = (v) => v.split(/[-+]/, 1)[0].split(".").map((n) => Number.parseInt(n, 10));
+  const [a0, a1, a2] = core(a);
+  const [b0, b1, b2] = core(b);
+  return a0 - b0 || a1 - b1 || a2 - b2;
+}
+
+export { compareSemverCore };

package/dist/v2/{server-qpg6wf72.js → server-ajzeteqw.js}

@@ -6,6 +6,14 @@ function closeQuietly(db) {
     db.close();
   } catch {}
 }
+function isKnownAutocommit(db) {
+  const state = db;
+  try {
+    return state.inTransaction === false || state.isTransaction === false;
+  } catch {
+    return false;
+  }
+}
 
 // src/shared/opencode-db-path.ts
 import { existsSync, readdirSync, statSync } from "node:fs";
@@ -184,4 +192,4 @@ function claimOpenCodeDbDiagnosticOnce(surface, resolution) {
   return true;
 }
 
-export { resolveOpenCodeDbPath, hasV1MessageTables, assertOpenCodeStoreGeneration, openCodeDbPathExists, getOpenCodeDbProbeDescriptions, recordOpenCodeDbReadFailure, clearOpenCodeDbReadFailure, claimOpenCodeDbDiagnosticOnce, closeQuietly };
+export { closeQuietly, isKnownAutocommit, resolveOpenCodeDbPath, hasV1MessageTables, assertOpenCodeStoreGeneration, openCodeDbPathExists, getOpenCodeDbProbeDescriptions, recordOpenCodeDbReadFailure, clearOpenCodeDbReadFailure, claimOpenCodeDbDiagnosticOnce };