@cortexkit/opencode-magic-context 0.47.0 → 0.48.0

package/dist/index-fb3zxn06.js

@@ -0,0 +1,13 @@
+// src/shared/sqlite-context-pragmas.ts
+function configureContextDatabasePragmas2(db, readonly = false) {
+  const [row] = db.prepare(readonly ? "PRAGMA journal_mode" : "PRAGMA journal_mode=WAL").all();
+  const mode = row?.journal_mode?.toLowerCase();
+  if (mode === "memory" || readonly && mode !== "wal")
+    return;
+  if (mode !== "wal") {
+    throw new Error(`context.db requires WAL before synchronous=NORMAL (got ${mode ?? "unknown"})`);
+  }
+  db.exec("PRAGMA synchronous=NORMAL");
+}
+
+export { configureContextDatabasePragmas2 };

package/dist/index-fbv1dn35.js

@@ -0,0 +1,171 @@
+import {
+  withSqliteBackgroundWriter2,
+  withoutSqliteTransformPass2
+} from "./index-kb9nn0a0.js";
+import {
+  logSlowWriteTransaction
+} from "./index-2y0s2hep.js";
+
+// src/features/magic-context/message-fts-rowid-map.ts
+import { createHash } from "node:crypto";
+var MESSAGE_FTS_ROWID_MAP_BACKFILL_BATCH_SIZE = 100;
+var BACKFILL_STATE_ID = 1;
+var EMPTY_INDEX_CONTENT_HASH = createHash("sha256").update("").digest("hex");
+var upsertMapStatements = new WeakMap;
+var rangeReadyStatements = new WeakMap;
+var updateTimeStatements = new WeakMap;
+var activeBackfills = new WeakMap;
+function getUpsertMapStatement(db) {
+  let statement = upsertMapStatements.get(db);
+  if (!statement) {
+    statement = db.prepare(`INSERT INTO message_fts_rowid_map
+                 (session_id, message_ordinal, fts_rowid, message_time_ms)
+             VALUES (?, ?, ?, ?)
+             ON CONFLICT(session_id, message_ordinal) DO UPDATE SET
+                 fts_rowid = excluded.fts_rowid,
+                 message_time_ms = COALESCE(
+                     excluded.message_time_ms,
+                     message_fts_rowid_map.message_time_ms
+                 )`);
+    upsertMapStatements.set(db, statement);
+  }
+  return statement;
+}
+function getBackfillState(db) {
+  const row = db.prepare(`SELECT watermark_rowid AS watermarkRowid, completed
+             FROM message_fts_rowid_map_backfill_state
+             WHERE id = ?`).get(BACKFILL_STATE_ID);
+  return {
+    processed: 0,
+    watermarkRowid: typeof row?.watermarkRowid === "number" && Number.isSafeInteger(row.watermarkRowid) ? row.watermarkRowid : 0,
+    completed: row?.completed === 1
+  };
+}
+function recordMessageFtsRowid(db, sessionId, messageOrdinal, ftsRowid, messageTimeMs = null) {
+  const numericRowid = Number(ftsRowid);
+  if (!Number.isSafeInteger(numericRowid) || numericRowid <= 0) {
+    throw new Error(`invalid message FTS rowid: ${String(ftsRowid)}`);
+  }
+  const normalizedTime = typeof messageTimeMs === "number" && Number.isSafeInteger(messageTimeMs) && messageTimeMs >= 0 ? messageTimeMs : null;
+  getUpsertMapStatement(db).run(sessionId, messageOrdinal, numericRowid, normalizedTime);
+}
+function recordIndexedMessageTime(db, sessionId, messageOrdinal, messageTimeMs) {
+  if (typeof messageTimeMs !== "number" || !Number.isSafeInteger(messageTimeMs) || messageTimeMs < 0) {
+    return;
+  }
+  let statement = updateTimeStatements.get(db);
+  if (!statement) {
+    statement = db.prepare(`UPDATE message_fts_rowid_map
+                SET message_time_ms = ?
+              WHERE session_id = ? AND message_ordinal = ?
+                AND message_time_ms IS NULL`);
+    updateTimeStatements.set(db, statement);
+  }
+  statement.run(messageTimeMs, sessionId, messageOrdinal);
+}
+function backfillMessageFtsRowidMapBatch(db, batchSize = MESSAGE_FTS_ROWID_MAP_BACKFILL_BATCH_SIZE) {
+  const boundedBatchSize = Number.isFinite(batchSize) ? Math.min(MESSAGE_FTS_ROWID_MAP_BACKFILL_BATCH_SIZE, Math.max(1, Math.floor(batchSize))) : MESSAGE_FTS_ROWID_MAP_BACKFILL_BATCH_SIZE;
+  let progress = {
+    processed: 0,
+    watermarkRowid: 0,
+    completed: false
+  };
+  let transactionStartedAt = 0;
+  db.transaction(() => {
+    transactionStartedAt = performance.now();
+    db.prepare(`INSERT OR IGNORE INTO message_fts_rowid_map_backfill_state
+            (id, watermark_rowid, completed) VALUES (?, 0, 0)`).run(BACKFILL_STATE_ID);
+    const state = getBackfillState(db);
+    if (state.completed) {
+      progress = state;
+      return;
+    }
+    const rows = db.prepare(`SELECT rowid AS ftsRowid,
+            session_id AS sessionId, message_ordinal AS messageOrdinal
+            FROM message_history_fts WHERE rowid > ? ORDER BY rowid ASC LIMIT ?`).all(state.watermarkRowid, boundedBatchSize);
+    let watermarkRowid = state.watermarkRowid;
+    for (const row of rows) {
+      const ftsRowid = Number(row.ftsRowid);
+      const messageOrdinal = Number(row.messageOrdinal);
+      if (Number.isSafeInteger(ftsRowid) && ftsRowid > watermarkRowid) {
+        watermarkRowid = ftsRowid;
+      }
+      if (typeof row.sessionId === "string" && Number.isSafeInteger(messageOrdinal) && messageOrdinal >= 0 && Number.isSafeInteger(ftsRowid) && ftsRowid > 0) {
+        recordMessageFtsRowid(db, row.sessionId, messageOrdinal, ftsRowid);
+      }
+    }
+    const completed = rows.length < boundedBatchSize;
+    db.prepare(`UPDATE message_fts_rowid_map_backfill_state
+             SET watermark_rowid = ?, completed = ?, updated_at = ?
+             WHERE id = ?`).run(watermarkRowid, completed ? 1 : 0, Date.now(), BACKFILL_STATE_ID);
+    progress = {
+      processed: rows.length,
+      watermarkRowid,
+      completed
+    };
+  }).immediate();
+  logSlowWriteTransaction("message_fts_rowid_backfill", transactionStartedAt);
+  return progress;
+}
+async function runMessageFtsRowidMapBackfill(db) {
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  for (;; ) {
+    const progress = backfillMessageFtsRowidMapBatch(db);
+    if (progress.completed)
+      return;
+    await new Promise((resolve) => setTimeout(resolve, 0));
+  }
+}
+function startMessageFtsRowidMapBackfill(db) {
+  const active = activeBackfills.get(db);
+  if (active)
+    return active;
+  const run = withoutSqliteTransformPass2(() => withSqliteBackgroundWriter2(() => runMessageFtsRowidMapBackfill(db))).finally(() => {
+    activeBackfills.delete(db);
+  });
+  activeBackfills.set(db, run);
+  return run;
+}
+function messageFtsOrdinalRangeIsMapped(db, sessionId, startOrdinal, endOrdinal) {
+  if (endOrdinal < startOrdinal)
+    return true;
+  if (getBackfillState(db).completed)
+    return true;
+  let statement = rangeReadyStatements.get(db);
+  if (!statement) {
+    statement = db.prepare(`SELECT COUNT(DISTINCT source.message_ordinal) AS sourceOrdinalCount,
+                    COUNT(DISTINCT CASE
+                        WHEN source.role IN ('user', 'assistant')
+                         AND source.normalized_content_hash != ?
+                        THEN source.message_ordinal
+                    END) AS expectedMapCount,
+                    COUNT(DISTINCT CASE
+                        WHEN source.role IN ('user', 'assistant')
+                         AND source.normalized_content_hash != ?
+                         AND map.fts_rowid IS NOT NULL
+                        THEN source.message_ordinal
+                    END) AS mappedCount
+             FROM message_history_source AS source
+             LEFT JOIN message_fts_rowid_map AS map
+               ON map.session_id = source.session_id
+              AND map.message_ordinal = source.message_ordinal
+             WHERE source.session_id = ?
+               AND source.message_ordinal BETWEEN ? AND ?`);
+    rangeReadyStatements.set(db, statement);
+  }
+  const row = statement.get(EMPTY_INDEX_CONTENT_HASH, EMPTY_INDEX_CONTENT_HASH, sessionId, startOrdinal, endOrdinal);
+  const ordinalCount = endOrdinal - startOrdinal + 1;
+  return row?.sourceOrdinalCount === ordinalCount && row.expectedMapCount === row.mappedCount;
+}
+function deleteUnmappedMessageFtsRows(db, sessionIds) {
+  if (sessionIds.length === 0)
+    return;
+  const state = getBackfillState(db);
+  if (state.completed)
+    return;
+  const placeholders = sessionIds.map(() => "?").join(", ");
+  db.prepare(`DELETE FROM message_history_fts
+         WHERE rowid > ? AND session_id IN (${placeholders})`).run(state.watermarkRowid, ...sessionIds);
+}
+
+export { recordMessageFtsRowid, recordIndexedMessageTime, startMessageFtsRowidMapBackfill, messageFtsOrdinalRangeIsMapped, deleteUnmappedMessageFtsRows };

