@cortexkit/opencode-magic-context 0.44.4 → 0.45.0

package/dist/v2/index-en1k8h8m.js

@@ -0,0 +1,244 @@
+import {
+  assertSync2,
+  EvalFlags2,
+  IntrinsicsFlags2,
+  JSPromiseStateEnum2,
+  GetOwnPropertyNamesFlags2,
+  IsEqualOp2,
+  setDebugMode2,
+  debugLog2,
+  errors_exports,
+  QuickJSMemoryLeakDetected,
+  QuickJSEmscriptenModuleError,
+  UsingDisposable2,
+  Lifetime2,
+  StaticLifetime2,
+  WeakLifetime2,
+  Scope2,
+  createDisposableArray2,
+  DisposableSuccess2,
+  DisposableFail2,
+  DisposableResult2,
+  QuickJSDeferredPromise2,
+  DefaultIntrinsics2,
+  QuickJSContext2,
+  QuickJSRuntime2,
+  QuickJSWASMModule2,
+  QuickJSAsyncContext2,
+  QuickJSAsyncRuntime2,
+  QuickJSAsyncWASMModule2
+} from "./server-g20jdh0p.js";
+
+// ../../node_modules/.bun/quickjs-emscripten-core@0.32.0/node_modules/quickjs-emscripten-core/dist/index.mjs
+async function newQuickJSWASMModuleFromVariant(variantOrPromise) {
+  let variant = smartUnwrap(await variantOrPromise), [wasmModuleLoader, QuickJSFFI, { QuickJSWASMModule: QuickJSWASMModule2 }] = await Promise.all([variant.importModuleLoader().then(smartUnwrap), variant.importFFI(), import("./module-ES6BEMUI-3cet1pyp.js").then(smartUnwrap)]), wasmModule = await wasmModuleLoader();
+  wasmModule.type = "sync";
+  let ffi = new QuickJSFFI(wasmModule);
+  return new QuickJSWASMModule2(wasmModule, ffi);
+}
+async function newQuickJSAsyncWASMModuleFromVariant(variantOrPromise) {
+  let variant = smartUnwrap(await variantOrPromise), [wasmModuleLoader, QuickJSAsyncFFI, { QuickJSAsyncWASMModule: QuickJSAsyncWASMModule2 }] = await Promise.all([variant.importModuleLoader().then(smartUnwrap), variant.importFFI(), import("./module-asyncify-2EFITU5U-c2razzd9.js").then(smartUnwrap)]), wasmModule = await wasmModuleLoader();
+  wasmModule.type = "async";
+  let ffi = new QuickJSAsyncFFI(wasmModule);
+  return new QuickJSAsyncWASMModule2(wasmModule, ffi);
+}
+function memoizePromiseFactory(fn) {
+  let promise;
+  return () => promise ?? (promise = fn());
+}
+function smartUnwrap(val) {
+  return val && "default" in val && val.default ? val.default && "default" in val.default && val.default.default ? val.default.default : val.default : val;
+}
+function newVariant(baseVariant, options) {
+  return { ...baseVariant, async importModuleLoader() {
+    let moduleLoader = smartUnwrap(await baseVariant.importModuleLoader());
+    return async function() {
+      let moduleLoaderArg = options.emscriptenModule ? { ...options.emscriptenModule } : {}, log = options.log ?? ((...args) => debugLog2("newVariant moduleLoader:", ...args)), tapValue = (message, val) => (log(...message, val), val), force = (val) => typeof val == "function" ? val() : val;
+      (options.wasmLocation || options.wasmSourceMapLocation || options.locateFile) && (moduleLoaderArg.locateFile = (fileName, relativeTo) => {
+        let args = { fileName, relativeTo };
+        if (fileName.endsWith(".wasm") && options.wasmLocation !== undefined)
+          return tapValue(["locateFile .wasm: provide wasmLocation", args], options.wasmLocation);
+        if (fileName.endsWith(".map")) {
+          if (options.wasmSourceMapLocation !== undefined)
+            return tapValue(["locateFile .map: provide wasmSourceMapLocation", args], options.wasmSourceMapLocation);
+          if (options.wasmLocation && !options.locateFile)
+            return tapValue(["locateFile .map: infer from wasmLocation", args], options.wasmLocation + ".map");
+        }
+        return options.locateFile ? tapValue(["locateFile: use provided fn", args], options.locateFile(fileName, relativeTo)) : tapValue(["locateFile: unhandled, passthrough", args], fileName);
+      }), options.wasmBinary && (moduleLoaderArg.wasmBinary = await force(options.wasmBinary)), options.wasmMemory && (moduleLoaderArg.wasmMemory = await force(options.wasmMemory));
+      let optionsWasmModule = options.wasmModule, modulePromise;
+      optionsWasmModule && (moduleLoaderArg.instantiateWasm = async (imports, onSuccess) => {
+        modulePromise ?? (modulePromise = Promise.resolve(force(optionsWasmModule)));
+        let wasmModule = await modulePromise;
+        if (!wasmModule)
+          throw new QuickJSEmscriptenModuleError(`options.wasmModule returned ${String(wasmModule)}`);
+        let instance = await WebAssembly.instantiate(wasmModule, imports);
+        return onSuccess(instance), instance.exports;
+      }), moduleLoaderArg.monitorRunDependencies = (left) => {
+        log("monitorRunDependencies:", left);
+      }, moduleLoaderArg.quickjsEmscriptenInit = () => newMockExtensions(log);
+      let resultPromise = moduleLoader(moduleLoaderArg), extensions = moduleLoaderArg.quickjsEmscriptenInit?.(log);
+      if (optionsWasmModule && extensions?.receiveWasmOffsetConverter && !extensions.existingWasmOffsetConverter) {
+        let wasmBinary = await force(options.wasmBinary) ?? new ArrayBuffer(0);
+        modulePromise ?? (modulePromise = Promise.resolve(force(optionsWasmModule)));
+        let wasmModule = await modulePromise;
+        if (!wasmModule)
+          throw new QuickJSEmscriptenModuleError(`options.wasmModule returned ${String(wasmModule)}`);
+        extensions.receiveWasmOffsetConverter(wasmBinary, wasmModule);
+      }
+      if (extensions?.receiveSourceMapJSON) {
+        let loadedSourceMapData = await force(options.wasmSourceMapData);
+        typeof loadedSourceMapData == "string" ? extensions.receiveSourceMapJSON(JSON.parse(loadedSourceMapData)) : loadedSourceMapData ? extensions.receiveSourceMapJSON(loadedSourceMapData) : extensions.receiveSourceMapJSON({ version: 3, names: [], sources: [], mappings: "" });
+      }
+      return resultPromise;
+    };
+  } };
+}
+function newMockExtensions(log) {
+  let mockMessage = "mock called, emscripten module may not be initialized yet";
+  return { mock: true, removeRunDependency(name) {
+    log(`${mockMessage}: removeRunDependency called:`, name);
+  }, receiveSourceMapJSON(data) {
+    log(`${mockMessage}: receiveSourceMapJSON called:`, data);
+  }, WasmOffsetConverter: undefined, receiveWasmOffsetConverter(bytes, mod) {
+    log(`${mockMessage}: receiveWasmOffsetConverter called:`, bytes, mod);
+  } };
+}
+function isSuccess(successOrFail) {
+  return !("error" in successOrFail);
+}
+function isFail(successOrFail) {
+  return "error" in successOrFail;
+}
+function shouldInterruptAfterDeadline(deadline) {
+  let deadlineAsNumber = typeof deadline == "number" ? deadline : deadline.getTime();
+  return function() {
+    return Date.now() > deadlineAsNumber;
+  };
+}
+var TestQuickJSWASMModule = class {
+  constructor(parent) {
+    this.parent = parent;
+    this.contexts = new Set;
+    this.runtimes = new Set;
+  }
+  newRuntime(options) {
+    let runtime = this.parent.newRuntime({ ...options, ownedLifetimes: [new Lifetime2(undefined, undefined, () => this.runtimes.delete(runtime)), ...options?.ownedLifetimes ?? []] });
+    return this.runtimes.add(runtime), runtime;
+  }
+  newContext(options) {
+    let context = this.parent.newContext({ ...options, ownedLifetimes: [new Lifetime2(undefined, undefined, () => this.contexts.delete(context)), ...options?.ownedLifetimes ?? []] });
+    return this.contexts.add(context), context;
+  }
+  evalCode(code, options) {
+    return this.parent.evalCode(code, options);
+  }
+  disposeAll() {
+    let allDisposables = [...this.contexts, ...this.runtimes];
+    this.runtimes.clear(), this.contexts.clear(), allDisposables.forEach((d) => {
+      d.alive && d.dispose();
+    });
+  }
+  assertNoMemoryAllocated() {
+    if (this.getFFI().QTS_RecoverableLeakCheck())
+      throw new QuickJSMemoryLeakDetected("Leak sanitizer detected un-freed memory");
+    if (this.contexts.size > 0)
+      throw new QuickJSMemoryLeakDetected(`${this.contexts.size} contexts leaked`);
+    if (this.runtimes.size > 0)
+      throw new QuickJSMemoryLeakDetected(`${this.runtimes.size} runtimes leaked`);
+  }
+  getWasmMemory() {
+    return this.parent.getWasmMemory();
+  }
+  getFFI() {
+    return this.parent.getFFI();
+  }
+};
+
+// ../../node_modules/.bun/@jitl+quickjs-wasmfile-debug-sync@0.32.0/node_modules/@jitl/quickjs-wasmfile-debug-sync/dist/index.mjs
+var variant = { type: "sync", importFFI: () => import("./ffi-bpvkebwr.js").then((mod) => mod.QuickJSFFI), importModuleLoader: () => import("./emscripten-module-pj1vyb44.js").then((mod) => mod.default) };
+var src_default = variant;
+
+// ../../node_modules/.bun/@jitl+quickjs-wasmfile-release-sync@0.32.0/node_modules/@jitl/quickjs-wasmfile-release-sync/dist/index.mjs
+var variant2 = { type: "sync", importFFI: () => import("./ffi-3cx1cxpk.js").then((mod) => mod.QuickJSFFI), importModuleLoader: () => import("./emscripten-module-e67xwsp3.js").then((mod) => mod.default) };
+var src_default2 = variant2;
+
+// ../../node_modules/.bun/@jitl+quickjs-wasmfile-debug-asyncify@0.32.0/node_modules/@jitl/quickjs-wasmfile-debug-asyncify/dist/index.mjs
+var variant3 = { type: "async", importFFI: () => import("./ffi-7e6gryj5.js").then((mod) => mod.QuickJSAsyncFFI), importModuleLoader: () => import("./emscripten-module-0pekdjxz.js").then((mod) => mod.default) };
+var src_default3 = variant3;
+
+// ../../node_modules/.bun/@jitl+quickjs-wasmfile-release-asyncify@0.32.0/node_modules/@jitl/quickjs-wasmfile-release-asyncify/dist/index.mjs
+var variant4 = { type: "async", importFFI: () => import("./ffi-7bqqe4cd.js").then((mod) => mod.QuickJSAsyncFFI), importModuleLoader: () => import("./emscripten-module-0g8f45e6.js").then((mod) => mod.default) };
+var src_default4 = variant4;
+
+// ../../node_modules/.bun/quickjs-emscripten@0.32.0/node_modules/quickjs-emscripten/dist/chunk-OHAYRCBA.mjs
+async function newQuickJSWASMModule(variantOrPromise = src_default2) {
+  return newQuickJSWASMModuleFromVariant(variantOrPromise);
+}
+async function newQuickJSAsyncWASMModule(variantOrPromise = src_default4) {
+  return newQuickJSAsyncWASMModuleFromVariant(variantOrPromise);
+}
+
+// ../../node_modules/.bun/quickjs-emscripten@0.32.0/node_modules/quickjs-emscripten/dist/index.mjs
+var singleton;
+var singletonPromise;
+async function getQuickJS() {
+  return singletonPromise ?? (singletonPromise = newQuickJSWASMModule().then((instance) => (singleton = instance, instance))), await singletonPromise;
+}
+function getQuickJSSync() {
+  if (!singleton)
+    throw new Error("QuickJS not initialized. Await getQuickJS() at least once.");
+  return singleton;
+}
+async function newAsyncRuntime(options) {
+  return (await newQuickJSAsyncWASMModule()).newRuntime(options);
+}
+async function newAsyncContext(options) {
+  return (await newQuickJSAsyncWASMModule()).newContext(options);
+}
+export {
+  src_default3 as DEBUG_ASYNC,
+  src_default as DEBUG_SYNC,
+  DefaultIntrinsics2 as DefaultIntrinsics,
+  DisposableFail2 as DisposableFail,
+  DisposableResult2 as DisposableResult,
+  DisposableSuccess2 as DisposableSuccess,
+  EvalFlags2 as EvalFlags,
+  GetOwnPropertyNamesFlags2 as GetOwnPropertyNamesFlags,
+  IntrinsicsFlags2 as IntrinsicsFlags,
+  IsEqualOp2 as IsEqualOp,
+  JSPromiseStateEnum2 as JSPromiseStateEnum,
+  Lifetime2 as Lifetime,
+  QuickJSAsyncContext2 as QuickJSAsyncContext,
+  QuickJSAsyncRuntime2 as QuickJSAsyncRuntime,
+  QuickJSAsyncWASMModule2 as QuickJSAsyncWASMModule,
+  QuickJSContext2 as QuickJSContext,
+  QuickJSDeferredPromise2 as QuickJSDeferredPromise,
+  QuickJSRuntime2 as QuickJSRuntime,
+  QuickJSWASMModule2 as QuickJSWASMModule,
+  src_default4 as RELEASE_ASYNC,
+  src_default2 as RELEASE_SYNC,
+  Scope2 as Scope,
+  StaticLifetime2 as StaticLifetime,
+  TestQuickJSWASMModule,
+  UsingDisposable2 as UsingDisposable,
+  WeakLifetime2 as WeakLifetime,
+  assertSync2 as assertSync,
+  createDisposableArray2 as createDisposableArray,
+  debugLog2 as debugLog,
+  errors_exports as errors,
+  getQuickJS,
+  getQuickJSSync,
+  isFail,
+  isSuccess,
+  memoizePromiseFactory,
+  newAsyncContext,
+  newAsyncRuntime,
+  newQuickJSAsyncWASMModule,
+  newQuickJSAsyncWASMModuleFromVariant,
+  newQuickJSWASMModule,
+  newQuickJSWASMModuleFromVariant,
+  newVariant,
+  setDebugMode2 as setDebugMode,
+  shouldInterruptAfterDeadline
+};

