@cortexkit/pi-magic-context 0.44.4 → 0.45.0

package/dist/index-2pbbk3en.js

@@ -0,0 +1,410 @@
+// ../plugin/src/shared/sqlite.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var reportSlowPrivilegedWrite;
+function registerSlowWriteReporter(reporter) {
+  reportSlowPrivilegedWrite = reporter;
+}
+var sqliteDiagnosticSink;
+function registerSqliteDiagnosticSink(sink) {
+  sqliteDiagnosticSink = sink;
+}
+function reportSqliteDiagnostic(message) {
+  try {
+    sqliteDiagnosticSink?.(`[magic-context] ${message}`);
+  } catch {}
+}
+function detectSqliteRuntime() {
+  const hasBunVersion = typeof process !== "undefined" && typeof process.versions?.bun === "string";
+  const hasBunGlobal = typeof globalThis !== "undefined" && typeof globalThis.Bun !== "undefined";
+  return hasBunVersion || hasBunGlobal ? "Bun" : "Node.js";
+}
+var bunSpec = "bun:" + "sqlite";
+var nodeSpec = "node:" + "sqlite";
+async function importSqliteModule(specifier) {
+  return await import(specifier);
+}
+function isModuleNotFoundError(error, specifier) {
+  const candidate = error;
+  const code = typeof candidate?.code === "string" ? candidate.code : "";
+  const name = typeof candidate?.name === "string" ? candidate.name : "";
+  const message = error instanceof Error ? error.message : String(error ?? "");
+  const details = `${code} ${name} ${message}`.toLowerCase();
+  const mentionsSpecifier = details.includes(specifier.toLowerCase());
+  if (!mentionsSpecifier)
+    return false;
+  return code === "ERR_MODULE_NOT_FOUND" || code === "ERR_UNKNOWN_BUILTIN_MODULE" || code === "MODULE_NOT_FOUND" || name === "ResolveMessage" || details.includes("module not found") || details.includes("cannot find module") || details.includes("cannot find package") || details.includes("no such built-in module");
+}
+
+class SqliteRuntimeUnavailableError extends Error {
+  runtime;
+  specifier;
+  constructor(runtime, specifier, cause) {
+    const requirement = specifier === nodeSpec ? "Requires Node.js >= 24, or Bun with bun:sqlite — this Bun build lacks node:sqlite." : "Requires Bun with bun:sqlite, or Node.js >= 24 — this Bun build lacks bun:sqlite.";
+    super(`Magic Context detected ${runtime}, but could not load ${specifier}. ${requirement}`, { cause });
+    this.name = "SqliteRuntimeUnavailableError";
+    this.runtime = runtime;
+    this.specifier = specifier;
+  }
+}
+async function loadSqliteModule(runtime = detectSqliteRuntime(), importer = importSqliteModule) {
+  const specifier = runtime === "Bun" ? bunSpec : nodeSpec;
+  try {
+    return await importer(specifier);
+  } catch (error) {
+    if (isModuleNotFoundError(error, specifier)) {
+      throw new SqliteRuntimeUnavailableError(runtime, specifier, error);
+    }
+    throw error;
+  }
+}
+var detectedRuntime = detectSqliteRuntime();
+var isBun = detectedRuntime === "Bun";
+var sqliteModule = await loadSqliteModule(detectedRuntime);
+var DatabaseImpl = isBun ? sqliteModule.Database : buildNodeSqliteDatabaseClass(sqliteModule.DatabaseSync);
+var trackedSqliteConnections = new Map;
+var nextSqliteConnectionSequence = 1;
+function installTransactionRouting(db, readonly) {
+  const nativeExec = db.exec.bind(db);
+  Object.defineProperty(db, "exec", {
+    configurable: true,
+    writable: true,
+    value: (sql) => {
+      if (/^\s*BEGIN\s+(?:IMMEDIATE|EXCLUSIVE)(?:\s+TRANSACTION)?\s*;?\s*$/i.test(sql)) {
+        openWriterTransactions.delete(db);
+        if (transformPassScope.getStore()?.active || backgroundWriterScope.getStore())
+          acquireShort(db, () => nativeExec(sql), sql.trim());
+        else
+          nativeExec(sql);
+        return db;
+      }
+      if (WRITER_TRANSACTION_END.test(sql) && openWriterTransactions.has(db))
+        return endWriterTransaction(db, () => nativeExec(sql), sql);
+      if (!/^\s*(?:SELECT|EXPLAIN|PRAGMA|COMMIT|END|ROLLBACK|SAVEPOINT|RELEASE)\b/i.test(sql))
+        return withAutocommitTimeout(db, () => nativeExec(sql));
+      return nativeExec(sql);
+    }
+  });
+  const nativePrepare = db.prepare.bind(db);
+  Object.defineProperty(db, "prepare", {
+    configurable: true,
+    writable: true,
+    value: (sql) => {
+      const statement = nativePrepare(sql);
+      if (!readonly && !/^\s*(?:SELECT|EXPLAIN|PRAGMA)\b/i.test(sql)) {
+        for (const method of ["run", "get", "all"]) {
+          const execute = statement[method].bind(statement);
+          Object.defineProperty(statement, method, {
+            configurable: true,
+            value: (...args) => withAutocommitTimeout(db, () => execute(...args))
+          });
+        }
+      }
+      return statement;
+    }
+  });
+  Object.defineProperty(db, "transaction", {
+    configurable: true,
+    writable: true,
+    value: (fn) => {
+      const make = (mode) => function(...args) {
+        const nested = isInTransaction(db);
+        const savepoint = "mc_tx_sp";
+        db.exec(nested ? `SAVEPOINT ${savepoint}` : `BEGIN ${mode}`);
+        try {
+          const result = fn.apply(this, args);
+          db.exec(nested ? `RELEASE ${savepoint}` : "COMMIT");
+          return result;
+        } catch (error) {
+          if (isInTransaction(db)) {
+            if (nested) {
+              db.exec(`ROLLBACK TO ${savepoint}`);
+              db.exec(`RELEASE ${savepoint}`);
+            } else
+              db.exec("ROLLBACK");
+          }
+          throw error;
+        }
+      };
+      const defaultTransaction = make(readonly ? "DEFERRED" : "IMMEDIATE");
+      const variants = {
+        default: defaultTransaction,
+        deferred: make("DEFERRED"),
+        immediate: make("IMMEDIATE"),
+        exclusive: make("EXCLUSIVE"),
+        database: db
+      };
+      for (const transaction of [
+        variants.default,
+        variants.deferred,
+        variants.immediate,
+        variants.exclusive
+      ]) {
+        Object.assign(transaction, variants);
+      }
+      return defaultTransaction;
+    }
+  });
+}
+function trackSqliteConnection(db, filename, options) {
+  const originalClose = db.close.bind(db);
+  const sequence = nextSqliteConnectionSequence++;
+  const metadata = {
+    sequence,
+    filename: typeof filename === "string" ? filename : Buffer.isBuffer(filename) ? "<buffer>" : ":memory:",
+    readonly: Boolean(options) && typeof options === "object" && (options.readonly === true || options.readOnly === true)
+  };
+  installTransactionRouting(db, metadata.readonly);
+  Object.defineProperty(db, "close", {
+    configurable: true,
+    value: (...args) => {
+      try {
+        return originalClose(...args);
+      } finally {
+        trackedSqliteConnections.delete(sequence);
+      }
+    }
+  });
+  trackedSqliteConnections.set(sequence, {
+    ...metadata,
+    reference: new WeakRef(db)
+  });
+  return db;
+}
+var TrackedDatabase = new Proxy(DatabaseImpl, {
+  construct(target, args) {
+    const db = Reflect.construct(target, args, target);
+    return trackSqliteConnection(db, args[0], args[1]);
+  }
+});
+function buildNodeSqliteDatabaseClass(DatabaseSync) {
+
+  class NodeSqliteDatabase extends DatabaseSync {
+    constructor(filename, options) {
+      const translated = { ...options };
+      if (options && "readonly" in options) {
+        translated.readOnly = options.readonly;
+        delete translated.readonly;
+      }
+      super(typeof filename === "string" ? filename : ":memory:", translated);
+    }
+    prepare(sql) {
+      const stmt = super.prepare(sql);
+      for (const method of ["run", "get", "all"]) {
+        const original = stmt[method].bind(stmt);
+        stmt[method] = (...args) => args.length === 1 && Array.isArray(args[0]) ? original(...args[0]) : original(...args);
+      }
+      return stmt;
+    }
+  }
+  return NodeSqliteDatabase;
+}
+var Database = TrackedDatabase;
+function pragmaValue(db, name) {
+  const row = db.prepare(`PRAGMA ${name}`).get();
+  if (!row)
+    return;
+  return row[name] ?? Object.values(row)[0];
+}
+function pragmaNumber(db, name) {
+  try {
+    const value = pragmaValue(db, name);
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+var privilegeDepth = new WeakMap;
+var transformPassScope = new AsyncLocalStorage;
+var admissionScope = new AsyncLocalStorage;
+var backgroundWriterScope = new AsyncLocalStorage;
+function withSqliteBackgroundWriter(operation) {
+  return backgroundWriterScope.run(true, operation);
+}
+function withSqliteTransformPass(operation) {
+  const existing = transformPassScope.getStore();
+  if (existing?.active)
+    return operation();
+  const lease = { active: true, remainingWaitMs: FOREGROUND_IN_PASS_BUSY_TIMEOUT_MS };
+  return transformPassScope.run(lease, () => {
+    try {
+      const result = operation();
+      if (result && typeof result.then === "function") {
+        return Promise.resolve(result).finally(() => {
+          lease.active = false;
+        });
+      }
+      lease.active = false;
+      return result;
+    } catch (error) {
+      lease.active = false;
+      throw error;
+    }
+  });
+}
+function withoutSqliteTransformPass(operation) {
+  return transformPassScope.run(undefined, operation);
+}
+function isTransientSqliteError(error) {
+  if (!error || typeof error !== "object")
+    return false;
+  const value = error;
+  return typeof value.code === "string" && /^(SQLITE_BUSY|SQLITE_LOCKED)(_|$)/.test(value.code) || typeof value.errcode === "number" && [5, 6].includes(value.errcode & 255);
+}
+
+class SqliteAcquisitionBusyError extends Error {
+  code = "SQLITE_BUSY";
+  stage;
+  constructor(cause, stage = "BEGIN IMMEDIATE") {
+    super("SQLite writer acquisition remained busy", { cause });
+    this.name = "SqliteAcquisitionBusyError";
+    this.stage = stage;
+  }
+}
+var SHORT_BUSY_TIMEOUT_MS = 25;
+var FOREGROUND_IN_PASS_BUSY_TIMEOUT_MS = 250;
+var SLOW_WRITER_LOG_MS = 250;
+var WRITER_TRANSACTION_END = /^\s*(?:COMMIT|END|ROLLBACK)(?:\s+TRANSACTION)?\s*;?\s*$/i;
+var writerAcquisitionScope = new AsyncLocalStorage;
+var openWriterTransactions = new WeakMap;
+function foregroundWaitLease() {
+  const lease = transformPassScope.getStore();
+  return lease?.active && !admissionScope.getStore() && !backgroundWriterScope.getStore() ? lease : undefined;
+}
+function withAutocommitTimeout(db, operation) {
+  const lease = foregroundWaitLease();
+  if (isInTransaction(db) || !lease && !backgroundWriterScope.getStore())
+    return operation();
+  const previous = pragmaNumber(db, "busy_timeout");
+  db.exec(`PRAGMA busy_timeout=${lease ? Math.floor(lease.remainingWaitMs) : SHORT_BUSY_TIMEOUT_MS}`);
+  const started = performance.now();
+  try {
+    return operation();
+  } catch (error) {
+    if (lease && isTransientSqliteError(error))
+      throw new SqliteAcquisitionBusyError(error, "autocommit");
+    throw error;
+  } finally {
+    if (lease)
+      lease.remainingWaitMs = Math.max(0, lease.remainingWaitMs - (performance.now() - started));
+    if (previous !== null)
+      db.exec(`PRAGMA busy_timeout=${previous}`);
+  }
+}
+function acquireShort(db, acquire, site) {
+  const started = performance.now();
+  const previous = pragmaNumber(db, "busy_timeout");
+  const outer = writerAcquisitionScope.getStore();
+  const owner = outer && !outer.claimed ? outer : undefined;
+  if (owner)
+    owner.claimed = true;
+  const writerSite = owner?.site ?? site;
+  const lane = owner?.lane ?? (transformPassScope.getStore()?.active ? "foreground" : "background");
+  let acquiredAt;
+  try {
+    const lease = foregroundWaitLease();
+    const timeout = lease ? Math.floor(lease.remainingWaitMs) : SHORT_BUSY_TIMEOUT_MS;
+    db.exec(`PRAGMA busy_timeout=${timeout}`);
+    acquire();
+    acquiredAt = performance.now();
+  } catch (error) {
+    if (transformPassScope.getStore()?.active && isTransientSqliteError(error))
+      throw new SqliteAcquisitionBusyError(error, site);
+    throw error;
+  } finally {
+    const attemptMs = (acquiredAt ?? performance.now()) - started;
+    const lease = foregroundWaitLease();
+    if (lease)
+      lease.remainingWaitMs = Math.max(0, lease.remainingWaitMs - attemptMs);
+    if (previous !== null)
+      db.exec(`PRAGMA busy_timeout=${previous}`);
+    if (acquiredAt !== undefined) {
+      openWriterTransactions.set(db, {
+        site: writerSite,
+        lane,
+        acquireMs: acquiredAt - (owner?.startedAt ?? started),
+        attempts: owner?.attempts ?? 1,
+        acquiredAt
+      });
+    } else if (attemptMs >= SLOW_WRITER_LOG_MS) {
+      reportSqliteDiagnostic(`sqlite writer site=${writerSite} lane=${lane} acquire_ms=${Math.round(attemptMs)} attempts=${owner?.attempts ?? 1} outcome=busy`);
+    }
+  }
+}
+function endWriterTransaction(db, end, sql) {
+  let ended = false;
+  try {
+    const result = end();
+    ended = true;
+    return result;
+  } finally {
+    const open = openWriterTransactions.get(db);
+    if (open && !isInTransaction(db)) {
+      openWriterTransactions.delete(db);
+      const holdMs = performance.now() - open.acquiredAt;
+      if (open.acquireMs >= SLOW_WRITER_LOG_MS || holdMs >= SLOW_WRITER_LOG_MS) {
+        const outcome = /^\s*ROLLBACK/i.test(sql) ? "rolled_back" : ended ? "committed" : "failed";
+        reportSqliteDiagnostic(`sqlite writer site=${open.site} lane=${open.lane} acquire_ms=${Math.round(open.acquireMs)} hold_ms=${Math.round(holdMs)} attempts=${open.attempts} outcome=${outcome}`);
+      }
+    }
+  }
+}
+function isInTransaction(db) {
+  const candidate = db;
+  return candidate.inTransaction === true || candidate.isTransaction === true;
+}
+function withPrivilegedWriter(db, operation) {
+  const previousDepth = privilegeDepth.get(db) ?? 0;
+  const nested = isInTransaction(db);
+  const savepoint = "mc_privilege_scope";
+  let transactionStartedAt;
+  if (nested) {
+    db.exec(`SAVEPOINT ${savepoint}`);
+  } else {
+    try {
+      db.exec("BEGIN IMMEDIATE");
+    } catch (error) {
+      if (transformPassScope.getStore()?.active && isTransientSqliteError(error))
+        throw new SqliteAcquisitionBusyError(error);
+      throw error;
+    }
+    transactionStartedAt = performance.now();
+  }
+  privilegeDepth.set(db, previousDepth + 1);
+  try {
+    db.prepare("INSERT INTO context_privilege_state(id, enabled) VALUES (1, 1) ON CONFLICT(id) DO UPDATE SET enabled = 1").run();
+    const result = operation();
+    if (previousDepth === 0) {
+      db.prepare("UPDATE context_privilege_state SET enabled = 0 WHERE id = 1").run();
+    }
+    if (nested) {
+      db.exec(`RELEASE ${savepoint}`);
+    } else {
+      db.exec("COMMIT");
+      if (transactionStartedAt !== undefined) {
+        reportSlowPrivilegedWrite?.("privileged_writer", transactionStartedAt);
+      }
+    }
+    if (previousDepth > 0)
+      privilegeDepth.set(db, previousDepth);
+    else
+      privilegeDepth.delete(db);
+    return result;
+  } catch (error) {
+    try {
+      if (nested) {
+        db.exec(`ROLLBACK TO ${savepoint}`);
+        db.exec(`RELEASE ${savepoint}`);
+      } else {
+        db.exec("ROLLBACK");
+      }
+    } finally {
+      if (previousDepth > 0)
+        privilegeDepth.set(db, previousDepth);
+      else
+        privilegeDepth.delete(db);
+    }
+    throw error;
+  }
+}
+
+export { registerSlowWriteReporter, registerSqliteDiagnosticSink, detectSqliteRuntime, Database, withSqliteBackgroundWriter, withSqliteTransformPass, withoutSqliteTransformPass, isTransientSqliteError, withPrivilegedWriter };

package/dist/index-4d3cba70.js

@@ -0,0 +1,10 @@
+// ../plugin/src/shared/storage-permissions.ts
+var enforcePrivateStoragePermissions = true;
+function setStoragePrivatePermissionEnforcement(enforce) {
+  enforcePrivateStoragePermissions = enforce;
+}
+function shouldEnforcePrivateStoragePermissions() {
+  return enforcePrivateStoragePermissions;
+}
+
+export { setStoragePrivatePermissionEnforcement, shouldEnforcePrivateStoragePermissions };

package/dist/{index-59dmj4zs.js → index-7n8gb6j3.js}

@@ -163,8 +163,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)
@@ -191,6 +193,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))
@@ -251,6 +255,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>"
@@ -317,6 +333,122 @@ function sanitizeConfigValue(value, keyPath = []) {
   return value;
 }
 
