@askexenow/exe-os 0.9.345 → 0.9.347

package/dist/{chunk-GGVP2B2O.js → chunk-4P7NUL4D.js}

@@ -138,7 +138,8 @@ async function writeContinuityCheckpoint(input) {
     timestamp: now,
     importance: importanceForReason(input.reason, input.importance),
     task_id: input.taskId,
-    memory_type: "checkpoint"
+    memory_type: "checkpoint",
+    session_scope: process.env.EXE_SESSION || process.env.EXE_SESSION_NAME?.split("-").pop() || void 0
   });
   const decisionLimit = input.reason === "periodic" ? 3 : 5;
   for (const decisionText of result.decisionTexts.slice(0, decisionLimit)) {
@@ -161,7 +162,9 @@ async function checkpointActiveTask(input) {
   await writeCheckpoint({
     taskId: input.taskId,
     step: input.step ?? "pre-compaction-checkpoint",
-    contextSummary: `Auto-checkpoint before context compaction. Task: ${input.taskTitle}. Session: ${input.sessionId}. Project: ${input.projectName}.`
+    contextSummary: `Auto-checkpoint before context compaction. Task: ${input.taskTitle}. Session: ${input.sessionId}. Project: ${input.projectName}.`,
+    callerSession: process.env.EXE_SESSION_NAME ?? process.env.MY_TMUX_SESSION ?? null,
+    sessionInstanceId: input.sessionId
   });
 }
 

package/dist/{chunk-XM3EARTG.js → chunk-4VLRGKNY.js}

@@ -1,12 +1,12 @@
 import {
   vectorToSqlLiteral
-} from "./chunk-XWD6F6EZ.js";
+} from "./chunk-TQSAPNFW.js";
 import {
   blobToVector
 } from "./chunk-OTVEIJUQ.js";
 import {
   getClient
-} from "./chunk-3BO6S3L2.js";
+} from "./chunk-ZY2ABBVR.js";
 
 // src/lib/behaviors.ts
 import crypto from "crypto";

package/dist/{chunk-PISA226N.js → chunk-53VXPGZ2.js}

@@ -1,11 +1,11 @@
 import {
   ingest
-} from "./chunk-FABOJ6IJ.js";
+} from "./chunk-7AD4GSRT.js";
 import {
   listWorkflowDefinitions,
   runWorkflow,
   startWorkflow
-} from "./chunk-EK2R7ORH.js";
+} from "./chunk-G6IANQKD.js";
 import {
   initCRMBridge
 } from "./chunk-ML4S5SHZ.js";

package/dist/{chunk-XQASVF7H.js → chunk-7667KFAG.js}

@@ -1,9 +1,9 @@
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-SDPOSTDC.js";
+} from "./chunk-MT6YGWJ6.js";
 
 // src/lib/worktree.ts
-import { execFile, execSync } from "child_process";
+import { execFile, execFileSync, execSync } from "child_process";
 import { promisify } from "util";
 import { existsSync, readFileSync, appendFileSync, mkdirSync, realpathSync, statSync, writeFileSync, chmodSync } from "fs";
 import path from "path";
@@ -17,6 +17,79 @@ async function gitAsync(args, cwd) {
   });
   return String(stdout ?? "");
 }