package/dist/{message-time-backfill-q374fxc5.js → v2/message-time-backfill-0n93vrd7.js}

@@ -1,8 +1,11 @@
-import"./index-s70wtd8k.js";
-import"./index-3bygzk2d.js";
+import {
+  withSqliteBackgroundWriter,
+  withoutSqliteTransformPass
+} from "./server-a4m2b1yv.js";
+import"./server-ckpc8pxy.js";
 import {
   logSlowWriteTransaction
-} from "./index-kr5qehbd.js";
+} from "./server-fgmxwrgy.js";
 
 // src/features/magic-context/message-time-backfill.ts
 var MESSAGE_TIME_BACKFILL_BATCH_SIZE = 500;
@@ -66,8 +69,11 @@ function backfillMessageTimesBatch(db, reader, batchSize = MESSAGE_TIME_BACKFILL
   const completed = rows.length < boundedBatchSize;
   const cursorSessionId = last?.sessionId ?? state.cursorSessionId;
   const cursorOrdinal = last ? Number(last.messageOrdinal) : state.cursorOrdinal;
-  const transactionStartedAt = performance.now();
+  let transactionStartedAt = 0;
   db.transaction(() => {
+    transactionStartedAt = performance.now();
+    db.prepare(`INSERT OR IGNORE INTO message_time_backfill_state
+            (id, cursor_session_id, cursor_ordinal, completed) VALUES (?, '', 0, 0)`).run(BACKFILL_STATE_ID);
     const update = db.prepare(`UPDATE message_fts_rowid_map
                 SET message_time_ms = ?
               WHERE session_id = ? AND message_ordinal = ? AND message_time_ms IS NULL`);
@@ -89,6 +95,7 @@ function backfillMessageTimesBatch(db, reader, batchSize = MESSAGE_TIME_BACKFILL
   };
 }
 async function runMessageTimeBackfill(db, reader) {
+  await new Promise((resolve) => setTimeout(resolve, 0));
   for (;; ) {
     const progress = backfillMessageTimesBatch(db, reader);
     if (progress.completed)
@@ -100,10 +107,17 @@ function startMessageTimeBackfill(db, reader) {
   const active = activeBackfills.get(db);
   if (active)
     return active;
-  const run = runMessageTimeBackfill(db, reader).finally(() => activeBackfills.delete(db));
+  const run = withoutSqliteTransformPass(() => withSqliteBackgroundWriter(() => runMessageTimeBackfill(db, reader))).finally(() => activeBackfills.delete(db));
   activeBackfills.set(db, run);
   return run;
 }
+function getMessageTimeBackfillProgress(db) {
+  return getBackfillState(db);
+}
 export {
+  MESSAGE_TIME_BACKFILL_BATCH_SIZE,
+  backfillMessageTimesBatch,
+  getMessageTimeBackfillProgress,
+  runMessageTimeBackfill,
   startMessageTimeBackfill
 };

package/dist/v2/migration-worker.js

@@ -0,0 +1,52 @@
+import {
+  setLogLineForwarder
+} from "./server-ckpc8pxy.js";
+import {
+  Database
+} from "./server-a4m2b1yv.js";
+import {
+  runMigrationsWithRetry,
+  setSqlitePragmaConfig,
+  initializeDatabase
+} from "./server-e36nf2p1.js";
+import {
+  closeQuietly
+} from "./server-qpg6wf72.js";
+import"./server-rhdgxp1t.js";
+import"./server-r7cmye3k.js";
+import"./server-fgmxwrgy.js";
+
+// src/features/magic-context/migration-worker.ts
+import { parentPort, workerData } from "node:worker_threads";
+function post(message) {
+  parentPort?.postMessage(message);
+}
+async function main() {
+  const data = workerData;
+  setLogLineForwarder((line) => post({ type: "log", line }));
+  setSqlitePragmaConfig(data.sqlitePragmaConfig);
+  post({ type: "ready" });
+  let db;
+  try {
+    db = new Database(data.dbPath);
+    initializeDatabase(db, data.busyTimeoutMs);
+    await runMigrationsWithRetry(db, {
+      sleep: async (delayMs) => {
+        post({ type: "lock-wait", waiting: true });
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+        post({ type: "lock-wait", waiting: false });
+      }
+    });
+    post({ type: "done" });
+  } catch (error) {
+    post({
+      type: "failed",
+      message: error instanceof Error ? error.message : String(error)
+    });
+  } finally {
+    if (db)
+      closeQuietly(db);
+    setLogLineForwarder(null);
+  }
+}
+main();

package/dist/v2/model-resolution-xhfmyyvy.js

@@ -0,0 +1,16 @@
+import {
+  normalizeModelEntry2,
+  resolveFallbackEntries2,
+  resolveHistorianModel2,
+  resolveDreamerTaskModel2,
+  resolveOpenCodeAgentOverrides2,
+  resolveHistorianAgentOverrides2
+} from "./server-sfpzqvdz.js";
+export {
+  normalizeModelEntry2 as normalizeModelEntry,
+  resolveDreamerTaskModel2 as resolveDreamerTaskModel,
+  resolveFallbackEntries2 as resolveFallbackEntries,
+  resolveHistorianAgentOverrides2 as resolveHistorianAgentOverrides,
+  resolveHistorianModel2 as resolveHistorianModel,
+  resolveOpenCodeAgentOverrides2 as resolveOpenCodeAgentOverrides
+};

package/dist/v2/module-ES6BEMUI-3cet1pyp.js

@@ -0,0 +1,12 @@
+import {
+  QuickJSModuleCallbacks2,
+  applyBaseRuntimeOptions2,
+  applyModuleEvalRuntimeOptions2,
+  QuickJSWASMModule2
+} from "./server-g20jdh0p.js";
+export {
+  QuickJSModuleCallbacks2 as QuickJSModuleCallbacks,
+  QuickJSWASMModule2 as QuickJSWASMModule,
+  applyBaseRuntimeOptions2 as applyBaseRuntimeOptions,
+  applyModuleEvalRuntimeOptions2 as applyModuleEvalRuntimeOptions
+};

package/dist/v2/module-asyncify-2EFITU5U-c2razzd9.js

@@ -0,0 +1,6 @@
+import {
+  QuickJSAsyncWASMModule2
+} from "./server-g20jdh0p.js";
+export {
+  QuickJSAsyncWASMModule2 as QuickJSAsyncWASMModule
+};

package/dist/v2/prompt-context-5y5ms8f9.js

@@ -0,0 +1,6 @@
+import {
+  resolvePromptContext2
+} from "./server-fmsr7v69.js";
+export {
+  resolvePromptContext2 as resolvePromptContext
+};

package/dist/v2/read-session-chunk-hjza38hr.js

@@ -0,0 +1,83 @@
+import {
+  resolveHostServedBoundaryId2,
+  hasRawMessageProvider2,
+  setRawMessageProvider2,
+  setBoundedRawMessageProvider2,
+  withRawMessageProvider2,
+  cleanUserText2,
+  withRawSessionMessageCache2,
+  readRawSessionMessages2,
+  readRawSessionMessagePage2,
+  getRawSessionMessageOrdinalCount2,
+  RAW_MESSAGE_VISIT_PAGE_SIZE2,
+  visitRawSessionMessages2,
+  readRawSessionMessageRange2,
+  primeTailRawMessageCache2,
+  getCachedAbsoluteMessageCount2,
+  primeInMemoryTailRawMessageCache2,
+  readRawSessionMessageOrdinalPage2,
+  getRawSessionStoredMessageCount2,
+  readRawSessionMessageIdOrdinalsForRange2,
+  readRawSessionMessageIdOrdinals2,
+  readRawSessionMessagePartsById2,
+  hasRawSessionMessageById2,
+  readRawSessionMessageOrdinalById2,
+  compareRawSessionMessageOrder2,
+  readRawSessionMessageById2,
+  getRawSessionMessageCount2,
+  RAW_SESSION_TAG_KEY_PAGE_SIZE2,
+  getRawSessionTagKeysThrough2,
+  getLegacyProtectedTailStartOrdinal2,
+  getProtectedTailStartOrdinal2,
+  readSessionChunk2,
+  getRawSessionMessageIdsThrough2,
+  readRawSessionSeedTail2
+} from "./server-hfjfbg59.js";
+import"./server-w99cyt6a.js";
+import"./server-n96ag4rk.js";
+import"./server-remp7e2g.js";
+import"./server-r7cmye3k.js";
+import"./server-qpg6wf72.js";
+import {
+  hasMeaningfulUserText2,
+  extractTexts2
+} from "./server-rhdgxp1t.js";
+import"./server-a4m2b1yv.js";
+import"./server-ckpc8pxy.js";
+export {
+  RAW_MESSAGE_VISIT_PAGE_SIZE2 as RAW_MESSAGE_VISIT_PAGE_SIZE,
+  RAW_SESSION_TAG_KEY_PAGE_SIZE2 as RAW_SESSION_TAG_KEY_PAGE_SIZE,
+  cleanUserText2 as cleanUserText,
+  compareRawSessionMessageOrder2 as compareRawSessionMessageOrder,
+  extractTexts2 as extractTexts,
+  getCachedAbsoluteMessageCount2 as getCachedAbsoluteMessageCount,
+  getLegacyProtectedTailStartOrdinal2 as getLegacyProtectedTailStartOrdinal,
+  getProtectedTailStartOrdinal2 as getProtectedTailStartOrdinal,
+  getRawSessionMessageCount2 as getRawSessionMessageCount,
+  getRawSessionMessageIdsThrough2 as getRawSessionMessageIdsThrough,
+  getRawSessionMessageOrdinalCount2 as getRawSessionMessageOrdinalCount,
+  getRawSessionStoredMessageCount2 as getRawSessionStoredMessageCount,
+  getRawSessionTagKeysThrough2 as getRawSessionTagKeysThrough,
+  hasMeaningfulUserText2 as hasMeaningfulUserText,
+  hasRawMessageProvider2 as hasRawMessageProvider,
+  hasRawSessionMessageById2 as hasRawSessionMessageById,
+  primeInMemoryTailRawMessageCache2 as primeInMemoryTailRawMessageCache,
+  primeTailRawMessageCache2 as primeTailRawMessageCache,
+  readRawSessionMessageById2 as readRawSessionMessageById,
+  readRawSessionMessageIdOrdinals2 as readRawSessionMessageIdOrdinals,
+  readRawSessionMessageIdOrdinalsForRange2 as readRawSessionMessageIdOrdinalsForRange,
+  readRawSessionMessageOrdinalById2 as readRawSessionMessageOrdinalById,
+  readRawSessionMessageOrdinalPage2 as readRawSessionMessageOrdinalPage,
+  readRawSessionMessagePage2 as readRawSessionMessagePage,
+  readRawSessionMessagePartsById2 as readRawSessionMessagePartsById,
+  readRawSessionMessageRange2 as readRawSessionMessageRange,
+  readRawSessionMessages2 as readRawSessionMessages,
+  readRawSessionSeedTail2 as readRawSessionSeedTail,
+  readSessionChunk2 as readSessionChunk,
+  resolveHostServedBoundaryId2 as resolveHostServedBoundaryId,
+  setBoundedRawMessageProvider2 as setBoundedRawMessageProvider,
+  setRawMessageProvider2 as setRawMessageProvider,
+  visitRawSessionMessages2 as visitRawSessionMessages,
+  withRawMessageProvider2 as withRawMessageProvider,
+  withRawSessionMessageCache2 as withRawSessionMessageCache
+};

package/dist/v2/recomp-orchestrator-1aq7h44c.js

@@ -0,0 +1,36 @@
+import {
+  isRecompFailure2,
+  isRecompSkip2,
+  extractRecompReason2,
+  setRecompStarting2,
+  setRecompNote2,
+  setRecompTerminal2,
+  buildRecompDeps2,
+  runManagedRecomp2
+} from "./server-c4g2y1z8.js";
+import"./server-z19x7eqz.js";
+import"./server-0jqw05sa.js";
+import"./server-v5xgft5v.js";
+import"./server-e36nf2p1.js";
+import"./server-hfjfbg59.js";
+import"./server-w99cyt6a.js";
+import"./server-n96ag4rk.js";
+import"./server-remp7e2g.js";
+import"./server-r7cmye3k.js";
+import"./server-qpg6wf72.js";
+import"./server-rhdgxp1t.js";
+import"./server-fgmxwrgy.js";
+import"./server-a4m2b1yv.js";
+import"./server-x8a7jmkh.js";
+import"./server-5317ykaf.js";
+import"./server-ckpc8pxy.js";
+export {
+  buildRecompDeps2 as buildRecompDeps,
+  extractRecompReason2 as extractRecompReason,
+  isRecompFailure2 as isRecompFailure,
+  isRecompSkip2 as isRecompSkip,
+  runManagedRecomp2 as runManagedRecomp,
+  setRecompNote2 as setRecompNote,
+  setRecompStarting2 as setRecompStarting,
+  setRecompTerminal2 as setRecompTerminal
+};

package/dist/v2/retrospective-raw-provider.d.ts

@@ -0,0 +1,21 @@
+import { type RetrospectiveProjectSession, type RetrospectiveRawMessage, type RetrospectiveRawProvider, type RetrospectiveSinceRead } from "../features/magic-context/dreamer/retrospective-raw-provider";
+import type { Database } from "../shared/sqlite";
+import { V2StoreReader } from "./store-reader";
+/** Uses only native OC2 projections, never converted legacy message/part rows.
+ * Like Pi, emits user-only history: private assistant text and tool output from
+ * other sessions are not retrospective input. The shared scan bounds sessions,
+ * messages and prompt tokens; the reader also bounds text before hydration. */
+export declare class V2RetrospectiveRawProvider implements RetrospectiveRawProvider {
+    private readonly contextDb;
+    private readonly openReader;
+    private reader?;
+    constructor(contextDb: Database, openReader?: () => V2StoreReader);
+    private store;
+    listProjectSessions(projectIdentity: string): RetrospectiveProjectSession[];
+    readOldestMessageTimesSince(sessionIds: readonly string[], sinceMs: number): Map<string, number>;
+    private read;
+    readUserMessagesSince(sessionId: string, sinceMs: number, capPerSession: number): RetrospectiveSinceRead;
+    readUserMessagesBefore(sessionId: string, beforeMs: number, count: number): RetrospectiveRawMessage[];
+    dispose(): void;
+}
+//# sourceMappingURL=retrospective-raw-provider.d.ts.map

package/dist/v2/retrospective-raw-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retrospective-raw-provider.d.ts","sourceRoot":"","sources":["../../src/v2/retrospective-raw-provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,KAAK,2BAA2B,EAChC,KAAK,uBAAuB,EAC5B,KAAK,wBAAwB,EAC7B,KAAK,sBAAsB,EAC9B,MAAM,8DAA8D,CAAC;AAItE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAkB,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAE/D;;;+EAG+E;AAC/E,qBAAa,0BAA2B,YAAW,wBAAwB;IAGnE,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAH/B,OAAO,CAAC,MAAM,CAAC,CAAgB;gBAEV,SAAS,EAAE,QAAQ,EACnB,UAAU,sBAGtB;IAGT,OAAO,CAAC,KAAK;IAIb,mBAAmB,CAAC,eAAe,EAAE,MAAM,GAAG,2BAA2B,EAAE;IAe3E,2BAA2B,CACvB,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,OAAO,EAAE,MAAM,GAChB,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAItB,OAAO,CAAC,IAAI;IAuBZ,qBAAqB,CACjB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,MAAM,GACtB,sBAAsB;IAQzB,sBAAsB,CAClB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,GACd,uBAAuB,EAAE;IAM5B,OAAO,IAAI,IAAI;CAIlB"}

package/dist/v2/rpc-notifications-3hed126v.js

@@ -0,0 +1,16 @@
+import {
+  registerNotificationSink2,
+  pushNotification2,
+  acknowledgeNotifications2,
+  __resetNotificationStateForTests2,
+  drainNotifications2,
+  isTuiConnected2
+} from "./server-x8a7jmkh.js";
+export {
+  __resetNotificationStateForTests2 as __resetNotificationStateForTests,
+  acknowledgeNotifications2 as acknowledgeNotifications,
+  drainNotifications2 as drainNotifications,
+  isTuiConnected2 as isTuiConnected,
+  pushNotification2 as pushNotification,
+  registerNotificationSink2 as registerNotificationSink
+};

package/dist/v2/safe-notification-target-wtj0bbc2.js

@@ -0,0 +1,9 @@
+import {
+  isDefaultSessionTitle2,
+  waitForSafeNotificationTarget2
+} from "./server-5317ykaf.js";
+import"./server-ckpc8pxy.js";
+export {
+  isDefaultSessionTitle2 as isDefaultSessionTitle,
+  waitForSafeNotificationTarget2 as waitForSafeNotificationTarget
+};

package/dist/{send-session-notification-04hvd54c.js → v2/send-session-notification-mq9frrtm.js}

@@ -1,4 +1,6 @@
 import {
+  MAX_QUEUED_IGNORED_NOTIFICATIONS2,
+  __ignoredNotificationTest2,
   setNotificationServerUrl2,
   sendCommandResult2,
   sendIgnoredMessage2,
@@ -6,12 +8,15 @@ import {
   clearIgnoredMessages2,
   observeIgnoredNotificationEvent2,
   sendStatusNotification2
-} from "./index-33q7s9y2.js";
-import"./index-4an2p8qa.js";
-import"./index-kwe03yde.js";
-import"./index-3bygzk2d.js";
-import"./index-s70wtd8k.js";
+} from "./server-z19x7eqz.js";
+import"./server-w99cyt6a.js";
+import"./server-qpg6wf72.js";
+import"./server-a4m2b1yv.js";
+import"./server-5317ykaf.js";
+import"./server-ckpc8pxy.js";
 export {
+  MAX_QUEUED_IGNORED_NOTIFICATIONS2 as MAX_QUEUED_IGNORED_NOTIFICATIONS,
+  __ignoredNotificationTest2 as __ignoredNotificationTest,
   clearIgnoredMessages2 as clearIgnoredMessages,
   flushIgnoredMessages2 as flushIgnoredMessages,
   observeIgnoredNotificationEvent2 as observeIgnoredNotificationEvent,