+// ../plugin/src/shared/stale-plugin-build.ts
+import { posix } from "node:path";
+import { fileURLToPath } from "node:url";
+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);
+  }
+}
+
 // ../plugin/src/shared/logger.ts
 var isTestEnv = false;
 var buffer = [];
@@ -459,15 +591,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();
@@ -488,4 +650,4 @@ if (!isTestEnv) {
   process.on("exit", flush);
 }
 
-export { setHarness, getHarness, harnessOwnsOpenCodeStore, getDataDir, ensureCortexKitArtifactGitignore, getProjectMagicContextHistorianDir, getMagicContextStorageDir, getLegacyOpenCodeMagicContextStorageDir, sanitizeDiagnosticText, hasShareabilitySensitiveText, log, sessionLog, flushLogger };
+export { setHarness, getHarness, harnessOwnsOpenCodeStore, getDataDir, ensureCortexKitArtifactGitignore, getProjectMagicContextHistorianDir, getMagicContextStorageDir, getLegacyOpenCodeMagicContextStorageDir, sanitizeDiagnosticText, hasShareabilitySensitiveText, registerStalePluginBuildHost, classifyStalePluginBuild, importPluginModule, setLogLineForwarder, writeForwardedLogLine, log, sessionLog, flushLogger };

package/dist/{index-97e5fzy3.js → index-7s5yk3za.js}

@@ -1,6 +1,6 @@
 import {
   log
-} from "./index-59dmj4zs.js";
+} from "./index-7n8gb6j3.js";
 
 // ../plugin/src/shared/write-transaction-timing.ts
 var SLOW_WRITE_TRANSACTION_THRESHOLD_MS = 1000;