package/dist/index-fr0wbhdn.js

@@ -0,0 +1,43 @@
+// src/features/magic-context/memory/constants.ts
+var V2_MEMORY_CATEGORIES = [
+  "PROJECT_RULES",
+  "ARCHITECTURE",
+  "CONSTRAINTS",
+  "CONFIG_VALUES",
+  "NAMING"
+];
+var PROMOTABLE_CATEGORIES = [
+  ...V2_MEMORY_CATEGORIES,
+  "ARCHITECTURE_DECISIONS",
+  "CONFIG_DEFAULTS",
+  "USER_PREFERENCES",
+  "USER_DIRECTIVES",
+  "ENVIRONMENT",
+  "WORKFLOW_RULES",
+  "KNOWN_ISSUES"
+];
+var CATEGORY_PRIORITY = [
+  ...V2_MEMORY_CATEGORIES,
+  "USER_DIRECTIVES",
+  "USER_PREFERENCES",
+  "CONFIG_DEFAULTS",
+  "ARCHITECTURE_DECISIONS",
+  "ENVIRONMENT",
+  "WORKFLOW_RULES",
+  "KNOWN_ISSUES"
+];
+var MEMORY_CATEGORY_ORDER_UNKNOWN = 99;
+var MEMORY_CATEGORY_ORDER_PRIORITY = CATEGORY_PRIORITY.reduce((acc, category, index) => {
+  acc[category] = index;
+  return acc;
+}, {});
+var MEMORY_CATEGORY_ORDER_SQL = `CASE category ${CATEGORY_PRIORITY.map((category, index) => `WHEN '${category}' THEN ${index}`).join(" ")} ELSE ${MEMORY_CATEGORY_ORDER_UNKNOWN} END`;
+function getMemoryCategoryOrder(category) {
+  return MEMORY_CATEGORY_ORDER_PRIORITY[category] ?? MEMORY_CATEGORY_ORDER_UNKNOWN;
+}
+var CATEGORY_DEFAULT_TTL = {
+  WORKFLOW_RULES: 90 * 24 * 60 * 60 * 1000,
+  KNOWN_ISSUES: 30 * 24 * 60 * 60 * 1000
+};
+
+export { V2_MEMORY_CATEGORIES, PROMOTABLE_CATEGORIES, CATEGORY_PRIORITY, MEMORY_CATEGORY_ORDER_SQL, getMemoryCategoryOrder, CATEGORY_DEFAULT_TTL };

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

