@askexenow/exe-os 0.9.322 → 0.9.324

package/dist/{chunk-AZL3EUR3.js → chunk-KK67DSCO.js}

@@ -1,29 +1,28 @@
 import {
   recordSessionKill
-} from "./chunk-G5TP2D2U.js";
+} from "./chunk-EWDTTTZP.js";
 import {
   updateTask
-} from "./chunk-7SDS5VCL.js";
+} from "./chunk-ZDNJ3TSB.js";
 import {
+  countPendingReviews,
   ensureEmployeeAsync,
   extractRootExe,
   getSessionState,
   isExeSession,
   queryTaskRows,
+  queueIntercom,
   sendIntercomAsync,
   sessionScopeFilter,
   strictSessionScopeFilter,
   writeNotification
-} from "./chunk-PLBDXCYZ.js";
-import {
-  queueIntercom
-} from "./chunk-4FVVJ7ME.js";
+} from "./chunk-KUJGADX6.js";
 import {
   isLeaseExpired
 } from "./chunk-E23LNUWJ.js";
 import {
   listSessions
-} from "./chunk-ABGDTMKC.js";
+} from "./chunk-JRD7ARQ6.js";
 import {
   listTmuxSessions,
   parseContextPercentage
@@ -33,16 +32,16 @@ import {
 } from "./chunk-RMOBQ6A5.js";
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-HV5CUDOE.js";
+} from "./chunk-F6TJIWN5.js";
 import {
   getAgentRuntime
-} from "./chunk-QVFJCFNM.js";
+} from "./chunk-FROUDYRT.js";
 import {
   baseAgentName,
   getCoordinatorName,
   isCoordinatorName,
   shouldAutoInstance
-} from "./chunk-XLNF3CIO.js";
+} from "./chunk-QGOMYIVT.js";
 import {
   loadConfigSync
 } from "./chunk-7Y5UDEVM.js";
@@ -53,7 +52,7 @@ import { promisify } from "util";
 import { randomUUID } from "crypto";
 import { existsSync as existsSync2, readFileSync, writeFileSync, unlinkSync, statSync as statSync2 } from "fs";
 import { homedir, loadavg, freemem, cpus as osCpus, platform } from "os";
-import { join } from "path";
+import { join, basename } from "path";
 
 // src/lib/agent-signals.ts
 import { existsSync, openSync, closeSync, readSync, statSync } from "fs";
@@ -432,6 +431,12 @@ async function pollIdleKill(deps, idleTickCounts, opts) {
   return killed;
 }
 var REVIEW_NUDGE_COOLDOWN_MS = 3e5;
