@cortexkit/pi-magic-context 0.48.0 → 0.49.0

package/dist/{index-5jp1h0bz.js → index-yzcjxnt2.js}

@@ -1,11 +1,11 @@
+import {
+  getHarness2
+} from "./index-0h2mkab2.js";
 import {
   removeSystemReminders,
   hasMeaningfulUserText2,
   extractTexts2
-} from "./index-9xb0axhc.js";
-import {
-  getHarness2
-} from "./index-0h2mkab2.js";
+} from "./index-r56xgha8.js";
 import {
   withSqliteBackgroundWriter2,
   withoutSqliteTransformPass2
@@ -15,20 +15,25 @@ import {
   recordIndexedMessageTime,
   messageFtsOrdinalRangeIsMapped,
   deleteUnmappedMessageFtsRows
-} from "./index-603mt6nm.js";
+} from "./index-r024r8da.js";
 import {
   deleteChunkEmbedBackoffForSession
-} from "./index-fm3ksh5e.js";
+} from "./index-bejpsj10.js";
 import {
   closeQuietly,
+  TAG_TOMBSTONE_OWNER_PREFIX,
+  tagTombstoneOwnerRange,
+  tagTombstoneOwnerKey,
+  tagRevisionKey,
+  tagIdentityRevisionKey,
   deleteTagIdentityRevisions
-} from "./index-8y5knskr.js";
+} from "./index-mcgehvgw.js";
 import {
   cleanUserText2
-} from "./index-hrf13mn3.js";
+} from "./index-3rea6zd9.js";
 import {
   logSlowWriteTransaction
-} from "./index-fp37he9a.js";
+} from "./index-0vrkp1jq.js";
 
 // ../plugin/src/features/magic-context/session-activity.ts
 var PREFIX = "retrospective_activity:";
