@cortexkit/pi-magic-context 0.49.19 → 0.49.21

package/dist/{index-msqrs4nf.js → index-3c3ztwgc.js}

@@ -3,12 +3,12 @@ import {
 } from "./index-135e8hvg.js";
 import {
   log2
-} from "./index-7bqrfyny.js";
+} from "./index-fgs78jyd.js";
 import {
   ensureColumn,
   healAllNullColumns,
   installV95PerfSchema
-} from "./index-jrap43gc.js";
+} from "./index-w1avzkdt.js";
 import {
   resolveOpenCodeDbPath,
   openCodeDbPathExists,
@@ -16,14 +16,14 @@ import {
 } from "./index-8976mezv.js";
 import {
   Database2
-} from "./index-rrwv9y2k.js";
+} from "./index-2qtx0q6h.js";
 import {
   normalizeStoredProjectPath,
   storedPathBelongsToIdentity
-} from "./index-g7p75667.js";
+} from "./index-hxp6q5f8.js";
 import {
   logSlowWriteTransaction
-} from "./index-d4dt19md.js";
+} from "./index-hqw0rt9k.js";
 
 // ../plugin/src/features/magic-context/migrations.ts
 import { isMainThread } from "node:worker_threads";

package/dist/index-54wmg4rj.js

@@ -0,0 +1,82 @@
+// ../plugin/src/shared/worker-shutdown.ts
+var WORKER_CLOSE_MESSAGE = { kind: "close" };
+function isWorkerCloseMessage(message) {
+  return typeof message === "object" && message !== null && message.kind === WORKER_CLOSE_MESSAGE.kind;
+}
+function exitOnWorkerClose(port, closeConnections) {
+  const listener = (message) => {
+    if (!isWorkerCloseMessage(message))
+      return;
+    try {
+      closeConnections();
+    } finally {
+      process.exit(0);
+    }
+  };
+  if (!port)
+    return { closePort() {} };
+  port.on("message", listener);
+  let closed = false;
+  return {
+    closePort() {
+      if (closed)
+        return;
+      closed = true;
+      setTimeout(() => {
+        port.off("message", listener);
+        port.close();
+      });
+    }
+  };
+}
+var outcomes = new Map;
+function createWorkerShutdown(worker, site, deadlineMs) {
+  let exited = false;
+  let forced = false;
+  let closing;
+  const exit = new Promise((resolve) => {
+    worker.once("exit", () => {
+      exited = true;
+      resolve();
+    });
+  });
+  const record = () => {
+    const counts = outcomes.get(site) ?? { graceful: 0, forced: 0 };
+    if (forced)
+      counts.forced += 1;
+    else
+      counts.graceful += 1;
+    outcomes.set(site, counts);
+  };
+  const terminate = () => {
+    forced = true;
+    worker.terminate().catch(() => {});
+  };
+  return {
+    close() {
+      if (closing)
+        return closing;
+      if (exited) {
+        closing = Promise.resolve();
+        return closing;
+      }
+      try {
+        worker.postMessage(WORKER_CLOSE_MESSAGE);
+      } catch {
+        terminate();
+      }
+      const fallback = setTimeout(() => {
+        if (!exited)
+          terminate();
+      }, deadlineMs);
+      fallback.unref?.();
+      closing = exit.then(() => {
+        clearTimeout(fallback);
+        record();
+      });
+      return closing;
+    }
+  };
+}
+
+export { isWorkerCloseMessage, exitOnWorkerClose, createWorkerShutdown };

package/dist/{index-yygsh681.js → index-579m1751.js}

@@ -2,13 +2,13 @@ import {
   getSqliteDatabasePath2,
   withSqliteBackgroundWriter2,
   withoutSqliteTransformPass2
-} from "./index-rrwv9y2k.js";
+} from "./index-2qtx0q6h.js";
 import {
   runSessionWarmupWorker
-} from "./index-vktahpdj.js";
+} from "./index-at6py2k3.js";
 import {
   logSlowWriteTransaction
-} from "./index-d4dt19md.js";
+} from "./index-hqw0rt9k.js";
 
 // ../plugin/src/features/magic-context/message-fts-rowid-map.ts
 import { createHash } from "node:crypto";

package/dist/{index-rc1dez8m.js → index-5j6vwg4z.js}