+function gitSync(args, cwd) {
+  return String(execFileSync("git", args, {
+    cwd,
+    encoding: "utf-8",
+    timeout: GIT_TIMEOUT_MS,
+    stdio: ["pipe", "pipe", "pipe"]
+  }) ?? "");
+}
+var GIT_CRYPT_SMUDGE_BYPASS_ARGS = [
+  "-c",
+  "filter.git-crypt.smudge=cat",
+  "-c",
+  "filter.git-crypt.process=",
+  "-c",
+  "filter.git-crypt.required=false"
+];
+function gitErrorText(err) {
+  if (!err || typeof err !== "object") return String(err);
+  const e = err;
+  const parts = [e.message, e.stderr, e.stdout].map((part) => Buffer.isBuffer(part) ? part.toString("utf8") : String(part ?? "")).filter(Boolean);
+  return parts.join("\n");
+}
+function isGitCryptSmudgeFailure(err) {
+  const text = gitErrorText(err);
+  return /git-crypt/i.test(text) && /smudge|filter/i.test(text);
+}
+function worktreeAddArgs(wtPath, branch, branchExists) {
+  return branchExists ? ["worktree", "add", wtPath, branch] : ["worktree", "add", wtPath, "-b", branch, "HEAD"];
+}
+function removePartialWorktreeSync(repoRoot, wtPath) {
+  try {
+    if (existsSync(wtPath)) gitSync(["worktree", "remove", "--force", wtPath], repoRoot);
+  } catch {
+  }
+}
+async function removePartialWorktreeAsync(repoRoot, wtPath) {
+  try {
+    if (existsSync(wtPath)) await gitAsync(["worktree", "remove", "--force", wtPath], repoRoot);
+  } catch {
+  }
+}
+function addWorktreeSync(repoRoot, wtPath, branch, branchExists) {
+  try {
+    gitSync(worktreeAddArgs(wtPath, branch, branchExists), repoRoot);
+  } catch (err) {
+    if (!isGitCryptSmudgeFailure(err)) throw err;
+    removePartialWorktreeSync(repoRoot, wtPath);
+    const retryBranchExists = branchExists || branchExistsLocally(repoRoot, branch);
+    gitSync([...GIT_CRYPT_SMUDGE_BYPASS_ARGS, ...worktreeAddArgs(wtPath, branch, retryBranchExists)], repoRoot);
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.gitcrypt_smudge_bypassed",
+      source: "worktree.ensureWorktree",
+      severity: "warn",
+      payload: { branch }
+    });
+  }
+}
+async function addWorktreeAsync(repoRoot, wtPath, branch, branchExists) {
+  try {
+    await gitAsync(worktreeAddArgs(wtPath, branch, branchExists), repoRoot);
+  } catch (err) {
+    if (!isGitCryptSmudgeFailure(err)) throw err;
+    await removePartialWorktreeAsync(repoRoot, wtPath);
+    const retryBranchExists = branchExists || await branchExistsLocallyAsync(repoRoot, branch);
+    await gitAsync([...GIT_CRYPT_SMUDGE_BYPASS_ARGS, ...worktreeAddArgs(wtPath, branch, retryBranchExists)], repoRoot);
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.gitcrypt_smudge_bypassed",
+      source: "worktree.ensureWorktreeAsync",
+      severity: "warn",
+      payload: { branch }
+    });
+  }
+}
 function classifyGitFailure(err) {
   if (!err || typeof err !== "object") return "unavailable";
   const e = err;
@@ -350,21 +423,7 @@ function ensureWorktree(projectDir, employeeName, instance) {
   }
   const branchExists = branchExistsLocally(repoRoot, branch);
   try {
-    if (branchExists) {
-      execSync(`git worktree add "${wtPath}" "${branch}"`, {
-        cwd: repoRoot,
-        encoding: "utf-8",
-        timeout: GIT_TIMEOUT_MS,
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-    } else {
-      execSync(`git worktree add "${wtPath}" -b "${branch}" HEAD`, {
-        cwd: repoRoot,
-        encoding: "utf-8",
-        timeout: GIT_TIMEOUT_MS,
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-    }
+    addWorktreeSync(repoRoot, wtPath, branch, branchExists);
     recordOrchestrationEventBestEffort({
       eventType: "worktree.created",
       source: "worktree.ensureWorktree",
@@ -469,11 +528,7 @@ async function ensureWorktreeAsync(projectDir, employeeName, instance) {
   }
   const branchExists = await branchExistsLocallyAsync(repoRoot, branch);
   try {
-    if (branchExists) {
-      await gitAsync(["worktree", "add", wtPath, branch], repoRoot);
-    } else {
-      await gitAsync(["worktree", "add", wtPath, "-b", branch, "HEAD"], repoRoot);
-    }
+    await addWorktreeAsync(repoRoot, wtPath, branch, branchExists);
     recordOrchestrationEventBestEffort({
       eventType: "worktree.created",
       source: "worktree.ensureWorktreeAsync",

package/dist/{chunk-FABOJ6IJ.js → chunk-7AD4GSRT.js}

@@ -1,6 +1,6 @@
 import {
   getClient
-} from "./chunk-3BO6S3L2.js";
+} from "./chunk-ZY2ABBVR.js";
 
 // src/lib/pipeline-router.ts
 import crypto from "crypto";
@@ -140,8 +140,8 @@ Agent response: ${agentResponse}` : ""
 }
 async function sinkEntityExtraction(msg, agentResponse, agentName) {
   try {
-    const { extractFromConversation } = await import("./conversation-entity-extractor-CVJ43JCX.js");
-    const { storeExtraction } = await import("./graph-rag-HHNAX7YO.js");
+    const { extractFromConversation } = await import("./conversation-entity-extractor-YC3A2ODD.js");
+    const { storeExtraction } = await import("./graph-rag-LWKKHY72.js");
     if ((msg.text?.length ?? 0) < 20) return false;
     if (msg.isHistorical) return false;
     const extraction = await extractFromConversation(msg, agentResponse, agentName);

package/dist/{chunk-IGF7YLMD.js → chunk-7DAJHBFH.js}

@@ -1,7 +1,7 @@
 import {
   clean,
   stableId
-} from "./chunk-SPV2RTA4.js";
+} from "./chunk-MA22RV3T.js";
 
 // src/lib/reflection-checkpoints.ts
 function parsePayload(payload) {

package/dist/{chunk-DWNRLCUQ.js → chunk-AHR3F7HW.js}

@@ -1,6 +1,6 @@
 import {
   sessionScopeFilter
-} from "./chunk-VNYSLHHX.js";
+} from "./chunk-EWWCMMES.js";
 import {
   leaseExpiryIso
 } from "./chunk-E23LNUWJ.js";

package/dist/{chunk-O7LWR36Z.js → chunk-AJIXH5JF.js}

@@ -1,25 +1,90 @@
 // src/lib/dispatch-ack.ts
 import {
-  existsSync,
-  mkdirSync,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
   readFileSync,
   writeFileSync,
-  unlinkSync,
-  readdirSync,
+  unlinkSync as unlinkSync2,
+  readdirSync as readdirSync2,
   rmSync
 } from "fs";
 import path from "path";
 import os from "os";
+
+// src/lib/dispatch-journal.ts
+import { appendFileSync, existsSync, mkdirSync, readdirSync, renameSync, statSync, unlinkSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var MAX_JSONL_BYTES = Number(process.env.EXE_DISPATCH_JOURNAL_MAX_BYTES) || 1e6;
+var MAX_ARCHIVES = Number(process.env.EXE_DISPATCH_JOURNAL_MAX_ARCHIVES) || 3;
+function dispatchJournalDir() {
+  const base = process.env.EXE_OS_DIR || join(homedir(), ".exe-os");
+  return join(base, "dispatch-journal");
+}
+function journalPath() {
+  return join(dispatchJournalDir(), "events.jsonl");
+}
+function rotateIfNeeded(file) {
+  try {
+    if (!existsSync(file)) return;
+    if (statSync(file).size < MAX_JSONL_BYTES) return;
+    for (let i = MAX_ARCHIVES; i >= 1; i--) {
+      const src = `${file}.${i}`;
+      const dst = `${file}.${i + 1}`;
+      if (!existsSync(src)) continue;
+      if (i === MAX_ARCHIVES) unlinkSync(src);
+      else renameSync(src, dst);
+    }
+    renameSync(file, `${file}.1`);
+  } catch {
+  }
+}
+function appendDispatchJournalEvent(input) {
+  try {
+    const dir = dispatchJournalDir();
+    mkdirSync(dir, { recursive: true });
+    const file = journalPath();
+    rotateIfNeeded(file);
+    appendFileSync(
+      file,
+      JSON.stringify({
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        ...input
+      }) + "\n",
+      "utf-8"
+    );
+    for (const entry of readdirSync(dir)) {
+      const match = entry.match(/^events\.jsonl\.(\d+)$/);
+      if (match && Number(match[1]) > MAX_ARCHIVES) {
+        try {
+          unlinkSync(join(dir, entry));
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+}
+
+// src/lib/dispatch-ack.ts
 function ackDir() {
   return process.env.EXE_DISPATCH_ACK_DIR || path.join(os.homedir(), ".exe-os", "dispatch-acks");
 }
 var DISPATCH_DEDUP_WINDOW_MS = 90 * 1e3;
 function ensureAckDir() {
   const dir = ackDir();
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  if (!existsSync2(dir)) mkdirSync2(dir, { recursive: true });
 }
 function writeDispatchPending(taskId, assignedTo, sessionName) {
   ensureAckDir();
+  try {
+    unlinkSync2(path.join(ackDir(), `${taskId}.failed`));
+  } catch {
+  }
+  try {
+    unlinkSync2(path.join(ackDir(), `${taskId}.ack`));
+  } catch {
+  }
   const signal = {
     taskId,
     assignedTo,
@@ -27,6 +92,13 @@ function writeDispatchPending(taskId, assignedTo, sessionName) {
     sessionName
   };
   writeFileSync(path.join(ackDir(), `${taskId}.pending`), JSON.stringify(signal), "utf-8");
+  appendDispatchJournalEvent({
+    event: "dispatch.pending",
+    taskId,
+    agentId: assignedTo,
+    sessionName: sessionName ?? null,
+    sessionScope: sessionName?.includes("-") ? sessionName.slice(sessionName.indexOf("-") + 1) : sessionName ?? null
+  });
 }
 function spawnLockName(taskId, bucket) {
   return `${taskId}.spawnlock.b${bucket}`;
@@ -52,11 +124,11 @@ function tryAcquireDispatchClaim(taskId, assignedTo, sessionName, windowMs = DIS
   const curLock = path.join(dir, spawnLockName(taskId, bucket));
   const prevLock = path.join(dir, spawnLockName(taskId, bucket - 1));
   try {
-    if (existsSync(prevLock) && ownerPidAlive(prevLock)) return false;
+    if (existsSync2(prevLock) && ownerPidAlive(prevLock)) return false;
   } catch {
   }
   try {
-    mkdirSync(curLock);
+    mkdirSync2(curLock);
   } catch (err) {
     if (err?.code === "EEXIST") return false;
     return true;
@@ -73,13 +145,20 @@ function tryAcquireDispatchClaim(taskId, assignedTo, sessionName, windowMs = DIS
     writeDispatchPending(taskId, assignedTo, sessionName);
   } catch {
   }
+  appendDispatchJournalEvent({
+    event: "dispatch.claim_acquired",
+    taskId,
+    agentId: assignedTo,
+    sessionName: sessionName ?? null,
+    sessionScope: sessionName?.includes("-") ? sessionName.slice(sessionName.indexOf("-") + 1) : sessionName ?? null
+  });
   return true;
 }
 function removeSpawnLockdirs(taskId) {
   const dir = ackDir();
   try {
     const prefix = `${taskId}.spawnlock.b`;
-    for (const entry of readdirSync(dir)) {
+    for (const entry of readdirSync2(dir)) {
       if (entry.startsWith(prefix)) {
         try {
           rmSync(path.join(dir, entry), { recursive: true, force: true });
@@ -97,6 +176,13 @@ function releaseDispatchClaim(taskId, assignedTo, reason = "dispatch failed") {
     writeDispatchFailed(taskId, assignedTo, reason);
   } catch {
   }
+  appendDispatchJournalEvent({
+    event: "dispatch.claim_released",
+    taskId,
+    agentId: assignedTo,
+    result: "released",
+    reason
+  });
 }
 function writeDispatchAck(taskId, agentId) {
   ensureAckDir();
@@ -111,10 +197,17 @@ function writeDispatchAck(taskId, agentId) {
   signal.ackedAt = (/* @__PURE__ */ new Date()).toISOString();
   writeFileSync(ackPath, JSON.stringify(signal), "utf-8");
   try {
-    unlinkSync(pendingPath);
+    unlinkSync2(pendingPath);
   } catch {
   }
   removeSpawnLockdirs(taskId);
+  appendDispatchJournalEvent({
+    event: "dispatch.acked",
+    taskId,
+    agentId,
+    sessionName: signal.sessionName ?? null,
+    sessionScope: signal.sessionName?.includes("-") ? signal.sessionName.slice(signal.sessionName.indexOf("-") + 1) : signal.sessionName ?? null
+  });
 }
 function writeDispatchFailed(taskId, assignedTo, error, sessionName) {
   ensureAckDir();
@@ -130,16 +223,25 @@ function writeDispatchFailed(taskId, assignedTo, error, sessionName) {
   if (sessionName) signal.sessionName = sessionName;
   writeFileSync(path.join(ackDir(), `${taskId}.failed`), JSON.stringify(signal), "utf-8");
   try {
-    unlinkSync(pendingPath);
+    unlinkSync2(pendingPath);
   } catch {
   }
+  appendDispatchJournalEvent({
+    event: "dispatch.failed",
+    taskId,
+    agentId: assignedTo,
+    sessionName: signal.sessionName ?? null,
+    sessionScope: signal.sessionName?.includes("-") ? signal.sessionName.slice(signal.sessionName.indexOf("-") + 1) : signal.sessionName ?? null,
+    result: "failed",
+    reason: error
+  });
 }
 function checkDispatchStatus(taskId) {
   ensureAckDir();
   const ackPath = path.join(ackDir(), `${taskId}.ack`);
   const failedPath = path.join(ackDir(), `${taskId}.failed`);
   const pendingPath = path.join(ackDir(), `${taskId}.pending`);
-  if (existsSync(ackPath)) {
+  if (existsSync2(ackPath)) {
     try {
       const signal = JSON.parse(readFileSync(ackPath, "utf-8"));
       return { status: "acked", signal };
@@ -147,7 +249,7 @@ function checkDispatchStatus(taskId) {
       return { status: "acked" };
     }
   }
-  if (existsSync(failedPath)) {
+  if (existsSync2(failedPath)) {
     try {
       const signal = JSON.parse(readFileSync(failedPath, "utf-8"));
       return { status: "failed", signal };
@@ -155,7 +257,7 @@ function checkDispatchStatus(taskId) {
       return { status: "failed" };
     }
   }
-  if (existsSync(pendingPath)) {
+  if (existsSync2(pendingPath)) {
     try {
       const signal = JSON.parse(readFileSync(pendingPath, "utf-8"));
       return { status: "pending", signal };
@@ -173,7 +275,7 @@ function terminalFailurePath(agentId, scope, baseDir) {
 }
 function writeTerminalLauncherFailure(rec, baseDir = TERMINAL_FAILURE_DIR) {
   try {
-    if (!existsSync(baseDir)) mkdirSync(baseDir, { recursive: true });
+    if (!existsSync2(baseDir)) mkdirSync2(baseDir, { recursive: true });
     const payload = {
       reason: rec.reason,
       ...rec.detail ? { detail: rec.detail } : {},
@@ -190,7 +292,7 @@ function readTerminalLauncherFailure(agentId, scope, opts) {
   const now = opts?.now ?? Date.now();
   try {
     const p = terminalFailurePath(agentId, scope, baseDir);
-    if (!existsSync(p)) return null;
+    if (!existsSync2(p)) return null;
     const rec = JSON.parse(readFileSync(p, "utf-8"));
     if (!rec || typeof rec.reason !== "string" || rec.reason.trim().length === 0) return null;
     if (typeof rec.ts !== "string") return null;
@@ -205,7 +307,7 @@ function readTerminalLauncherFailure(agentId, scope, opts) {
 }
 function clearTerminalLauncherFailure(agentId, scope, baseDir = TERMINAL_FAILURE_DIR) {
   try {
-    unlinkSync(terminalFailurePath(agentId, scope, baseDir));
+    unlinkSync2(terminalFailurePath(agentId, scope, baseDir));
   } catch {
   }
 }
@@ -215,7 +317,7 @@ function cleanStaleDispatchAcks(maxAgeMs = 60 * 60 * 1e3) {
   let cleaned = 0;
   try {
     const dir = ackDir();
-    for (const file of readdirSync(dir)) {
+    for (const file of readdirSync2(dir)) {
       const fullPath = path.join(dir, file);
       if (file.includes(".spawnlock.b")) {
         try {
@@ -238,12 +340,12 @@ function cleanStaleDispatchAcks(maxAgeMs = 60 * 60 * 1e3) {
         const signal = JSON.parse(readFileSync(fullPath, "utf-8"));
         const ts = signal.ackedAt ?? signal.dispatchedAt;
         if (now - new Date(ts).getTime() > maxAgeMs) {
-          unlinkSync(fullPath);
+          unlinkSync2(fullPath);
           cleaned++;
         }
       } catch {
         try {
-          unlinkSync(fullPath);
+          unlinkSync2(fullPath);
           cleaned++;
         } catch {
         }
@@ -255,6 +357,7 @@ function cleanStaleDispatchAcks(maxAgeMs = 60 * 60 * 1e3) {
 }
 
 export {
+  appendDispatchJournalEvent,
   DISPATCH_DEDUP_WINDOW_MS,
   writeDispatchPending,
   tryAcquireDispatchClaim,

package/dist/{chunk-6Z6ZVYHA.js → chunk-BMTUSSHV.js}

@@ -1,6 +1,6 @@
 import {
   getClient
-} from "./chunk-3BO6S3L2.js";
+} from "./chunk-ZY2ABBVR.js";
 
 // src/lib/token-budget.ts
 var WARN_THRESHOLD = 0.8;

package/dist/{chunk-SDC5XIA5.js → chunk-BRVDGE7N.js}

@@ -1,17 +1,17 @@
 import {
   isExeSession,
   strictSessionScopeFilter
-} from "./chunk-VNYSLHHX.js";
+} from "./chunk-EWWCMMES.js";
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-SDPOSTDC.js";
+} from "./chunk-MT6YGWJ6.js";
 import {
   getProjectName
 } from "./chunk-OPU3NYOO.js";
 import {
   DEFAULT_COORDINATOR_TEMPLATE_NAME,
   getCoordinatorName
-} from "./chunk-3BO6S3L2.js";
+} from "./chunk-ZY2ABBVR.js";
 import {
   loadConfigSync
 } from "./chunk-BCZF3AGJ.js";
@@ -260,7 +260,7 @@ function createRealDeps(getClient) {
       });
     },
     createReviewForOrphan: async (task) => {
-      const { createReviewForCompletedTask } = await import("./tasks-review-WR3XEADY.js");
+      const { createReviewForCompletedTask } = await import("./tasks-review-ZY3S65OV.js");
       const cwd = process.cwd();
       await createReviewForCompletedTask(
         task,

package/dist/{chunk-ENVO4NIX.js → chunk-CNIAEIWV.js}

@@ -212,7 +212,7 @@ async function main(args) {
   console.log("[health-gate] Starting rollback...");
   restorePreDeployBackup();
   try {
-    const { rollbackStackUpdate, defaultStackPaths } = await import("./stack-update-ABMTXOZR.js");
+    const { rollbackStackUpdate, defaultStackPaths } = await import("./stack-update-CBP5S5BG.js");
     const paths = defaultStackPaths();
     await rollbackStackUpdate({
       manifestRef: paths.manifestRef,

package/dist/{chunk-5A5LNAMW.js → chunk-DBDMZTU5.js}

@@ -1,7 +1,7 @@
 import {
   checkLicense,
   loadLicense
-} from "./chunk-RSMOYIVR.js";
+} from "./chunk-ZK53K7OR.js";
 
 // src/lib/license-gate.ts
 var _cachedLicense = null;

package/dist/{chunk-WT6YYIEL.js → chunk-DNN27P35.js}

@@ -1,7 +1,7 @@
 import {
   formatDegradations,
   getRetrievalHealth
-} from "./chunk-IGAODB3D.js";
+} from "./chunk-CYI2YR56.js";
 import {
   buildRestartReport,
   formatRestartReport
@@ -20,7 +20,7 @@ import {
 } from "./chunk-OTVEIJUQ.js";
 import {
   offloadReadIfMain
-} from "./chunk-3BO6S3L2.js";
+} from "./chunk-ZY2ABBVR.js";
 import {
   isMainModule
 } from "./chunk-6Y4B3QF6.js";
@@ -1023,7 +1023,7 @@ function formatReport(report, flags) {
   return lines.join("\n");
 }
 async function fixNullVectors() {
-  const { tryAcquireWorkerSlot, registerWorkerPid } = await import("./worker-gate-XJJXOMUN.js");
+  const { tryAcquireWorkerSlot, registerWorkerPid } = await import("./worker-gate-NZRA426F.js");
   if (!tryAcquireWorkerSlot()) {
     process.stderr.write("[exe-doctor] Worker gate full \u2014 waiting for existing backfill workers to finish\n");
     await new Promise((r) => setTimeout(r, 5e3));
@@ -1209,7 +1209,7 @@ async function main(argv = process.argv.slice(2)) {
     console.log(formatRestartReport(restartReport));
     return emptyAuditReport();
   }
-  const { fastDbInit } = await import("./fast-db-init-CZSSDWDG.js");
+  const { fastDbInit } = await import("./fast-db-init-O7AECNTB.js");
   const client = await fastDbInit();
   const report = await runAudit(client, flags);
   console.log(formatReport(report, flags));