@cortexkit/opencode-magic-context 0.44.4 → 0.45.0

package/dist/v2/server-5317ykaf.js

@@ -0,0 +1,40 @@
+import {
+  log
+} from "./server-ckpc8pxy.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$/;
+function isDefaultSessionTitle2(title) {
+  return DEFAULT_TITLE_RE.test(title);
+}
+async function readSessionTitle(client, sessionId) {
+  try {
+    const c = client;
+    if (typeof c.session?.get !== "function")
+      return null;
+    const raw = await Promise.resolve(c.session.get({ path: { id: sessionId } }));
+    const obj = raw;
+    const title = obj && typeof obj === "object" ? obj.data?.title ?? obj.title : undefined;
+    return typeof title === "string" ? title : null;
+  } catch {
+    return null;
+  }
+}
+async function waitForSafeNotificationTarget2(client, sessionId, options) {
+  const attempts = Math.max(1, options?.attempts ?? 4);
+  const delayMs = options?.delayMs ?? 15000;
+  for (let attempt = 0;attempt < attempts; attempt += 1) {
+    const title = await readSessionTitle(client, sessionId);
+    if (title === null)
+      return "safe";
+    if (!isDefaultSessionTitle2(title))
+      return "safe";
+    if (attempt < attempts - 1) {
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+  }
+  log(`[magic-context] notification skipped: session ${sessionId} still has its default title (would suppress title generation); will retry on a later startup`);
+  return "skip";
+}
+
+export { isDefaultSessionTitle2, waitForSafeNotificationTarget2 };

package/dist/v2/server-a4m2b1yv.js

@@ -0,0 +1,530 @@
+// src/shared/sqlite.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+import { statSync } from "node:fs";
+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;
+  }
+}
+function pragmaString(db, name) {
+  try {
+    const value = pragmaValue(db, name);
+    return typeof value === "string" ? value : null;
+  } catch {
+    return null;
+  }
+}
+function sqliteSidecarBytes(filename, suffix) {
+  if (filename === ":memory:" || filename === "<buffer>")
+    return 0;
+  try {
+    return statSync(`${filename}${suffix}`).size;
+  } catch (error) {
+    return error.code === "ENOENT" ? 0 : null;
+  }
+}
+function fts5TableCount(db) {
+  try {
+    const row = db.prepare("SELECT COUNT(*) AS count FROM sqlite_master WHERE type = 'table' AND sql LIKE '%USING fts5%'").get();
+    return typeof row?.count === "number" ? row.count : null;
+  } catch {
+    return null;
+  }
+}
+function getSqliteMemoryStats() {
+  const connections = [];
+  for (const [sequence, tracked] of trackedSqliteConnections) {
+    const db = tracked.reference.deref();
+    if (!db) {
+      trackedSqliteConnections.delete(sequence);
+      continue;
+    }
+    const pageSize = pragmaNumber(db, "page_size");
+    const cacheSize = pragmaNumber(db, "cache_size");
+    const cacheSizeUnit = cacheSize === null ? null : cacheSize < 0 ? "kib" : "pages";
+    const cacheUpperBoundBytes = cacheSize === null ? null : cacheSize < 0 ? Math.abs(cacheSize) * 1024 : pageSize === null ? null : cacheSize * pageSize;
+    connections.push({
+      sequence: tracked.sequence,
+      filename: tracked.filename,
+      readonly: tracked.readonly,
+      pageSize,
+      pageCount: pragmaNumber(db, "page_count"),
+      freelistCount: pragmaNumber(db, "freelist_count"),
+      cacheSize,
+      cacheSizeUnit,
+      cacheUpperBoundBytes,
+      mmapSizeBytes: pragmaNumber(db, "mmap_size"),
+      walFileBytes: sqliteSidecarBytes(tracked.filename, "-wal"),
+      shmFileBytes: sqliteSidecarBytes(tracked.filename, "-shm"),
+      fts5TableCount: fts5TableCount(db),
+      journalMode: pragmaString(db, "journal_mode")
+    });
+  }
+  const sumKnown = (select) => connections.reduce((sum, connection) => sum + (select(connection) ?? 0), 0);
+  return {
+    connectionCount: connections.length,
+    cacheUpperBoundBytes: sumKnown((connection) => connection.cacheUpperBoundBytes),
+    mmapUpperBoundBytes: sumKnown((connection) => connection.mmapSizeBytes),
+    walFileBytes: sumKnown((connection) => connection.walFileBytes),
+    shmFileBytes: sumKnown((connection) => connection.shmFileBytes),
+    sqliteStatusApi: "unavailable",
+    connections
+  };
+}
+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 FOREGROUND_ACQUISITION_BUDGET_MS = 16500;
+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}`);
+      }
+    }
+  }
+}
+async function beginSqliteWriterAsync(db, site) {
+  const started = performance.now();
+  let attempts = 0;
+  for (;; ) {
+    attempts++;
+    try {
+      const acquisition = {
+        site,
+        lane: "background",
+        startedAt: started,
+        attempts,
+        claimed: false
+      };
+      writerAcquisitionScope.run(acquisition, () => withSqliteBackgroundWriter(() => db.exec("BEGIN IMMEDIATE")));
+      return performance.now();
+    } catch (error) {
+      if (!isTransientSqliteError(error))
+        throw error;
+      const elapsed = performance.now() - started;
+      if (elapsed >= FOREGROUND_ACQUISITION_BUDGET_MS) {
+        reportSqliteDiagnostic(`sqlite writer site=${site} lane=background acquire_ms=${Math.round(elapsed)} attempts=${attempts} outcome=busy`);
+        throw error;
+      }
+      await new Promise((resolve) => setTimeout(resolve, Math.min(attempts === 1 ? 500 : 1000, FOREGROUND_ACQUISITION_BUDGET_MS - elapsed)));
+    }
+  }
+}
+async function withAsyncPrivilegedWriter(db, operation) {
+  const started = performance.now();
+  let attempts = 0;
+  for (;; ) {
+    attempts++;
+    try {
+      const acquisition = {
+        site: "privileged_writer",
+        lane: "foreground",
+        startedAt: started,
+        attempts,
+        claimed: false
+      };
+      return admissionScope.run(true, () => withSqliteTransformPass(() => writerAcquisitionScope.run(acquisition, () => withPrivilegedWriter(db, operation))));
+    } catch (error) {
+      if (!(error instanceof SqliteAcquisitionBusyError))
+        throw error;
+      const elapsed = performance.now() - started;
+      if (elapsed >= FOREGROUND_ACQUISITION_BUDGET_MS) {
+        reportSqliteDiagnostic(`sqlite writer site=privileged_writer lane=foreground acquire_ms=${Math.round(elapsed)} attempts=${attempts} outcome=busy`);
+        throw error;
+      }
+      await new Promise((resolve) => setTimeout(resolve, Math.min(attempts === 1 ? 500 : 1000, FOREGROUND_ACQUISITION_BUDGET_MS - elapsed)));
+    }
+  }
+}
+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, getSqliteMemoryStats, withSqliteBackgroundWriter, withSqliteTransformPass, withoutSqliteTransformPass, isTransientSqliteError, SqliteAcquisitionBusyError, beginSqliteWriterAsync, withAsyncPrivilegedWriter, withPrivilegedWriter };

package/dist/v2/server-avwt563y.js

@@ -0,0 +1,62 @@
+// src/shared/harness-provider-map.ts
+var CANONICAL_TO_PI_PROVIDER = {
+  openai: "openai-codex",
+  google: "google-antigravity"
+};
+var PI_TO_CANONICAL_PROVIDER = {
+  "openai-codex": "openai",
+  "google-antigravity": "google"
+};
+var CANONICAL_TO_OMP_PROVIDER = {
+  openai: "openai-codex",
+  google: "google-antigravity",
+  opencode: "opencode-zen"
+};
+var OMP_TO_CANONICAL_PROVIDER = {
+  "openai-codex": "openai",
+  "google-antigravity": "google",
+  "opencode-zen": "opencode"
+};
+var CANONICAL_MODEL_IDENTITY_ALIASES = {
+  "github-copilot/gpt-6-astra": "openai/gpt-6-astra"
+};
+function remapProviderPrefix(ref, map) {
+  if (typeof ref !== "string")
+    return ref;
+  const slash = ref.indexOf("/");
+  if (slash <= 0)
+    return ref;
+  const provider = ref.slice(0, slash);
+  if (!Object.hasOwn(map, provider))
+    return ref;
+  return `${map[provider]}${ref.slice(slash)}`;
+}
+function canonicalModelIdentity(ref) {
+  const harnessCanonical = piModelRefToCanonical(ompModelRefToCanonical(ref));
+  return CANONICAL_MODEL_IDENTITY_ALIASES[harnessCanonical.toLowerCase()] ?? harnessCanonical;
+}
+function piModelRefToCanonical(ref) {
+  return remapProviderPrefix(ref, PI_TO_CANONICAL_PROVIDER);
+}
+function resolveModelRefForPi(ref) {
+  return remapProviderPrefix(piModelRefToCanonical(ref), CANONICAL_TO_PI_PROVIDER);
+}
+function modelRefLookupOrder(ref) {
+  const canonical = piModelRefToCanonical(ompModelRefToCanonical(ref));
+  return [
+    ...new Set([
+      canonical,
+      ref,
+      resolveModelRefForPi(canonical),
+      resolveModelRefForOmp(canonical)
+    ])
+  ];
+}
+function ompModelRefToCanonical(ref) {
+  return remapProviderPrefix(ref, OMP_TO_CANONICAL_PROVIDER);
+}
+function resolveModelRefForOmp(ref) {
+  return remapProviderPrefix(ompModelRefToCanonical(ref), CANONICAL_TO_OMP_PROVIDER);
+}
+
+export { canonicalModelIdentity, piModelRefToCanonical, modelRefLookupOrder };