@@ -3,18 +3,139 @@ import {
   tagRevisionCountSql,
   tagRevisionKey,
   TAG_INSERT_CONFLICT_ROWS
-} from "./index-jrap43gc.js";
+} from "./index-w1avzkdt.js";
 import {
   getTagsBySession2,
   getTagsByNumbers2
-} from "./index-rhprywn6.js";
+} from "./index-n8e5e9fp.js";
 import {
   inRootAsyncContext2,
-  getSqliteDatabasePath2
-} from "./index-rrwv9y2k.js";
+  getSqliteDatabasePath2,
+  withSqliteTurnDeadline2
+} from "./index-2qtx0q6h.js";
 import {
   createFailClosedBlockingError
-} from "./index-sqt2haap.js";
+} from "./index-dbgg6hsf.js";
+import {
+  createWorkerShutdown
+} from "./index-54wmg4rj.js";
+
+// src/pi-context-budget.ts
+var PI_CONTEXT_BUDGET = {
+  hostDeadlineMs: 30000,
+  hostMarginMs: 5000,
+  outcomeMs: 25000,
+  fallbackObservedMs: 4,
+  workMs: 21000,
+  writerMs: 16500,
+  completionReserveMs: 2000,
+  searchMs: 3000
+};
+
+class PiContextDeadlineError extends Error {
+}
+
+class PiContextSupersededError extends Error {
+  origin;
+  constructor(message, origin = "context ownership") {
+    super(message);
+    this.origin = origin;
+  }
+}
+
+class PiContextBudget {
+  startedAt;
+  now;
+  sideTurn = false;
+  stage = "entry";
+  recovery = "not attempted";
+  abandoned = false;
+  completed = false;
+  failureReason;
+  signal;
+  cancelled = false;
+  isCancelled(error) {
+    return this.cancelled || this.signal?.aborted === true || !this.signal && typeof error === "object" && error !== null && "name" in error && error.name === "AbortError";
+  }
+  cancel() {
+    this.cancelled = true;
+    this.abandoned = true;
+    this.completed = false;
+    this.failureReason = undefined;
+  }
+  assertOwner = () => {};
+  constructor(startedAt = performance.now(), now = () => performance.now()) {
+    this.startedAt = startedAt;
+    this.now = now;
+  }
+  elapsed() {
+    return this.now() - this.startedAt;
+  }
+  remainingWork = () => {
+    return Math.max(0, PI_CONTEXT_BUDGET.workMs - this.elapsed());
+  };
+  remainingOutcome = () => Math.max(0, PI_CONTEXT_BUDGET.outcomeMs - this.elapsed());
+  writerAllowance() {
+    return Math.max(0, Math.min(PI_CONTEXT_BUDGET.writerMs, this.remainingWork() - PI_CONTEXT_BUDGET.completionReserveMs));
+  }
+  hydrationAllowance() {
+    return Math.max(0, Math.min(this.remainingWork() - PI_CONTEXT_BUDGET.completionReserveMs, this.remainingOutcome() - PI_CONTEXT_BUDGET.completionReserveMs));
+  }
+  assertOutcome = () => {
+    this.assertOwner();
+    this.signal?.throwIfAborted();
+    if (this.abandoned || this.elapsed() >= PI_CONTEXT_BUDGET.outcomeMs)
+      throw new PiContextDeadlineError(this.diagnostic());
+  };
+  assert = () => {
+    this.assertOutcome();
+    if (this.elapsed() >= PI_CONTEXT_BUDGET.workMs)
+      throw new PiContextDeadlineError(this.diagnostic());
+  };
+  assertDecisionPublication = () => {
+    this.signal?.throwIfAborted();
+    if (!this.completed)
+      this.assertOwner();
+    if (this.abandoned || !this.completed && this.elapsed() >= PI_CONTEXT_BUDGET.outcomeMs)
+      throw new PiContextDeadlineError(this.diagnostic());
+  };
+  diagnostic() {
+    return `stage=${this.stage} elapsed=${Math.round(this.elapsed())}ms recovery=${this.recovery}`;
+  }
+  waitUntil = async (pending, assert, remaining) => {
+    try {
+      assert();
+    } catch (error) {
+      pending.catch(() => {});
+      throw error;
+    }
+    let timer;
+    let onAbort;
+    try {
+      return await Promise.race([
+        pending,
+        ...this.signal ? [
+          new Promise((_, reject) => {
+            onAbort = () => reject(this.signal?.reason);
+            this.signal?.addEventListener("abort", onAbort, {
+              once: true
+            });
+          })
+        ] : [],
+        new Promise((_, reject) => {
+          timer = setTimeout(() => reject(new PiContextDeadlineError(this.diagnostic())), remaining());
+        })
+      ]);
+    } finally {
+      clearTimeout(timer);
+      if (onAbort)
+        this.signal?.removeEventListener("abort", onAbort);
+      assert();
+    }
+  };
+  wait = (pending) => this.waitUntil(pending, this.assert, () => this.remainingWork());
+  waitMandatory = (pending) => this.waitUntil(pending, this.assertOutcome, this.remainingOutcome);
+}
 
 // src/tag-snapshot-worker-client-pi.ts
 import { setImmediate as yieldImmediate } from "node:timers/promises";