+var REVIEW_RENUDGE_INTERVAL_MS = Number(process.env.EXE_REVIEW_RENUDGE_MS) || 30 * 60 * 1e3;
+var DEAD_SCOPE_REVIEW_ALERT_MS = 60 * 60 * 1e3;
+var _deadScopeReviewAlertAt = /* @__PURE__ */ new Map();
+function _resetDeadScopeReviewAlerts() {
+  _deadScopeReviewAlertAt.clear();
+}
 async function pollReviewNudge(deps, state) {
   let sessions;
   try {
@@ -440,9 +445,57 @@ async function pollReviewNudge(deps, state) {
     process.stderr.write("[daemon-orch] list tmux sessions for review nudge: " + (e instanceof Error ? e.message : String(e)) + "\n");
     return [];
   }
-  if (sessions.length === 0) return [];
   const nudged = [];
   const now = Date.now();
+  const deadExtraBySession = /* @__PURE__ */ new Map();
+  if (deps.listDeadScopeReviewCounts) {
+    let deadRows = [];
+    try {
+      deadRows = await deps.listDeadScopeReviewCounts(sessions);
+    } catch (e) {
+      process.stderr.write("[daemon-orch] list dead-scope review counts: " + (e instanceof Error ? e.message : String(e)) + "\n");
+    }
+    for (const row of deadRows) {
+      if (row.count <= 0) continue;
+      let attributed = null;
+      if (row.projectName && deps.getSessionProjectDir) {
+        for (const s of sessions) {
+          let dir = null;
+          try {
+            dir = deps.getSessionProjectDir(s);
+          } catch {
+            dir = null;
+          }
+          if (dir && basename(dir) === row.projectName) {
+            attributed = s;
+            break;
+          }
+        }
+      }
+      if (attributed) {
+        deadExtraBySession.set(attributed, (deadExtraBySession.get(attributed) ?? 0) + row.count);
+        process.stderr.write(
+          `[review-nudge] ${row.count} review(s) scoped to dead coordinator "${row.scope}" folded into live coordinator "${attributed}" (project "${row.projectName}")
+`
+        );
+      } else {
+        const lastAlert = _deadScopeReviewAlertAt.get(row.scope) ?? 0;
+        if (now - lastAlert < DEAD_SCOPE_REVIEW_ALERT_MS) continue;
+        _deadScopeReviewAlertAt.set(row.scope, now);
+        process.stderr.write(
+          `[review-nudge] ORPHANED REVIEWS: ${row.count} pending review(s) scoped to DEAD coordinator "${row.scope}" (project "${row.projectName ?? "unknown"}") \u2014 no live coordinator matches; re-scope or close them
+`
+        );
+        if (deps.notifyDeadScopeReviews) {
+          try {
+            await deps.notifyDeadScopeReviews(row.scope, row.count, row.projectName ?? null);
+          } catch (e) {
+            process.stderr.write("[daemon-orch] notify dead-scope reviews: " + (e instanceof Error ? e.message : String(e)) + "\n");
+          }
+        }
+      }
+    }
+  }
   for (const exeSession of sessions) {
     const prev = state.lastNudge.get(exeSession);
     if (prev && now - prev.at < REVIEW_NUDGE_COOLDOWN_MS) continue;
@@ -455,8 +508,11 @@ async function pollReviewNudge(deps, state) {
       process.stderr.write("[daemon-orch] count reviews for scope: " + (e instanceof Error ? e.message : String(e)) + "\n");
       continue;
     }
+    count += deadExtraBySession.get(exeSession) ?? 0;
     if (count === 0) continue;
-    if (prev && prev.count === count) continue;
+    const countChanged = !prev || prev.count !== count;
+    const renudgeDue = prev !== void 0 && now - prev.at > REVIEW_RENUDGE_INTERVAL_MS;
+    if (!countChanged && !renudgeDue) continue;
     try {
       deps.sendNudge(exeSession);
       state.lastNudge.set(exeSession, { at: now, count });
@@ -499,15 +555,48 @@ function createReviewNudgeRealDeps(_getClient) {
     listTmuxSessions: () => listTmuxSessions(),
     getSessionState: (sessionName) => getSessionState(sessionName),
     countReviewsForScope: async (sessionScope) => {
+      return countPendingReviews(sessionScope, getCoordinatorName());
+    },
+    listDeadScopeReviewCounts: async (liveScopes) => {
       const rows = await queryTaskRows({
         status: "needs_review",
-        columns: "COUNT(*) as cnt",
-        sessionScope,
+        columns: "session_scope, project_name",
+        sessionScope: null,
         projectName: null,
-        limit: 1,
+        limit: 1e3,
         orderBy: "1"
       });
-      return Number(rows[0]?.cnt ?? 0);
+      const live = new Set(liveScopes);
+      const acc = /* @__PURE__ */ new Map();
+      for (const r of rows) {
+        const scope = r.session_scope ? String(r.session_scope) : null;
+        if (!scope || live.has(scope)) continue;
+        const projectName = r.project_name ? String(r.project_name) : null;
+        const key = `${scope}::${projectName ?? ""}`;
+        const cur = acc.get(key);
+        if (cur) cur.count++;
+        else acc.set(key, { scope, projectName, count: 1 });
+      }
+      return [...acc.values()];
+    },
+    getSessionProjectDir: (sessionName) => {
+      try {
+        const entry = listSessions().find((s) => s.windowName === sessionName);
+        return entry?.projectDir ?? null;
+      } catch {
+        return null;
+      }
+    },
+    notifyDeadScopeReviews: async (scope, count, projectName) => {
+      await writeNotification({
+        agentId: getCoordinatorName(),
+        agentRole: "coordinator",
+        event: "orphan_task",
+        project: projectName ?? "",
+        summary: `\u26A0\uFE0F ${count} pending review(s) scoped to dead coordinator session "${scope}" (project "${projectName ?? "unknown"}") \u2014 no live coordinator matches. Re-scope or close them; they are invisible to every live lane.`,
+        // NULL scope on purpose: visible to any coordinator lane, since the owning lane is dead.
+        sessionScope: null
+      });
     },
     sendNudge: (sessionName) => {
       queueIntercom(sessionName, "review nudge: pending reviews", "completion");
@@ -611,6 +700,7 @@ function createIdleKillRealDeps(getClient, intercomAckWindowMs) {
 }
 var AUTO_WAKE_COOLDOWN_MS = 5 * 60 * 1e3;
 var AUTO_WAKE_MAX_RETRIES = 3;
+var DEAD_SCOPE_SKIP_THRESHOLD = 10;
 var AUTO_WAKE_STATE_PATH = join(homedir(), ".exe-os", "session-cache", "auto-wake-state.json");
 var CRASH_LOOP_WINDOW_MS = 15 * 60 * 1e3;
 var CRASH_LOOP_THRESHOLD = 3;
@@ -627,12 +717,13 @@ function loadAutoWakeState() {
         taskRetries: raw.taskRetries ?? {},
         recentSpawns: raw.recentSpawns ?? {},
         crashLoopCount: raw.crashLoopCount ?? {},
+        deadScopeSkips: raw.deadScopeSkips ?? {},
         lastSaved: raw.lastSaved ?? 0
       };
     }
   } catch {
   }
-  return { lastSpawn: {}, taskRetries: {}, recentSpawns: {}, crashLoopCount: {}, lastSaved: 0 };
+  return { lastSpawn: {}, taskRetries: {}, recentSpawns: {}, crashLoopCount: {}, deadScopeSkips: {}, lastSaved: 0 };
 }
 var AUTO_WAKE_STATE_MAX_ENTRIES = Number(process.env.EXE_AUTOWAKE_STATE_MAX_ENTRIES) || 500;
 function pruneAutoWakeMap(map) {
@@ -645,6 +736,7 @@ function pruneAutoWakeState(state) {
   pruneAutoWakeMap(state.taskRetries);
   pruneAutoWakeMap(state.recentSpawns);
   pruneAutoWakeMap(state.crashLoopCount);
+  pruneAutoWakeMap(state.deadScopeSkips);
 }
 function saveAutoWakeState(state) {
   try {
@@ -674,7 +766,7 @@ var _autoWakeRecentSpawns = {
   }
 };
 function _resetAutoWakeState() {
-  _autoWakeState = { lastSpawn: {}, taskRetries: {}, recentSpawns: {}, crashLoopCount: {}, lastSaved: 0 };
+  _autoWakeState = { lastSpawn: {}, taskRetries: {}, recentSpawns: {}, crashLoopCount: {}, deadScopeSkips: {}, lastSaved: 0 };
   try {
     unlinkSync(AUTO_WAKE_STATE_PATH);
   } catch {
@@ -790,6 +882,7 @@ async function pollOrphanedTasks(deps, nowMs = Date.now()) {
   const coordinatorSet = new Set(coordinatorSessions);
   const VALID_SESSION_SCOPE = /^[a-zA-Z0-9_]+$/;
   const agentTasks = /* @__PURE__ */ new Map();
+  let deadScopeStateDirty = false;
   for (const t of tasksByAgent) {
     const rawScope = t.sessionScope;
     if (rawScope && !VALID_SESSION_SCOPE.test(rawScope)) {
@@ -812,17 +905,110 @@ async function pollOrphanedTasks(deps, nowMs = Date.now()) {
     }
     if (!scope) continue;
     if (t.sessionScope && !coordinatorSet.has(t.sessionScope)) {
-      process.stderr.write(
-        `[auto-wake] Skipping ${t.agentId} task ${t.taskId} \u2014 coordinator session "${t.sessionScope}" is dead
+      const deadScope = t.sessionScope;
+      const skips = (_autoWakeState.deadScopeSkips[t.taskId] ?? 0) + 1;
+      _autoWakeState.deadScopeSkips[t.taskId] = skips;
+      deadScopeStateDirty = true;
+      if (skips < DEAD_SCOPE_SKIP_THRESHOLD) {
+        process.stderr.write(
+          `[auto-wake] Skipping ${t.agentId} task ${t.taskId} \u2014 coordinator session "${deadScope}" is dead (skip ${skips}/${DEAD_SCOPE_SKIP_THRESHOLD} before escalation)
 `
-      );
-      continue;
+        );
+        continue;
+      }
+      const taskProject = t.projectName ?? null;
+      let reparented = false;
+      if (taskProject && deps.reparentTask && deps.listRegisteredSessions) {
+        try {
+          let registry = [];
+          try {
+            registry = deps.listRegisteredSessions();
+          } catch {
+            registry = [];
+          }
+          const matches = coordinatorSessions.filter((cs) => {
+            const entry = registry.find((r) => r.windowName === cs);
+            return Boolean(entry?.projectDir) && basename(entry.projectDir) === taskProject;
+          });
+          if (matches.length === 1) {
+            const newScope = matches[0];
+            await deps.reparentTask(t.taskId, newScope);
+            delete _autoWakeState.deadScopeSkips[t.taskId];
+            process.stderr.write(
+              `[auto-wake] RE-PARENTED task ${t.taskId} (${t.agentId}): dead coordinator "${deadScope}" \u2192 live coordinator "${newScope}" \u2014 project "${taskProject}" matched exactly one live coordinator after ${skips} skipped ticks
+`
+            );
+            recordOrchestrationEventBestEffort({
+              eventType: "auto_wake.dead_scope_reparented",
+              source: "daemon-orchestration.pollOrphanedTasks",
+              severity: "warn",
+              agentId: t.agentId,
+              sessionScope: newScope,
+              payload: { taskId: t.taskId, deadScope, project: taskProject, skips }
+            });
+            t.sessionScope = newScope;
+            scope = newScope;
+            reparented = true;
+          } else {
+            process.stderr.write(
+              `[auto-wake] Cannot re-parent task ${t.taskId} from dead scope "${deadScope}" \u2014 ${matches.length} live coordinator(s) match project "${taskProject}" (need exactly 1)
+`
+            );
+          }
+        } catch (e) {
+          process.stderr.write("[daemon-orch] re-parent dead-scope task: " + (e instanceof Error ? e.message : String(e)) + "\n");
+        }
+      }
+      if (!reparented) {
+        try {
+          const routed = await routeUnrecoverableTask(
+            deps,
+            t.taskId,
+            `Coordinator session "${deadScope}" is dead \u2014 auto-wake skipped ${skips} ticks and no unique live coordinator matches this project. Deliverable present; needs manual review.`,
+            `Coordinator session "${deadScope}" is dead \u2014 auto-wake skipped ${skips} ticks and no unique live coordinator matches this project. Blocked for manual re-dispatch.`
+          );
+          delete _autoWakeState.deadScopeSkips[t.taskId];
+          process.stderr.write(
+            `[auto-wake] DEAD-SCOPE ESCALATION: task ${t.taskId} (${t.agentId}) scoped to dead coordinator "${deadScope}" marked ${routed} after ${skips} skipped ticks
+`
+          );
+          recordOrchestrationEventBestEffort({
+            eventType: "auto_wake.dead_scope_unrecoverable",
+            source: "daemon-orchestration.pollOrphanedTasks",
+            severity: "warn",
+            agentId: t.agentId,
+            sessionScope: deadScope,
+            payload: { taskId: t.taskId, routed, project: taskProject, skips }
+          });
+          try {
+            const attention = routed === "blocked" ? "needs re-dispatch" : "needs review";
+            await writeNotification({
+              agentId: t.agentId,
+              agentRole: "employee",
+              event: "orphan_task",
+              project: taskProject ?? "",
+              summary: `\u26A0\uFE0F Task ${t.taskId} (${t.agentId}) was scoped to dead coordinator "${deadScope}" \u2014 marked ${routed} after ${skips} skipped auto-wake ticks; ${attention}.`,
+              // Deliver to a live coordinator lane so it is actually seen;
+              // NULL scope (visible everywhere) when no coordinator is live.
+              sessionScope: coordinatorSessions[0] ?? null
+            });
+          } catch {
+          }
+        } catch (e) {
+          process.stderr.write("[daemon-orch] dead-scope escalation failed for task " + t.taskId + ": " + (e instanceof Error ? e.message : String(e)) + "\n");
+        }
+        continue;
+      }
+    } else if (_autoWakeState.deadScopeSkips[t.taskId] !== void 0) {
+      delete _autoWakeState.deadScopeSkips[t.taskId];
+      deadScopeStateDirty = true;
     }
     const key = `${t.agentId}::${scope}`;
     const existing = agentTasks.get(key) ?? [];
     existing.push({ taskId: t.taskId, priority: t.priority, sessionScope: scope });
     agentTasks.set(key, existing);
   }
+  if (deadScopeStateDirty) saveAutoWakeState(_autoWakeState);
   const woken = [];
   for (const [key, tasks] of agentTasks) {
     const agentId = key.split("::")[0];
@@ -1238,7 +1424,7 @@ function createAutoWakeRealDeps(getClient, projectDir) {
       const deviceId = loadDeviceId();
       const rows = await queryTaskRows({
         status: ["open", "in_progress"],
-        columns: "assigned_to, id, priority, session_scope",
+        columns: "assigned_to, id, priority, session_scope, project_name",
         sessionScope: null,
         // daemon-level: no session filter
         projectName: null,
@@ -1250,9 +1436,19 @@ function createAutoWakeRealDeps(getClient, projectDir) {
         agentId: String(r.assigned_to),
         taskId: String(r.id),
         priority: String(r.priority),
-        sessionScope: r.session_scope ? String(r.session_scope) : null
+        sessionScope: r.session_scope ? String(r.session_scope) : null,
+        projectName: r.project_name ? String(r.project_name) : null
       }));
     },
+    // C1: registry lookup + re-parent for dead-scope escalation.
+    listRegisteredSessions: () => listSessions(),
+    reparentTask: async (taskId, newSessionScope) => {
+      const client = getClient();
+      await client.execute({
+        sql: `UPDATE tasks SET session_scope = ?, updated_at = ? WHERE id = ?`,
+        args: [newSessionScope, (/* @__PURE__ */ new Date()).toISOString(), taskId]
+      });
+    },
     ensureEmployee: async (agentName, scope) => {
       let resolvedProjectDir = projectDir;
       try {
@@ -2014,9 +2210,9 @@ async function reapOrphanedWorktrees(deps, nowMs = Date.now()) {
 }
 async function createWorktreeReaperRealDeps() {
   const { getPaneCwdAsync } = await import("./lib/tmux-status.js");
-  const { getGitRoot, isWorktreeDirty: isDirty } = await import("./worktree-OYGDGJP7.js");
+  const { getGitRoot, isWorktreeDirty: isDirty } = await import("./worktree-72QYYL5L.js");
   const { statSync: statSync3 } = await import("fs");
-  const { basename } = await import("path");
+  const { basename: basename2 } = await import("path");
   const { promisify: promisify2 } = await import("util");
   const { execFile: execFileCb } = await import("child_process");
   const execFileAsync2 = promisify2(execFileCb);
@@ -2105,7 +2301,7 @@ async function createWorktreeReaperRealDeps() {
       }
     },
     parseAgentFromWorktreePath: (wtPath) => {
-      const dirName = basename(wtPath);
+      const dirName = basename2(wtPath);
       if (!dirName) return null;
       return baseAgentName(dirName);
     },
@@ -2198,7 +2394,7 @@ async function gcStaleCheckpoints() {
 }
 async function pollTaskGroupBarriers() {
   try {
-    const { checkAndFireBarriers } = await import("./tasks-crud-QUIIRWE3.js");
+    const { checkAndFireBarriers } = await import("./tasks-crud-6SJOKES5.js");
     const firedGroupIds = await checkAndFireBarriers();
     if (firedGroupIds.length === 0) return 0;
     const { getClient } = await import("./lib/database.js");
@@ -2280,6 +2476,9 @@ export {
   checkSessionTTL,
   pollIdleKill,
   REVIEW_NUDGE_COOLDOWN_MS,
+  REVIEW_RENUDGE_INTERVAL_MS,
+  DEAD_SCOPE_REVIEW_ALERT_MS,
+  _resetDeadScopeReviewAlerts,
   pollReviewNudge,
   loadNudgeState,
   saveNudgeState,
@@ -2289,6 +2488,7 @@ export {
   createIdleKillRealDeps,
   AUTO_WAKE_COOLDOWN_MS,
   AUTO_WAKE_MAX_RETRIES,
+  DEAD_SCOPE_SKIP_THRESHOLD,
   CRASH_LOOP_WINDOW_MS,
   CRASH_LOOP_THRESHOLD,
   pruneAutoWakeState,

package/dist/{chunk-H2SD2EA7.js → chunk-KLDQFOFY.js}

@@ -9,7 +9,7 @@ import {
   findScopedDuplicate,
   governMemoryRecord,
   schedulePostWriteMemoryHygiene
-} from "./chunk-SIJSFULW.js";
+} from "./chunk-TSYMWC53.js";
 import {
   orgBus
 } from "./chunk-MP2AFCGL.js";
@@ -18,7 +18,7 @@ import {
   ensureSchema,
   getClient,
   initTurso
-} from "./chunk-XLNF3CIO.js";
+} from "./chunk-QGOMYIVT.js";
 import {
   EMBEDDING_DIM
 } from "./chunk-FXU7JOXK.js";
@@ -68,7 +68,7 @@ function recordShardFailure(project, error) {
       `[store] Shard circuit OPEN for "${project}" after ${state.failures} consecutive failures. Will retry in ${SHARD_CB_COOLDOWN_MS / 6e4}min. Last error: ${error}
 `
     );
-    void import("./orchestration-events-O5P5NEKS.js").then(({ recordOrchestrationEventBestEffort }) => {
+    void import("./orchestration-events-KVNRNIPR.js").then(({ recordOrchestrationEventBestEffort }) => {
       recordOrchestrationEventBestEffort({
         eventType: "shard.circuit_open",
         source: "store.recordShardFailure",
@@ -165,7 +165,7 @@ async function initStore(options) {
     );
     _nextVersion = (Number(vResult.rows[0]?.max_v) || 0) + 1;
     try {
-      const { loadGlobalProcedures } = await import("./global-procedures-FNUKY2LF.js");
+      const { loadGlobalProcedures } = await import("./global-procedures-76NDWTYN.js");
       await loadGlobalProcedures();
     } catch (e) {
       logStoreWarn("catch", e);
@@ -293,7 +293,7 @@ async function writeMemory(record) {
     founder_id: record.founder_id ?? null
   };
   try {
-    const { checkMemoryPoisoning } = await import("./memory-poisoning-defense-3CYFKNLA.js");
+    const { checkMemoryPoisoning } = await import("./memory-poisoning-defense-M3LOQ3XU.js");
     const poisonResult = await checkMemoryPoisoning({
       memoryId: dbRow.id,
       vector: Array.isArray(dbRow.vector) ? dbRow.vector : void 0,
@@ -486,19 +486,19 @@ async function flushBatch() {
     }
     _nextVersion = baseVersion;
     try {
-      const { insertMemoryCardsForBatch } = await import("./memory-cards-MGZ4P3AA.js");
+      const { insertMemoryCardsForBatch } = await import("./memory-cards-6NGUDUDN.js");
       await insertMemoryCardsForBatch(batch);
     } catch (e) {
       logStoreWarn("catch", e);
     }
     try {
-      const { insertOntologyForBatch } = await import("./agentic-ontology-HQKCU7LG.js");
+      const { insertOntologyForBatch } = await import("./agentic-ontology-2QFPBIQP.js");
       await insertOntologyForBatch(batch);
     } catch (e) {
       logStoreWarn("catch", e);
     }
     try {
-      const { extractGraphForBatch } = await import("./memory-graph-extractor-44P2ATID.js");
+      const { extractGraphForBatch } = await import("./memory-graph-extractor-FIMS3VQR.js");
       await extractGraphForBatch(batch);
     } catch (e) {
       logStoreWarn("catch", e);
@@ -629,7 +629,7 @@ async function searchMemories(queryVector, agentId, options) {
     args.push(activeEmbeddingModel);
   }
   try {
-    const { founderScopeFilter } = await import("./founder-context-J362DNU4.js");
+    const { founderScopeFilter } = await import("./founder-context-FYTF4IMD.js");
     const founderFilter = founderScopeFilter(options?.founderId);
     sql += founderFilter.sql;
     args.push(...founderFilter.args.filter((a) => a !== null));
@@ -787,6 +787,20 @@ async function updateMemoryStatus(id, status) {
 }
 async function reserveVersions(count) {
   const client = getClient();
+  const interactiveTx = client.interactiveTransactions !== false;
+  if (!interactiveTx) {
+    const vResult = await client.execute("SELECT COALESCE(MAX(version), 0) as max_v FROM memories");
+    let baseVersion = (Number(vResult.rows[0]?.max_v) || 0) + 1;
+    if (_nextVersion > baseVersion) {
+      baseVersion = _nextVersion;
+    }
+    const reserved = [];
+    for (let i = 0; i < count; i++) {
+      reserved.push(baseVersion + i);
+    }
+    _nextVersion = baseVersion + count;
+    return reserved;
+  }
   await client.execute("BEGIN IMMEDIATE");
   try {
     const vResult = await client.execute("SELECT COALESCE(MAX(version), 0) as max_v FROM memories");

package/dist/chunk-KPIN44GZ.js

@@ -0,0 +1,67 @@
+import {
+  MODELS_DIR,
+  loadConfigSync,
+  resolveEmbedModelFile
+} from "./chunk-7Y5UDEVM.js";
+
+// src/lib/backfill-gate.ts
+import { existsSync } from "fs";
+import path from "path";
+function backfillKillSwitchEnabled(env = process.env) {
+  const v = env.EXE_DISABLE_BACKFILL;
+  return v === "1" || v === "true";
+}
+var PARKED_EMBEDDING_MODEL_PREFIX = "parked:";
+var PARKED_EMBEDDING_MODEL = `${PARKED_EMBEDDING_MODEL_PREFIX}embed-failed`;
+var NOT_PARKED_SQL = `(embedding_model IS NULL OR embedding_model NOT LIKE '${PARKED_EMBEDDING_MODEL_PREFIX}%')`;
+async function countActionableNullVectors(client) {
+  try {
+    const res = await client.execute(
+      `SELECT COUNT(*) as cnt FROM memories WHERE vector IS NULL AND ${NOT_PARKED_SQL}`
+    );
+    return Number(res.rows[0]?.cnt) || 0;
+  } catch {
+    const res = await client.execute("SELECT COUNT(*) as cnt FROM memories WHERE vector IS NULL");
+    return Number(res.rows[0]?.cnt) || 0;
+  }
+}
+function computeBackfillDisabled(totalGB, oomMarkerPath, env = process.env) {
+  if (backfillKillSwitchEnabled(env)) {
+    return { disabled: true, reason: "EXE_DISABLE_BACKFILL kill-switch is set" };
+  }
+  if (totalGB <= 8) {
+    return { disabled: true, reason: `host RAM ${totalGB.toFixed(1)} GB <= 8 GB` };
+  }
+  if (existsSync(oomMarkerPath)) {
+    return { disabled: true, reason: "embedding OOM marker present" };
+  }
+  if (env.EXE_SERVER_MODE === "1") {
+    return { disabled: true, reason: "EXE_SERVER_MODE=1 (VPS mode)" };
+  }
+  const envOverride = env.EXE_EMBEDDINGS;
+  const embeddingsEnabled = envOverride === "1" || envOverride === "true";
+  if (!embeddingsEnabled) {
+    return { disabled: true, reason: "embeddings OFF (set EXE_EMBEDDINGS=1 to enable)" };
+  }
+  try {
+    const cfg = loadConfigSync();
+    if (cfg?.searchMode === "fts") {
+      return { disabled: true, reason: "searchMode=fts (FTS+Graph only)" };
+    }
+    const modelName = resolveEmbedModelFile(MODELS_DIR, cfg?.modelFile || void 0);
+    if (!modelName || !existsSync(path.join(MODELS_DIR, modelName))) {
+      return { disabled: true, reason: "no embedding model installed" };
+    }
+  } catch {
+  }
+  return { disabled: false, reason: "" };
+}
+
+export {
+  backfillKillSwitchEnabled,
+  PARKED_EMBEDDING_MODEL_PREFIX,
+  PARKED_EMBEDDING_MODEL,
+  NOT_PARKED_SQL,
+  countActionableNullVectors,
+  computeBackfillDisabled
+};