@@ -1,6 +1,6 @@
 import {
   resolveDreamerTaskModel2
-} from "./index-sfpzqvdz.js";
+} from "./index-8cd2j99z.js";
 
 // src/features/magic-context/dreamer/task-registry.ts
 var CANONICAL_DREAM_TASKS = [
@@ -17,6 +17,9 @@ var CANONICAL_DREAM_TASKS = [
   "promote-primers",
   "refresh-primers"
 ];
+function availableDreamTasks(smartNotesEnabled = true) {
+  return CANONICAL_DREAM_TASKS.filter((task) => smartNotesEnabled || task !== "evaluate-smart-notes");
+}
 var DREAM_TOOL_LOOP_TOKEN_BUDGETS = {
   "map-memories": 2500000,
   verify: 2500000,
@@ -150,13 +153,12 @@ function compareTaskOrder(a, b) {
 }
 
 // src/features/magic-context/dreamer/task-config.ts
-function buildDreamTaskRuntimeConfigs2(dreamer, harness, language, muralModel) {
-  return CANONICAL_DREAM_TASKS.map((task) => {
+function buildDreamTaskRuntimeConfigs2(dreamer, harness, language, smartNotesEnabled = true) {
+  return availableDreamTasks(smartNotesEnabled).map((task) => {
     const resolved = resolveDreamerTaskModel2({
       config: { dreamer },
       harness,
-      task,
-      muralModel
+      task
     });
     return {
       task,
@@ -184,13 +186,13 @@ function dreamTaskScheduled2(dreamer, task) {
   const schedule = dreamer?.tasks?.[task]?.schedule;
   return typeof schedule === "string" && schedule.trim() !== "";
 }
-function enabledDreamTasks2(dreamer) {
+function enabledDreamTasks2(dreamer, smartNotesEnabled = true) {
   if (!dreamer?.tasks)
     return [];
-  return CANONICAL_DREAM_TASKS.filter((t) => dreamer.tasks[t]?.schedule?.trim());
+  return availableDreamTasks(smartNotesEnabled).filter((t) => dreamer.tasks[t]?.schedule?.trim());
 }
-function summarizeDreamSchedule2(dreamer) {
-  const enabled = enabledDreamTasks2(dreamer);
+function summarizeDreamSchedule2(dreamer, smartNotesEnabled = true) {
+  const enabled = enabledDreamTasks2(dreamer, smartNotesEnabled);
   if (enabled.length === 0)
     return "manual-only";
   return enabled.map((t) => `${t} ${dreamer?.tasks[t]?.schedule}`).join(", ");

package/dist/{index-fzbvakh0.js → index-jcbd3znx.js}

@@ -1,6 +1,6 @@
 import {
-  log
-} from "./index-hybnrwq0.js";
+  log2
+} from "./index-8j7gqj40.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$/;
@@ -33,7 +33,7 @@ async function waitForSafeNotificationTarget2(client, sessionId, options) {
       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`);
+  log2(`[magic-context] notification skipped: session ${sessionId} still has its default title (would suppress title generation); will retry on a later startup`);
   return "skip";
 }
 

package/dist/{index-5a2r0p9f.js → index-k1xb52kd.js}

@@ -1,6 +1,6 @@
 import {
-  sessionLog
-} from "./index-hybnrwq0.js";
+  sessionLog2
+} from "./index-8j7gqj40.js";
 import {
   COMPARTMENT_LEASE_RENEWAL_MS,
   acquireCompartmentLease,
@@ -21,17 +21,20 @@ import {
   getActiveCompartmentRun,
   markActiveCompartmentRunPublished,
   registerActiveCompartmentRun
-} from "./index-6d9e1m08.js";
+} from "./index-692jzy0p.js";
+import {
+  prepareRawSessionOrdinals2
+} from "./index-bdckkfw6.js";
 import {
   pushNotification2
 } from "./index-x8a7jmkh.js";
 import {
   sendStatusNotification2
-} from "./index-adwfkpex.js";
+} from "./index-yq8n9qcb.js";
 import {
   setRecompStarting2,
   setRecompTerminal2
-} from "./index-gg8j07zz.js";
+} from "./index-mmyh6d8f.js";
 
 // src/hooks/magic-context/wrapup-orchestrator.ts
 import * as crypto from "node:crypto";
@@ -123,7 +126,7 @@ async function acquireCompartmentLeaseForWrapup(ctx, sessionId, renewWrapupMarke
   const remainingMs = () => Math.max(0, waitStartedAt + maxWaitMs - Date.now());
   for (;; ) {
     if (remainingMs() <= 0) {
-      sessionLog(sessionId, "wrapup: timed out waiting for the compartment-state lease");
+      sessionLog2(sessionId, "wrapup: timed out waiting for the compartment-state lease");
       return { ok: false, reason: "timeout" };
     }
     const active = getActiveCompartmentRun(sessionId);
@@ -134,7 +137,7 @@ async function acquireCompartmentLeaseForWrapup(ctx, sessionId, renewWrapupMarke
       emitWrapupProgress(ctx, sessionId, { note: "Waiting for the active historian run…" });
       const outcome = await waitForActiveRunWithin(active.promise, remainingMs());
       if (outcome === "timeout") {
-        sessionLog(sessionId, "wrapup: timed out waiting for the active historian run");
+        sessionLog2(sessionId, "wrapup: timed out waiting for the active historian run");
         return { ok: false, reason: "timeout" };
       }
       continue;
@@ -157,10 +160,10 @@ async function runOneWrapupIteration(args) {
   const renewal = setInterval(() => {
     try {
       if (!renewCompartmentLease(ctx.db, sessionId, leaseHolderId)) {
-        sessionLog(sessionId, "wrapup: compartment lease renewal failed");
+        sessionLog2(sessionId, "wrapup: compartment lease renewal failed");
       }
     } catch (err) {
-      sessionLog(sessionId, `wrapup: compartment lease renewal threw; continuing (${err instanceof Error ? err.message : String(err)})`);
+      sessionLog2(sessionId, `wrapup: compartment lease renewal threw; continuing (${err instanceof Error ? err.message : String(err)})`);
     }
   }, COMPARTMENT_LEASE_RENEWAL_MS);
   const runCompartmentAgentForWrapup = ctx.runCompartmentAgentForWrapup ?? runCompartmentAgent;
@@ -206,13 +209,17 @@ async function runOneWrapupIteration(args) {
     return { ran: true };
   } finally {
     clearInterval(renewal);
-    releaseCompartmentLeaseBestEffort(ctx.db, sessionId, leaseHolderId, sessionLog);
+    releaseCompartmentLeaseBestEffort(ctx.db, sessionId, leaseHolderId, sessionLog2);
   }
 }
 async function runManagedWrapup2(ctx, sessionId, options) {
   const messagesToKeep = Math.max(1, Math.floor(options.messagesToKeep));
   setRecompStarting2(ctx.liveSessionState, sessionId, "Estimating wrapup…", "wrapup");
   try {
+    if (!await prepareRawSessionOrdinals2(sessionId)) {
+      setRecompTerminal2(ctx.liveSessionState, sessionId, "failed", "Session ordinals are warming; retry wrapup shortly.");
+      return "Wrapup deferred while session ordinals warm in the background. Retry shortly.";
+    }
     return await runStartedWrapup(ctx, sessionId, messagesToKeep);
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
@@ -265,7 +272,7 @@ ${message}`;
     if (ownershipLost)
       return;
     ownershipLost = true;
-    sessionLog(sessionId, "wrapup: durable marker ownership lost; aborting loop");
+    sessionLog2(sessionId, "wrapup: durable marker ownership lost; aborting loop");
   };
   const renewWrapupMarker = (updates) => {
     const updated = updateWrapupInProgress(ctx.db, sessionId, wrapupHolderId, updates);
@@ -282,7 +289,7 @@ ${message}`;
         chunkIndex
       });
     } catch (err) {
-      sessionLog(sessionId, `wrapup: marker renewal threw; continuing (${err instanceof Error ? err.message : String(err)})`);
+      sessionLog2(sessionId, `wrapup: marker renewal threw; continuing (${err instanceof Error ? err.message : String(err)})`);
     }
   }, 60000);
   markerRenewal.unref?.();
@@ -338,7 +345,7 @@ ${message}`;
         if (lastEnd + 1 >= plan.targetEligibleEndOrdinal)
           break;
         chunkIndex += 1;
-        sessionLog(sessionId, `wrapup chunk ${chunkIndex}: ${describeBoundaryDiagnostics(plan.snapshot)}`);
+        sessionLog2(sessionId, `wrapup chunk ${chunkIndex}: ${describeBoundaryDiagnostics(plan.snapshot)}`);
         emitWrapupProgress(ctx, sessionId, {
           processedMessages: Math.max(0, lastEnd),
           totalMessages: Math.max(0, plan.targetEligibleEndOrdinal - 1),