@@ -228,6 +349,7 @@ function startPiTagSnapshotWorker(request, options = {}) {
   const started = performance.now();
   const consumer = createPiHydrationPacketConsumer(request, options.cached, options.byteLimit);
   const worker = inRootAsyncContext2(() => new Worker(entry, { workerData: request }));
+  const shutdown = createWorkerShutdown(worker, "pi-tag-snapshot", 1000);
   let exited = false;
   let settled = false;
   let consumption = Promise.resolve();
@@ -292,7 +414,7 @@ function startPiTagSnapshotWorker(request, options = {}) {
     clearTimeout(timer);
     rejectResult(error);
     if (!exited)
-      worker.terminate().catch(() => {});
+      shutdown.close();
   }
   const timer = inRootAsyncContext2(() => setTimeout(() => abort(new PiTagHydrationError("job deadline exceeded", "deadline")), options.deadlineMs ?? 1e4));
   timer.unref();
@@ -306,6 +428,13 @@ function createPiTagSnapshotReader(db) {
   const existing = readers.get(db);
   if (existing)
     return existing;
+  const nativeWaiters = new Set;
+  const inSnapshotRoot = (operation) => inRootAsyncContext2(() => withSqliteTurnDeadline2(() => {
+    let remaining = Infinity;
+    for (const waiter of nativeWaiters)
+      remaining = Math.min(remaining, waiter());
+    return remaining;
+  }, operation));
   db.exec(`
 		CREATE TEMP TABLE IF NOT EXISTS pi_tag_revision (revision INTEGER NOT NULL);
 		INSERT INTO pi_tag_revision SELECT 0 WHERE NOT EXISTS (SELECT 1 FROM pi_tag_revision);
@@ -399,7 +528,8 @@ function createPiTagSnapshotReader(db) {
   const ownFirstAllocation = db.prepare(`SELECT 1 FROM pi_tag_first_allocation allocation
 		WHERE session_id = ? AND seen = 1 AND incarnation || ':0' = ?
 		AND EXISTS (SELECT 1 FROM pi_tag_watch WHERE session_id = allocation.session_id)
-		AND EXISTS (SELECT 1 FROM pi_tag_first_rows WHERE session_id = allocation.session_id)
+		AND EXISTS (SELECT 1 FROM pi_tag_changes WHERE session_id = allocation.session_id)
+		AND (? = 'legacy' OR EXISTS (SELECT 1 FROM pi_tag_first_rows WHERE session_id = allocation.session_id))
 		AND NOT EXISTS (SELECT 1 FROM pi_tag_first_rows first_row WHERE first_row.session_id = allocation.session_id
 		AND NOT EXISTS (SELECT 1 FROM pi_tag_changes change WHERE change.session_id = first_row.session_id AND change.tag_number IS first_row.tag_number))`);
   const managed = new Set;
@@ -410,6 +540,7 @@ function createPiTagSnapshotReader(db) {
   let desiredSession;
   let failedUntil = 0;
   let lastFailure;
+  let failedSession;
   const totalRevision = db.prepare("SELECT COALESCE(value, '0') AS revision, value IS NOT NULL AS present FROM (SELECT 1) LEFT JOIN schema_migrations_meta ON key = ?");
   const assertOutsideTransaction = () => {
     const connection = db;
@@ -454,7 +585,7 @@ function createPiTagSnapshotReader(db) {
     if (current?.sessionId === sessionId)
       current.cancel();
   };
-  const load = (sessionId) => inRootAsyncContext2(async () => {
+  const load = (sessionId) => inSnapshotRoot(async () => {
     managed.add(sessionId);
     if (ready(sessionId))
       return;
@@ -468,7 +599,7 @@ function createPiTagSnapshotReader(db) {
         throw new PiTagHydrationError("session hydration superseded", "stale");
       return load(sessionId);
     }
-    if (performance.now() < failedUntil)
+    if (failedSession === sessionId && performance.now() < failedUntil)
       throw lastFailure;
     watch.run(sessionId);
     const token = stamps(sessionId, ++jobId);
@@ -512,7 +643,7 @@ function createPiTagSnapshotReader(db) {
       if (current !== destination || desiredSession !== sessionId || !samePiTagSnapshotToken(token, live) || token.totalRevision !== live.totalRevision || generation.revision !== token.totalRevision || generation.durable !== token.durableVersion)
         throw new PiTagHydrationError("owner generation or lifetime changed", "stale");
       const snapshot = {
-        firstAllocationPending: !live.revisionPresent && candidate.tags.length === 0 && !db.prepare("SELECT 1 FROM tags WHERE session_id = ? LIMIT 1").get(sessionId),
+        firstAllocationPending: live.revisionPresent ? undefined : candidate.tags.length === 0 && !db.prepare("SELECT 1 FROM tags WHERE session_id = ? LIMIT 1").get(sessionId) ? "empty" : "legacy",
         revision: legacyFallbackOnly ? previous.revision : live.localRevision,
         foreignRevision: live.foreignRevision,
         tags: legacyFallbackOnly ? previous.tags : candidate.tags,
@@ -541,6 +672,7 @@ function createPiTagSnapshotReader(db) {
       if (error instanceof PiTagHydrationError && error.code === "stale")
         destination.stale = true;
       if (current === destination && desiredSession === sessionId && token.sessionEpoch === (sessionEpochs.get(sessionId) ?? 0)) {
+        failedSession = sessionId;
         lastFailure = error;
         failedUntil = performance.now() + (error instanceof PiTagHydrationError && error.code === "stale" ? 0 : 500);
       }
@@ -558,6 +690,12 @@ function createPiTagSnapshotReader(db) {
   owners.set(db, {
     ready,
     load,
+    addNativeWaiter: (remaining) => {
+      nativeWaiters.add(remaining);
+      return () => {
+        nativeWaiters.delete(remaining);
+      };
+    },
     manage: (sessionId) => managed.add(sessionId),
     cancel
   });
@@ -574,9 +712,9 @@ function createPiTagSnapshotReader(db) {
     ];
     const stamp = versionStamp.get(sessionId, sessionId);
     let snapshot = cache.get(sessionId);
-    if (snapshot?.firstAllocationPending && snapshot.foreignRevision !== external && snapshot.revision !== local && stamp.durable - snapshot.durableVersion === stamp.own - snapshot.ownVersion && ownFirstAllocation.get(sessionId, external)) {
+    if (snapshot?.firstAllocationPending && snapshot.foreignRevision !== external && snapshot.revision !== local && stamp.durable - snapshot.durableVersion === stamp.own - snapshot.ownVersion && ownFirstAllocation.get(sessionId, external, snapshot.firstAllocationPending)) {
       snapshot.foreignRevision = external;
-      snapshot.firstAllocationPending = false;
+      snapshot.firstAllocationPending = undefined;
       db.prepare("DELETE FROM pi_tag_first_watch WHERE session_id = ?").run(sessionId);
       db.prepare("DELETE FROM pi_tag_first_rows WHERE session_id = ?").run(sessionId);
     }
@@ -658,6 +796,7 @@ function createPiTagSnapshotReader(db) {
     writable: true,
     value: (...args) => {
       desiredSession = undefined;
+      nativeWaiters.clear();
       current?.cancel();
       cache.clear();
       entryReaders.delete(db);
@@ -881,6 +1020,7 @@ function ensurePiTagSnapshotReady(db, sessionId, budget) {
       if (allowance <= 0)
         throw new PiTagHydrationError("remaining pass budget exhausted waiting for tag snapshot; turn not sent, retry", "deadline");
       let timer;
+      const releaseNativeWaiter = owner.addNativeWaiter(() => budget.remainingOutcome() - PI_CONTEXT_BUDGET.completionReserveMs);
       try {
         await budget.wait(Promise.race([
           owner.load(sessionId),
@@ -897,9 +1037,10 @@ function ensurePiTagSnapshotReady(db, sessionId, budget) {
           throw error;
       } finally {
         clearTimeout(timer);
+        releaseNativeWaiter();
       }
     }
   })();
 }
 
-export { encodePiHydrationOperation, PiTagHydrationError, PI_FALLBACK_ROW_COLUMNS, PI_FALLBACK_ROW_PREDICATE, getPiTagSnapshotView, getPiActiveTagSnapshotView, readPiFallbackTagRows, prewarmPiTagSnapshot, cancelPiTagSnapshotSession, drainPiTagSnapshotSession, assertPiTagSnapshotReady, ensurePiTagSnapshotReady };
+export { PI_CONTEXT_BUDGET, PiContextDeadlineError, PiContextSupersededError, PiContextBudget, encodePiHydrationOperation, PiTagHydrationError, PI_FALLBACK_ROW_COLUMNS, PI_FALLBACK_ROW_PREDICATE, getPiTagSnapshotView, getPiActiveTagSnapshotView, readPiFallbackTagRows, prewarmPiTagSnapshot, cancelPiTagSnapshotSession, drainPiTagSnapshotSession, assertPiTagSnapshotReady, ensurePiTagSnapshotReady };

package/dist/{index-qpq6w67c.js → index-6wdwv3a6.js}

@@ -3,11 +3,11 @@ import {
 } from "./index-399p688g.js";
 import {
   log2
-} from "./index-7bqrfyny.js";
+} from "./index-fgs78jyd.js";
 import {
   inRootAsyncContext2,
   getSqliteDatabasePath2
-} from "./index-rrwv9y2k.js";
+} from "./index-2qtx0q6h.js";
 
 // ../plugin/src/features/magic-context/compaction-marker-candidates.ts
 import { existsSync, realpathSync } from "node:fs";

package/dist/{index-vktahpdj.js → index-at6py2k3.js}

@@ -2,13 +2,16 @@ import {
   inRootAsyncContext2,
   getSqliteDatabasePath2,
   releaseIndexOwner2
-} from "./index-rrwv9y2k.js";
+} from "./index-2qtx0q6h.js";
 import {
   registerExitAbort
 } from "./index-399p688g.js";
 import {
   log2
-} from "./index-7bqrfyny.js";
+} from "./index-fgs78jyd.js";
+import {
+  createWorkerShutdown
+} from "./index-54wmg4rj.js";
 
 // ../plugin/src/hooks/magic-context/read-session-raw.ts
 import { isMainThread } from "node:worker_threads";
@@ -17,6 +20,7 @@ import { isMainThread } from "node:worker_threads";
 import { Worker } from "node:worker_threads";
 var ACCEPT_TIMEOUT_MS = 2000;
 var RESULT_TIMEOUT_MS = 10 * 60000;
+var WARMUP_CLOSE_DEADLINE_MS = 2000;
 var FAILURE_BACKOFF_MS = 5 * 60000;
 var inFlight = new Map;
 var connectionIds = new WeakMap;
@@ -45,6 +49,7 @@ function runSessionWarmupWorker(input, options) {
   return new Promise((resolve) => {
     const openCancellation = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
     let worker;
+    let shutdown;
     let deadline;
     let settled = false;
     const finish = (result) => {
@@ -56,7 +61,7 @@ function runSessionWarmupWorker(input, options) {
       options.signal?.removeEventListener("abort", abort);
       if (worker) {
         activeWorkers.delete(worker);
-        const stopped = worker.terminate();
+        const stopped = shutdown?.close() ?? worker.terminate();
         worker.unref();
         stopped.finally(() => {
           releaseIndexOwner2(input);
@@ -82,6 +87,7 @@ function runSessionWarmupWorker(input, options) {
       worker = inRootAsyncContext2(() => new Worker(options.entry ?? defaultEntry(), {
         workerData: { ...input, openCancellation: openCancellation.buffer }
       }));
+      shutdown = createWorkerShutdown(worker, "raw-ordinal-warmup", WARMUP_CLOSE_DEADLINE_MS);
     } catch (error) {
       finish({ failure: "start-failed", detail: String(error) });
       return;