@@ -176,6 +181,17 @@ function deleteSessionScopedRows(db, sessionIds, harness, options = {}) {
   if (deletableSessionIds.length === 0)
     return 0;
   const placeholders = deletableSessionIds.map(() => "?").join(", ");
+  const harnessTables = SESSION_SCOPED_TABLES.filter((definition) => definition.harnessScoped);
+  if (options.preserveTagRevisionTombstones) {
+    const owners = db.prepare(harnessTables.map((definition) => `SELECT session_id, harness FROM ${definition.table} WHERE session_id IN (${placeholders})${definition.extraPredicate ? ` AND ${definition.extraPredicate}` : ""}`).join(" UNION ")).all(...harnessTables.flatMap(() => deletableSessionIds));
+    const record = db.prepare("INSERT OR IGNORE INTO schema_migrations_meta (key, value) VALUES (?, ?)");
+    for (const owner of owners)
+      record.run(tagTombstoneOwnerKey(owner.session_id, owner.harness), owner.harness);
+    const fallback = db.prepare(`INSERT INTO schema_migrations_meta (key, value)
+            SELECT ?, ? WHERE NOT EXISTS (SELECT 1 FROM schema_migrations_meta WHERE key >= ? AND key < ?)`);
+    for (const id of deletableSessionIds)
+      fallback.run(tagTombstoneOwnerKey(id, getHarness2()), getHarness2(), ...tagTombstoneOwnerRange(id));
+  }
   for (const sessionId of deletableSessionIds)
     deleteChunkEmbedBackoffForSession(db, sessionId);
   for (const definition of SESSION_SCOPED_TABLES) {
@@ -202,6 +218,20 @@ function deleteSessionScopedRows(db, sessionIds, harness, options = {}) {
       statement.run(...deletableSessionIds);
   }
   deleteSessionActivity(db, deletableSessionIds);
+  if (!options.preserveTagRevisionTombstones) {
+    const retireOwner = db.prepare(harness === undefined ? "DELETE FROM schema_migrations_meta WHERE key >= ? AND key < ?" : "DELETE FROM schema_migrations_meta WHERE key = ?");
+    const survivingRows = harnessTables.map((definition) => `EXISTS (SELECT 1 FROM ${definition.table} WHERE session_id = ?${definition.extraPredicate ? ` AND ${definition.extraPredicate}` : ""})`).join(" OR ");
+    const retire = db.prepare(`DELETE FROM schema_migrations_meta WHERE key IN (?, ?)
+            AND NOT (${survivingRows})
+            AND NOT EXISTS (SELECT 1 FROM schema_migrations_meta AS owners WHERE owners.key >= ? AND owners.key < ?)`);
+    for (const id of deletableSessionIds) {
+      if (harness === undefined)
+        retireOwner.run(...tagTombstoneOwnerRange(id));
+      else
+        retireOwner.run(tagTombstoneOwnerKey(id, harness));
+      retire.run(tagIdentityRevisionKey(id), tagRevisionKey(id), ...harnessTables.map(() => id), ...tagTombstoneOwnerRange(id));
+    }
+  }
   return deletableSessionIds.length;
 }
 
@@ -641,12 +671,19 @@ function persistMessageHistoryOrphanSweepState(db, cursor, lastSweptAt, harness)
              last_swept_at = excluded.last_swept_at`).run(harness, cursor, lastSweptAt);
 }
 function getOpenCodeSessionScopedCandidateSourceSql(harness) {
-  return SESSION_SCOPED_TABLES.filter((definition) => definition.harnessScoped === true).map((definition) => {
+  const sources = SESSION_SCOPED_TABLES.filter((definition) => definition.harnessScoped === true).map((definition) => {
     const predicates = ["session_id IS NOT NULL", `harness = '${harness}'`];
     if (definition.extraPredicate)
       predicates.push(definition.extraPredicate);
     return `SELECT session_id FROM ${definition.table} WHERE ${predicates.join(" AND ")}`;
-  }).join(`
+  });
+  const jsonId = `SUBSTR(key, ${TAG_TOMBSTONE_OWNER_PREFIX.length + 1}, LENGTH(key) - ${TAG_TOMBSTONE_OWNER_PREFIX.length + harness.length + 1})`;
+  sources.push(`SELECT CASE WHEN json_valid(${jsonId}) THEN
+        CASE WHEN json_type(${jsonId}) = 'text' THEN json_extract(${jsonId}, '$') END END AS session_id
+        FROM schema_migrations_meta WHERE value = '${harness}'
+        AND key >= '${TAG_TOMBSTONE_OWNER_PREFIX}' AND key < '${TAG_TOMBSTONE_OWNER_PREFIX.slice(0, -1)};'
+        AND SUBSTR(key, -${harness.length + 1}) = ':${harness}'`);
+  return sources.join(`
 UNION
 `);
 }

package/dist/{index-zrr5t5a7.js → index-zh1jw8qp.js}

@@ -134,6 +134,111 @@ function buildHiddenAgentRegistrations(args) {
   ];
 }
 
