@cortexkit/opencode-magic-context 0.44.4 → 0.45.0

package/dist/index-gd5qx1j9.js

@@ -0,0 +1,398 @@
+import {
+  log
+} from "./index-hybnrwq0.js";
+
+// src/shared/internal-initiator-marker.ts
+var OMO_INTERNAL_INITIATOR_MARKER = "<!-- OMO_INTERNAL_INITIATOR -->";
+
+// src/shared/system-directive.ts
+var SYSTEM_DIRECTIVE_PREFIX = "[SYSTEM DIRECTIVE: MAGIC-CONTEXT";
+function isSystemDirective(text) {
+  return text.trimStart().startsWith(SYSTEM_DIRECTIVE_PREFIX);
+}
+function removeSystemReminders(text) {
+  return text.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/gi, "").trim();
+}
+
+// src/hooks/magic-context/read-session-formatting.ts
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { createRequire } from "node:module";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+
+// src/shared/commit-detection.ts
+var HASH_HEX = "[0-9a-f]{7,12}";
+var COMMIT_HASH_TEST_PATTERN = new RegExp(`\\b${HASH_HEX}\\b`, "i");
+var COMMIT_VERB_PATTERN = /\b(?:commit(?:ted|ting|s)?|cherry-?pick(?:ed|ing|s)?|merge[ds]?|merging|rebas(?:e|ed|es|ing))\b/i;
+function textMentionsRecentCommit(text) {
+  return COMMIT_HASH_TEST_PATTERN.test(text) && COMMIT_VERB_PATTERN.test(text);
+}
+function createCommitHashExtractPattern() {
+  return new RegExp(`\`?\\b(${HASH_HEX})\\b\`?`, "gi");
+}
+
+// src/hooks/magic-context/read-session-formatting.ts
+var MAX_COMMITS_PER_BLOCK = 5;
+function hasMeaningfulUserText2(parts) {
+  for (const part of parts) {
+    if (part === null || typeof part !== "object")
+      continue;
+    const candidate = part;
+    if (candidate.type !== "text" || typeof candidate.text !== "string")
+      continue;
+    if (candidate.ignored === true)
+      continue;
+    const cleaned = removeSystemReminders(candidate.text).replace(OMO_INTERNAL_INITIATOR_MARKER, "").trim();
+    if (!cleaned)
+      continue;
+    if (isSystemDirective(cleaned))
+      continue;
+    return true;
+  }
+  return false;
+}
+function extractTexts2(parts) {
+  const texts = [];
+  for (const part of parts) {
+    if (part === null || typeof part !== "object")
+      continue;
+    const p = part;
+    if (p.type === "text" && typeof p.text === "string" && p.text.trim().length > 0) {
+      texts.push(p.text.trim());
+    }
+  }
+  return texts;
+}
+function extractToolResultBodyTokens(parts) {
+  let tokens = 0;
+  for (const part of parts) {
+    if (part === null || typeof part !== "object")
+      continue;
+    const p = part;
+    if (p.type !== "tool")
+      continue;
+    const state = p.state;
+    if (!state || typeof state !== "object")
+      continue;
+    const body = state.output ?? state.error;
+    if (body === undefined)
+      continue;
+    const text = typeof body === "string" ? body : JSON.stringify(body);
+    tokens += Math.ceil(text.length / 4);
+  }
+  return tokens;
+}
+function extractToolCallSummaries(parts) {
+  const summaries = [];
+  for (const part of parts) {
+    if (part === null || typeof part !== "object")
+      continue;
+    const p = part;
+    if (p.type !== "tool" || typeof p.tool !== "string")
+      continue;
+    const state = p.state;
+    if (!state || typeof state !== "object")
+      continue;
+    const input = state.input;
+    const metadata = state.metadata;
+    const description = input && typeof input.description === "string" && input.description || metadata && typeof metadata.description === "string" && metadata.description;
+    if (description) {
+      summaries.push(`TC: ${description}`);
+      continue;
+    }
+    const toolName = p.tool;
+    const keyArg = extractKeyArg(toolName, input);
+    summaries.push(keyArg ? `TC: ${toolName}(${keyArg})` : `TC: ${toolName}`);
+  }
+  return summaries;
+}
+function extractKeyArg(_toolName, input) {
+  if (!input)
+    return null;
+  if (typeof input.filePath === "string")
+    return truncateArg(input.filePath);
+  if (typeof input.path === "string")
+    return truncateArg(input.path);
+  if (typeof input.pattern === "string")
+    return truncateArg(input.pattern);
+  if (typeof input.query === "string")
+    return truncateArg(input.query);
+  if (typeof input.symbol === "string")
+    return input.symbol;
+  if (typeof input.module === "string")
+    return input.module;
+  if (typeof input.action === "string")
+    return input.action;
+  return null;
+}
+function truncateArg(value, maxLen = 60) {
+  if (value.length <= maxLen)
+    return value;
+  return `${value.slice(0, maxLen)}…`;
+}
+var TOKENIZER_PACKAGE_DIRS = [
+  ["@cortexkit", "opencode-magic-context"],
+  ["@cortexkit", "pi-magic-context"]
+];
+var tokenizer;
+var tokenizerLoadAttempted = false;
+var tokenizerLoadPromise;
+var tokenizerWarningSent = false;
+var tokenizerEncodingPath;
+var tokenizerSerializedTableBytes;
+function tokenizerPackageRoots() {
+  const cwd = process.cwd();
+  const openCodeCache = join(process.env.XDG_CACHE_HOME ?? join(homedir(), ".cache"), "opencode");
+  const roots = [cwd, openCodeCache];
+  const candidates = [];
+  for (const root of roots) {
+    for (const packageDir of TOKENIZER_PACKAGE_DIRS) {
+      candidates.push(join(root, "node_modules", ...packageDir, "node_modules", "ai-tokenizer"));
+    }
+    candidates.push(join(root, "node_modules", "ai-tokenizer"));
+  }
+  let ancestor = process.argv[1] ? dirname(resolve(process.argv[1])) : cwd;
+  while (true) {
+    candidates.push(join(ancestor, "node_modules", "ai-tokenizer"));
+    const parent = dirname(ancestor);
+    if (parent === ancestor)
+      break;
+    ancestor = parent;
+  }
+  return [...new Set(candidates)];
+}
+function packageImportTarget(value) {
+  if (typeof value === "string")
+    return value;
+  if (!value || typeof value !== "object")
+    return;
+  const conditions = value;
+  return packageImportTarget(conditions.import) ?? packageImportTarget(conditions.default);
+}
+function findTokenizerImportPaths() {
+  for (const packageRoot of tokenizerPackageRoots()) {
+    const packageJsonPath = join(packageRoot, "package.json");
+    if (!existsSync(packageJsonPath))
+      continue;
+    try {
+      const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+      const tokenizerTarget = packageImportTarget(packageJson.exports?.["."]) ?? (typeof packageJson.module === "string" ? packageJson.module : undefined) ?? (typeof packageJson.main === "string" ? packageJson.main : undefined);
+      const encodingTarget = packageImportTarget(packageJson.exports?.["./encoding/claude"]);
+      if (!tokenizerTarget || !encodingTarget)
+        continue;
+      return {
+        tokenizerPath: realpathSync(join(packageRoot, tokenizerTarget)),
+        encodingPath: realpathSync(join(packageRoot, encodingTarget))
+      };
+    } catch {}
+  }
+  return;
+}
+function constructTokenizer(tokenizerModule, claudeEncoding) {
+  const typedModule = tokenizerModule;
+  const Tokenizer = typedModule.default ?? typedModule.Tokenizer;
+  if (!Tokenizer) {
+    throw new Error("ai-tokenizer does not expose a Tokenizer constructor");
+  }
+  return new Tokenizer(claudeEncoding);
+}
+function loadTokenizer() {
+  const requireFromThisModule = createRequire(import.meta.url);
+  const encodingSpecifier = "ai-tokenizer/encoding/" + "claude";
+  tokenizerEncodingPath = requireFromThisModule.resolve(encodingSpecifier);
+  tokenizerSerializedTableBytes = undefined;
+  return constructTokenizer(requireFromThisModule("ai-" + "tokenizer"), requireFromThisModule(encodingSpecifier));
+}
+async function loadTokenizerFromInstalledPackage() {
+  const installedPaths = findTokenizerImportPaths();
+  if (!installedPaths) {
+    throw new Error("ai-tokenizer was not found under the project, runtime, or OpenCode cache node_modules roots");
+  }
+  const [tokenizerModule, claudeEncoding] = await Promise.all([
+    import(pathToFileURL(installedPaths.tokenizerPath).href),
+    import(pathToFileURL(installedPaths.encodingPath).href)
+  ]);
+  tokenizerEncodingPath = installedPaths.encodingPath;
+  tokenizerSerializedTableBytes = undefined;
+  return constructTokenizer(tokenizerModule, claudeEncoding);
+}
+function serializedTokenizerTableBytes(entryPath) {
+  const root = dirname(entryPath);
+  const pending = [entryPath];
+  const visited = new Set;
+  let total = 0;
+  try {
+    while (pending.length > 0) {
+      const nextPath = pending.pop();
+      if (!nextPath)
+        break;
+      const path = realpathSync(nextPath);
+      if (visited.has(path))
+        continue;
+      visited.add(path);
+      total += statSync(path).size;
+      const source = readFileSync(path, "utf8");
+      const localImports = source.matchAll(/(?:require\(|\bfrom\s+|\bimport\()\s*["'](\.\.?\/[^"']+)["']/g);
+      for (const match of localImports) {
+        const specifier = match[1];
+        if (!specifier)
+          continue;
+        const dependency = resolve(dirname(path), specifier);
+        if (dependency.startsWith(root))
+          pending.push(dependency);
+      }
+    }
+    return total;
+  } catch {
+    return null;
+  }
+}
+function getTokenizerNativeMemoryStats() {
+  if (tokenizerSerializedTableBytes === undefined) {
+    tokenizerSerializedTableBytes = tokenizerEncodingPath ? serializedTokenizerTableBytes(tokenizerEncodingPath) : null;
+  }
+  return {
+    loaded: tokenizer !== undefined,
+    loadAttempted: tokenizerLoadAttempted || tokenizerLoadPromise !== undefined,
+    tableBytes: tokenizerSerializedTableBytes,
+    tablePath: tokenizerEncodingPath ?? null
+  };
+}
+function warnTokenizerFallback(error) {
+  if (tokenizerWarningSent)
+    return;
+  tokenizerWarningSent = true;
+  const reason = error instanceof Error ? error.message : String(error);
+  log("[magic-context] ai-tokenizer is unavailable; using approximate character-based token counts for this process. Token budgets, persisted per-message counts, and protected-tail/compartment boundaries may be less accurate until restart:", reason);
+}
+async function preloadTokenizer() {
+  if (tokenizer)
+    return true;
+  if (tokenizerLoadAttempted)
+    return false;
+  if (tokenizerLoadPromise)
+    return tokenizerLoadPromise;
+  tokenizerLoadPromise = (async () => {
+    try {
+      try {
+        tokenizer = loadTokenizer();
+      } catch {
+        tokenizer = await loadTokenizerFromInstalledPackage();
+      }
+      tokenizerLoadAttempted = true;
+      return true;
+    } catch (error) {
+      tokenizerLoadAttempted = true;
+      warnTokenizerFallback(error);
+      return false;
+    } finally {
+      tokenizerLoadPromise = undefined;
+    }
+  })();
+  return tokenizerLoadPromise;
+}
+function getTokenizer() {
+  if (tokenizer || tokenizerLoadAttempted)
+    return tokenizer;
+  tokenizerLoadAttempted = true;
+  try {
+    tokenizer = loadTokenizer();
+  } catch (error) {
+    warnTokenizerFallback(error);
+  }
+  return tokenizer;
+}
+function estimateTokensHeuristically(text) {
+  return Math.ceil(text.length / 3.5);
+}
+var TOKEN_ESTIMATOR_SAMPLE = 'Coverage check: const windows = chunk(text, 0x1f, 512); // ok? "naïve" café 日本語 <EOT> 3.14159 ->  done.';
+var estimatorFingerprintTokenizer;
+var estimatorFingerprint = "";
+function getTokenEstimatorFingerprint() {
+  const activeTokenizer = getTokenizer();
+  if (!activeTokenizer) {
+    return `heuristic:${estimateTokensHeuristically(TOKEN_ESTIMATOR_SAMPLE)}`;
+  }
+  if (estimatorFingerprintTokenizer === activeTokenizer)
+    return estimatorFingerprint;
+  let fingerprint;
+  try {
+    fingerprint = `tokenizer:${activeTokenizer.encode(TOKEN_ESTIMATOR_SAMPLE, "all").length}`;
+  } catch {
+    fingerprint = "tokenizer:sample-unencodable";
+  }
+  estimatorFingerprintTokenizer = activeTokenizer;
+  estimatorFingerprint = fingerprint;
+  return fingerprint;
+}
+function estimateTokens(text) {
+  if (!text)
+    return 0;
+  const activeTokenizer = getTokenizer();
+  if (!activeTokenizer)
+    return estimateTokensHeuristically(text);
+  try {
+    return activeTokenizer.encode(text, "all").length;
+  } catch (error) {
+    tokenizer = undefined;
+    tokenizerLoadAttempted = true;
+    warnTokenizerFallback(error);
+    return estimateTokensHeuristically(text);
+  }
+}
+function normalizeText(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function compactRole(role) {
+  if (role === "assistant")
+    return "A";
+  if (role === "user")
+    return "U";
+  return role.slice(0, 1).toUpperCase() || "M";
+}
+function formatBlock(block) {
+  const range = block.startOrdinal === block.endOrdinal ? `[${block.startOrdinal}]` : `[${block.startOrdinal}-${block.endOrdinal}]`;
+  const commitSuffix = block.commitHashes.length > 0 ? ` commits: ${block.commitHashes.join(", ")}` : "";
+  return `${range} ${block.role}:${commitSuffix} ${block.parts.join(" / ")}`;
+}
+function extractCommitHashes(text) {
+  const hashes = [];
+  const seen = new Set;
+  for (const match of text.matchAll(createCommitHashExtractPattern())) {
+    const hash = match[1]?.toLowerCase();
+    if (!hash || seen.has(hash))
+      continue;
+    seen.add(hash);
+    hashes.push(hash);
+    if (hashes.length >= MAX_COMMITS_PER_BLOCK)
+      break;
+  }
+  return hashes;
+}
+function compactTextForSummary(text, role) {
+  const commitHashes = role === "assistant" ? extractCommitHashes(text) : [];
+  if (commitHashes.length === 0 || !COMMIT_VERB_PATTERN.test(text)) {
+    return { text, commitHashes };
+  }
+  const withoutHashes = text.replace(createCommitHashExtractPattern(), "").replace(/\(\s*\)/g, "").replace(/\s+,/g, ",").replace(/,\s*,+/g, ", ").replace(/\s{2,}/g, " ").replace(/\s+([,.;:])/g, "$1").trim();
+  return {
+    text: withoutHashes.length > 0 ? withoutHashes : text,
+    commitHashes
+  };
+}
+function mergeCommitHashes(existing, next) {
+  if (next.length === 0)
+    return existing;
+  const merged = [...existing];
+  for (const hash of next) {
+    if (merged.includes(hash))
+      continue;
+    merged.push(hash);
+    if (merged.length >= MAX_COMMITS_PER_BLOCK)
+      break;
+  }
+  return merged;
+}
+
+export { textMentionsRecentCommit, OMO_INTERNAL_INITIATOR_MARKER, isSystemDirective, removeSystemReminders, hasMeaningfulUserText2, extractTexts2, extractToolResultBodyTokens, extractToolCallSummaries, getTokenizerNativeMemoryStats, preloadTokenizer, getTokenEstimatorFingerprint, estimateTokens, normalizeText, compactRole, formatBlock, compactTextForSummary, mergeCommitHashes };

package/dist/{index-3bygzk2d.js → index-hybnrwq0.js}

@@ -1,6 +1,11 @@
 import {
+  getHarness,
   getMagicContextLogPath
-} from "./index-s70wtd8k.js";
+} from "./index-q6hef7fh.js";
+
+// src/shared/stale-plugin-build.ts
+import { posix } from "node:path";
+import { fileURLToPath } from "node:url";
 
 // src/shared/logger.ts
 import * as fs from "node:fs";
@@ -53,8 +58,10 @@ var SECRET_QUALIFIERS = new Set([
   "github",
   "huggingface",
   "aws",
-  "azure"
+  "azure",
+  "id"
 ]);
+var UNQUALIFIED_SECRET_SEGMENT_PATTERN = /^(?:password|secret|credential|bearer|authorization)s?$/;
 function isSecretKey(key) {
   const segments = key.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().split(/[._-]+/).filter(Boolean);
   if (segments.length === 0)
@@ -81,6 +88,8 @@ function isSecretKey(key) {
     }
     if (!trailingOk)
       continue;
+    if (UNQUALIFIED_SECRET_SEGMENT_PATTERN.test(seg))
+      return true;
     for (let k = i - 1;k >= 0; k--) {
       const lead = segments[k];
       if (lead && SECRET_QUALIFIERS.has(lead))
@@ -141,6 +150,18 @@ var SECRET_TEXT_PATTERNS = [
     pattern: /\b(Authorization\s*:\s*Bearer\s+)([A-Za-z0-9._~+/=-]{8,})/gi,
     replacement: (_full, prefix) => `${prefix}<REDACTED:bearer>`
   },
+  {
+    pattern: /\b((?:Proxy-)?Authorization\s*:\s*(?:Basic|Digest|Token|Negotiate|NTLM)\s+)([A-Za-z0-9._~+/=-]{4,})/gi,
+    replacement: (_full, prefix) => `${prefix}<REDACTED:authorization>`
+  },
+  {
+    pattern: /\b((?:x-)?(?:api-?key|api-?token|auth-?token|access-?token)\s*:\s*)([^\s'"`,;<>]{6,})/gi,
+    replacement: (full, prefix, value) => isNonSecretScalarValue(value) ? full : `${prefix}<REDACTED:api_key>`
+  },
+  {
+    pattern: /\b([a-z][a-z0-9+.-]*:\/\/[^\s/:@]+:)([^\s/@]+)(@)/gi,
+    replacement: (_full, prefix, _password, at) => `${prefix}<REDACTED:password>${at}`
+  },
   {
     pattern: /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g,
     replacement: "<JWT_REDACTED>"
@@ -349,15 +370,45 @@ function scheduleFlush() {
     flush();
   }, FLUSH_INTERVAL_MS);
 }
-function log(message, data) {
+var lineForwarder = null;
+function setLogLineForwarder(forward) {
+  lineForwarder = forward;
+}
+function writeForwardedLogLine(line) {
   if (isTestEnv)
     return;
   try {
+    buffer.push(line);
+    bufferedBytes += Buffer.byteLength(line);
+    boundBuffer();
+    if (buffer.length >= BUFFER_SIZE_LIMIT)
+      flush();
+    else
+      scheduleFlush();
+  } catch {}
+}
+function log(message, data) {
+  try {
+    let diagnostic = stalePluginBuildDiagnostic(data);
+    if (diagnostic === undefined)
+      diagnostic = stalePluginBuildDiagnostic(message);
+    if (diagnostic === null)
+      return;
+    if (diagnostic !== undefined) {
+      message = diagnostic;
+      data = undefined;
+    }
+    if (isTestEnv)
+      return;
     const timestamp = new Date().toISOString();
     const serialized = data === undefined ? "" : data instanceof Error ? ` ${sanitizeDiagnosticText(`${data.message}${data.stack ? `
 ${data.stack}` : ""}`)}` : ` ${JSON.stringify(sanitizeConfigValue(data))}`;
     const line = `[${timestamp}] ${sanitizeDiagnosticText(message)}${serialized}
 `;
+    if (lineForwarder) {
+      lineForwarder(line);
+      return;
+    }
     buffer.push(line);
     bufferedBytes += Buffer.byteLength(line);
     boundBuffer();
@@ -385,4 +436,118 @@ if (!isTestEnv) {
   process.on("exit", flush);
 }
 
-export { sanitizeDiagnosticText, hasShareabilitySensitiveText, log, sessionLog, getLoggerDiagnostics, flushLogger };
+// src/shared/stale-plugin-build.ts
+var STATE = Symbol.for("magic-context.stale-plugin-build");
+function state() {
+  const globals = globalThis;
+  return globals[STATE] ??= {
+    hosts: new Map,
+    loggedChunks: new Set,
+    notified: false
+  };
+}
+function absolutePath(value) {
+  let path = value;
+  if (path.startsWith("file:")) {
+    try {
+      path = fileURLToPath(path);
+    } catch {
+      return;
+    }
+  }
+  path = path.replaceAll("\\", "/").replace(/^\/(?=[A-Za-z]:\/)/, "");
+  if (!path.startsWith("/") && !/^[A-Za-z]:\//.test(path))
+    return;
+  path = posix.normalize(path);
+  return /^[A-Za-z]:\//.test(path) ? path.toLowerCase() : path;
+}
+function distForModule(moduleUrl) {
+  const path = absolutePath(moduleUrl);
+  if (!path)
+    return;
+  const dist = path.lastIndexOf("/dist/");
+  return dist < 0 ? undefined : path.slice(0, dist + "/dist".length);
+}
+function stalePluginBuildGuidance(harness) {
+  return harness === "pi" || harness === "omp" ? "Magic Context was rebuilt while this Pi was running; type /reload to load the new build" : "Magic Context was rebuilt while this OpenCode host was running; restart the host to load the new build";
+}
+function deliverNotice(host) {
+  const current = state();
+  if (current.notified || !current.pendingNotice || !host.notify)
+    return;
+  current.notified = true;
+  try {
+    Promise.resolve(host.notify(current.pendingNotice)).catch(() => {});
+  } catch {}
+}
+function registerStalePluginBuildHost(options) {
+  const dist = distForModule(options.moduleUrl);
+  if (!dist)
+    return;
+  const host = { ...options, dist };
+  state().hosts.set(dist, host);
+  deliverNotice(host);
+}
+function classifyStalePluginBuild(error) {
+  if (error instanceof StalePluginBuildError)
+    return error.build;
+  const message = error instanceof Error ? error.message : String(error);
+  const missing = message.match(/(?:Cannot find module|ENOENT reading)\s+(['"])(.*?)\1/);
+  if (!missing)
+    return null;
+  let chunk = absolutePath(missing[2]);
+  if (!chunk && /^\.\.?[/\\]/.test(missing[2])) {
+    const importer = message.slice((missing.index ?? 0) + missing[0].length).match(/(?:imported from|from)\s+(?:['"]([^'"]+)['"]|([^\n]+))/);
+    const from = importer && absolutePath((importer[1] ?? importer[2]).trim());
+    if (from)
+      chunk = absolutePath(posix.join(posix.dirname(from), missing[2].replaceAll("\\", "/")));
+  }
+  if (!chunk)
+    return null;
+  for (const host of state().hosts.values()) {
+    if (chunk.startsWith(`${host.dist}/`)) {
+      return { chunk, guidance: stalePluginBuildGuidance(host.harness) };
+    }
+  }
+  const ownDist = distForModule(import.meta.url);
+  return ownDist && chunk.startsWith(`${ownDist}/`) ? { chunk, guidance: stalePluginBuildGuidance(getHarness()) } : null;
+}
+
+class StalePluginBuildError extends Error {
+  build;
+  constructor(build) {
+    super(build.guidance);
+    this.build = build;
+    this.name = "StalePluginBuildError";
+  }
+}
+function stalePluginBuildDiagnostic(error) {
+  const pending = state().pendingNotice;
+  const message = error instanceof Error ? error.message : typeof error === "string" ? error : "";
+  if (pending && message.includes(pending))
+    return null;
+  const build = classifyStalePluginBuild(error);
+  if (!build)
+    return;
+  const current = state();
+  current.pendingNotice ??= build.guidance;
+  for (const host of current.hosts.values())
+    deliverNotice(host);
+  if (current.loggedChunks.has(build.chunk))
+    return null;
+  current.loggedChunks.add(build.chunk);
+  return `[magic-context] stale plugin build: missing ${build.chunk.replace(/[\r\n]/g, " ")}; ${build.guidance}`;
+}
+async function importPluginModule(load) {
+  try {
+    return await load();
+  } catch (error) {
+    const build = classifyStalePluginBuild(error);
+    if (!build)
+      throw error;
+    log("[magic-context] lazy import failed", error);
+    throw new StalePluginBuildError(build);
+  }
+}
+
+export { sanitizeDiagnosticText, hasShareabilitySensitiveText, registerStalePluginBuildHost, classifyStalePluginBuild, importPluginModule, setLogLineForwarder, writeForwardedLogLine, log, sessionLog, getLoggerDiagnostics, flushLogger };

package/dist/{index-jqcbs2k1.js → index-mc22ayvf.js}

@@ -1,6 +1,6 @@
 import {
   resolveDreamerTaskModel2
-} from "./index-7k55qm8a.js";
+} from "./index-sfpzqvdz.js";
 
 // src/features/magic-context/dreamer/task-registry.ts
 var CANONICAL_DREAM_TASKS = [
@@ -18,9 +18,9 @@ var CANONICAL_DREAM_TASKS = [
   "refresh-primers"
 ];
 var DREAM_TOOL_LOOP_TOKEN_BUDGETS = {
-  "map-memories": 1500000,
-  verify: 1700000,
-  "verify-broad": 1700000,
+  "map-memories": 2500000,
+  verify: 2500000,
+  "verify-broad": 3000000,
   curate: 1500000,
   retrospective: 300000,
   "maintain-docs": 1600000,
@@ -177,4 +177,23 @@ function userMemoryCollectionEnabled2(dreamer) {
   const schedule = dreamer?.tasks?.["review-user-memories"]?.schedule;
   return typeof schedule === "string" && schedule.trim() !== "";
 }
-export { CANONICAL_DREAM_TASKS, DREAM_TASK_CAPABILITIES, toolLoopDreamTasks, formatUnsupportedDreamTasks, formatDreamTaskBacklogs, formatDreamTaskFailures, processedDreamTaskItems, leaseKindFor, leaseKeyFor, isCanonicalDreamTask, compareTaskOrder, buildDreamTaskRuntimeConfigs2, userMemoryCollectionEnabled2 };
+function userMemoryPromotionThreshold2(dreamer) {
+  return dreamer?.tasks?.["review-user-memories"]?.promotion_threshold ?? 3;
+}
+function dreamTaskScheduled2(dreamer, task) {
+  const schedule = dreamer?.tasks?.[task]?.schedule;
+  return typeof schedule === "string" && schedule.trim() !== "";
+}
+function enabledDreamTasks2(dreamer) {
+  if (!dreamer?.tasks)
+    return [];
+  return CANONICAL_DREAM_TASKS.filter((t) => dreamer.tasks[t]?.schedule?.trim());
+}
+function summarizeDreamSchedule2(dreamer) {
+  const enabled = enabledDreamTasks2(dreamer);
+  if (enabled.length === 0)
+    return "manual-only";
+  return enabled.map((t) => `${t} ${dreamer?.tasks[t]?.schedule}`).join(", ");
+}
+
+export { CANONICAL_DREAM_TASKS, DREAM_TASK_CAPABILITIES, toolLoopDreamTasks, formatUnsupportedDreamTasks, formatDreamTaskBacklogs, formatDreamTaskFailures, processedDreamTaskItems, leaseKindFor, leaseKeyFor, isCanonicalDreamTask, compareTaskOrder, buildDreamTaskRuntimeConfigs2, userMemoryCollectionEnabled2, userMemoryPromotionThreshold2, dreamTaskScheduled2, enabledDreamTasks2, summarizeDreamSchedule2 };