+// ../plugin/src/shared/models-dev-temperature.ts
+import { readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var CATALOG_PROVIDER_ALIASES = {
+  "google-antigravity": "google",
+  "opencode-zen": "opencode"
+};
+var ANTIGRAVITY_MODEL_PREFIX = "antigravity-";
+var cached;
+function modelsDevCatalogPath(env = process.env) {
+  if (env.OPENCODE_MODELS_PATH)
+    return env.OPENCODE_MODELS_PATH;
+  return join(env.XDG_CACHE_HOME || join(homedir(), ".cache"), "opencode", "models.json");
+}
+function buildIndex(raw) {
+  const index = new Map;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    return index;
+  for (const [providerID, provider] of Object.entries(raw)) {
+    const models = provider?.models;
+    if (!models || typeof models !== "object")
+      continue;
+    for (const [modelID, model] of Object.entries(models)) {
+      const temperature = model?.temperature;
+      if (typeof temperature === "boolean")
+        index.set(`${providerID}/${modelID}`, temperature);
+    }
+  }
+  return index;
+}
+function loadIndex() {
+  const path = modelsDevCatalogPath();
+  try {
+    const stat = statSync(path);
+    if (cached?.path === path && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size)
+      return cached.index;
+    const index = buildIndex(JSON.parse(readFileSync(path, "utf8")));
+    cached = { path, mtimeMs: stat.mtimeMs, size: stat.size, index };
+    return index;
+  } catch {
+    return;
+  }
+}
+function catalogCandidates(providerID, modelID) {
+  const provider = Object.hasOwn(CATALOG_PROVIDER_ALIASES, providerID) ? CATALOG_PROVIDER_ALIASES[providerID] : providerID;
+  const candidates = [`${provider}/${modelID}`];
+  if (provider === "google" && modelID.startsWith(ANTIGRAVITY_MODEL_PREFIX))
+    candidates.push(`google/${modelID.slice(ANTIGRAVITY_MODEL_PREFIX.length)}`);
+  return candidates;
+}
+function catalogTemperature(model) {
+  const slash = model.indexOf("/");
+  if (slash <= 0 || slash === model.length - 1)
+    return;
+  const index = loadIndex();
+  if (!index)
+    return;
+  for (const entry of catalogCandidates(model.slice(0, slash), model.slice(slash + 1))) {
+    const temperature = index.get(entry);
+    if (temperature !== undefined)
+      return { temperature, entry };
+  }
+  return;
+}
+
+// ../plugin/src/shared/subagent-temperature.ts
+var loggedDecisions = new Set;
+function temperatureCapability(metadata) {
+  if (!metadata || typeof metadata !== "object")
+    return;
+  const model = metadata;
+  const supported = model.capabilities?.temperature ?? model.temperature ?? model.compat?.supportsTemperature ?? model.compat?.supportsSamplingParams;
+  return typeof supported === "boolean" ? supported : undefined;
+}
+function resolveTemperatureCapability(model, metadata) {
+  const host = temperatureCapability(metadata);
+  if (host !== undefined)
+    return { supported: host, source: "host" };
+  const catalog = catalogTemperature(model);
+  if (catalog)
+    return { supported: catalog.temperature, source: "catalog", entry: catalog.entry };
+  return { supported: undefined, source: "none" };
+}
+function describeTemperatureDecision(model, decision) {
+  const verdict = decision.supported === true ? "sent" : "omitted";
+  const answer = decision.supported === true ? "yes" : "no";
+  const reason = decision.source === "host" ? `host model metadata says ${answer}` : decision.source === "catalog" ? `models.dev cache entry ${decision.entry ?? "unknown"} says ${answer}` : "no host or models.dev metadata";
+  return `Subagent temperature ${verdict} for ${model}: ${reason}`;
+}
+function logTemperatureDecision(model, decision, log) {
+  const key = `${model}\x00${decision.source}\x00${decision.supported}\x00${decision.entry ?? ""}`;
+  if (loggedDecisions.has(key))
+    return;
+  loggedDecisions.add(key);
+  log(describeTemperatureDecision(model, decision), decision);
+}
+function subagentTemperature(model, metadata, temperature, log) {
+  if (temperature === undefined)
+    return;
+  const decision = resolveTemperatureCapability(model, metadata);
+  logTemperatureDecision(model, decision, log);
+  return decision.supported === true ? temperature : undefined;
+}
+
 // src/subagent-telemetry.ts
 import { createHash } from "node:crypto";
 var stepCaps = new Map(buildHiddenAgentRegistrations({
@@ -250,4 +355,4 @@ function readHostSystemPrompt(ctx) {
   return;
 }
 
-export { buildHiddenAgentRegistrations, subagentStepCap, promptFingerprint, SubagentTelemetry, readHostSystemPrompt };
+export { buildHiddenAgentRegistrations, logTemperatureDecision, subagentTemperature, subagentStepCap, promptFingerprint, SubagentTelemetry, readHostSystemPrompt };