@askexenow/exe-os 0.9.345 → 0.9.346

package/dist/{chunk-3BO6S3L2.js → chunk-3QYE5U6D.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-2I23RPSI.js";
 import {
   listBackups
-} from "./chunk-7IE3NPBV.js";
+} from "./chunk-Q6ZQIX7L.js";
 import {
   getEmotionalBaseline,
   renderEmotionalBaselineSection
@@ -1266,13 +1266,64 @@ async function ensureIdempotencyKeyMigration(client) {
        WHERE idempotency_key IS NOT NULL`
   );
 }
+async function ensureScopedMemoryHashIndexes(client) {
+  await executeAddColumn(
+    client,
+    "ALTER TABLE memories ADD COLUMN outcome TEXT",
+    "migration add memories.outcome for scoped hash repair"
+  );
+  await client.execute(
+    `CREATE INDEX IF NOT EXISTS idx_memories_scoped_content_hash
+       ON memories(content_hash, agent_id, project_name, memory_type)
+       WHERE content_hash IS NOT NULL`
+  );
+  const createUnique = () => client.execute(
+    `CREATE UNIQUE INDEX IF NOT EXISTS idx_memories_unique_scoped_hash
+       ON memories(content_hash, agent_id, project_name, memory_type)
+       WHERE content_hash IS NOT NULL
+         AND COALESCE(status, 'active') != 'deleted'`
+  );
+  try {
+    await createUnique();
+    return;
+  } catch (e) {
+    if (!(e instanceof Error && e.message.includes("UNIQUE constraint"))) {
+      throw e;
+    }
+  }
+  process.stderr.write("[migration] Cleaning up existing duplicate memories before creating unique index...\n");
+  await client.execute(`
+    UPDATE memories SET status = 'deleted', outcome = 'dedup-migration'
+    WHERE id IN (
+      SELECT m.id
+      FROM memories m
+      WHERE m.content_hash IS NOT NULL
+        AND COALESCE(m.status, 'active') != 'deleted'
+        AND EXISTS (
+          SELECT 1
+          FROM memories winner
+          WHERE winner.content_hash = m.content_hash
+            AND winner.agent_id = m.agent_id
+            AND winner.project_name IS m.project_name
+            AND COALESCE(winner.memory_type, 'raw') = COALESCE(m.memory_type, 'raw')
+            AND COALESCE(winner.status, 'active') != 'deleted'
+            AND (
+              winner.timestamp > m.timestamp
+              OR (winner.timestamp = m.timestamp AND winner.id > m.id)
+            )
+        )
+    )
+  `);
+  await createUnique();
+  process.stderr.write("[migration] Duplicate cleanup + unique index created successfully\n");
+}
 async function migrateReflectionDedup(client) {
   const added = await executeAddColumn(
     client,
     "ALTER TABLE memory_reflections ADD COLUMN dedup_key TEXT",
     "migration add memory_reflections.dedup_key"
   );
-  const { reflectionDedupKey } = await import("./memory-reflection-KRYBPDHC.js");
+  const { reflectionDedupKey } = await import("./memory-reflection-WIMMTW7M.js");
   const keyForRow = (row) => {
     let sources = [];
     try {
@@ -1453,40 +1504,64 @@ ${getOwnPidStartTimeSync() ?? ""}
     logCatchDebug("lock pid write", e);
   }
 }
+function statDbLockIdentity(lockPath) {
+  try {
+    const st = statSync(lockPath);
+    return { identity: { dev: st.dev, ino: st.ino }, mtimeMs: st.mtimeMs };
+  } catch {
+    return null;
+  }
+}
+function unlinkDbLockIfSameInode(lockPath, identity) {
+  try {
+    const st = statSync(lockPath);
+    if (st.dev !== identity.dev || st.ino !== identity.ino) return false;
+    unlinkSync3(lockPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function classifyStaleDbLock(lockPath, lockMtimeMs, isAlive = pidIsAlive) {
+  const holderPid = readLockHolderPid(lockPath);
+  if (holderPid === null) {
+    if (Date.now() - lockMtimeMs > DB_LOCK_STALE_MS) {
+      return {
+        result: "cleaned-stale",
+        message: `unknown holder, lock older than ${DB_LOCK_STALE_MS}ms`
+      };
+    }
+    return null;
+  }
+  if (!isAlive(holderPid)) {
+    return { result: "cleaned-dead", message: `pid ${holderPid} is dead` };
+  }
+  const recordedStartTime = readLockHolderStartTime(lockPath);
+  if (recordedStartTime !== null) {
+    const currentStartTime = await getPidStartTime(holderPid);
+    if (currentStartTime !== null && currentStartTime !== recordedStartTime) {
+      return {
+        result: "cleaned-pid-reuse",
+        message: `pid ${holderPid} start time changed`
+      };
+    }
+  }
+  return null;
+}
 async function verifyAndCleanStaleDbLock() {
   try {
     const lockPath = dbLockPath();
     if (!existsSync4(lockPath)) return "absent";
-    let identity;
-    try {
-      const st = statSync(lockPath);
-      identity = { dev: st.dev, ino: st.ino };
-    } catch {
-      return "absent";
-    }
-    const unlinkIfSameInode = () => {
-      try {
-        const st = statSync(lockPath);
-        if (st.dev !== identity.dev || st.ino !== identity.ino) return false;
-        unlinkSync3(lockPath);
-        return true;
-      } catch {
-        return false;
-      }
-    };
-    const holderPid = readLockHolderPid(lockPath);
-    if (holderPid === null) return "unknown";
-    if (!pidIsAlive(holderPid)) {
-      return unlinkIfSameInode() ? "cleaned-dead" : "unknown";
-    }
-    const recordedStartTime = readLockHolderStartTime(lockPath);
-    if (recordedStartTime !== null) {
-      const currentStartTime = await getPidStartTime(holderPid);
-      if (currentStartTime !== null && currentStartTime !== recordedStartTime) {
-        return unlinkIfSameInode() ? "cleaned-pid-reuse" : "unknown";
-      }
+    const snapshot = statDbLockIdentity(lockPath);
+    if (!snapshot) return "absent";
+    const stale = await classifyStaleDbLock(lockPath, snapshot.mtimeMs);
+    if (!stale) return readLockHolderPid(lockPath) === null ? "unknown" : "live";
+    if (unlinkDbLockIfSameInode(lockPath, snapshot.identity)) {
+      process.stderr.write(`[database] CRITICAL: reclaimed stale db.lock (${stale.message}).
+`);
+      return stale.result;
     }
-    return "live";
+    return "unknown";
   } catch {
     return "unknown";
   }
@@ -1522,27 +1597,22 @@ async function acquireDbLock(options = {}) {
         throw err;
       }
     }
-    const holderPid = readLockHolderPid(lockPath);
-    let stale = false;
-    if (holderPid !== null) {
-      stale = !isAlive(holderPid);
-    } else {
-      try {
-        stale = Date.now() - statSync(lockPath).mtimeMs > DB_LOCK_STALE_MS;
-      } catch (e) {
-        logCatchDebug("stale lock check", e);
-        continue;
-      }
+    const snapshot = statDbLockIdentity(lockPath);
+    if (!snapshot) {
+      continue;
     }
+    const holderPid = readLockHolderPid(lockPath);
+    const stale = await classifyStaleDbLock(lockPath, snapshot.mtimeMs, isAlive);
     if (stale) {
       process.stderr.write(
-        `[database] db.lock is stale (holder ${holderPid !== null ? `pid ${holderPid} is dead` : "unknown, lock older than 60s"}) \u2014 breaking lock.
+        `[database] CRITICAL: db.lock is stale (${stale.message}) \u2014 reclaiming lock.
 `
       );
-      try {
-        unlinkSync3(lockPath);
-      } catch (e) {
-        logCatchDebug("stale lock unlink", e);
+      if (!unlinkDbLockIfSameInode(lockPath, snapshot.identity)) {
+        process.stderr.write(
+          `[database] db.lock was replaced before stale reclaim completed \u2014 leaving replacement lock intact.
+`
+        );
       }
       continue;
     }
@@ -1935,7 +2005,7 @@ async function initDatabase(config) {
       throw e;
     }
     if (!dbIsCorrupt) {
-      const { writeDbVerifyStamp } = await import("./db-verify-stamp-YTRPEKZ5.js");
+      const { writeDbVerifyStamp } = await import("./db-verify-stamp-P2FCVTXK.js");
       writeDbVerifyStamp(config.dbPath);
     }
   }
@@ -2026,7 +2096,7 @@ async function sweepExpiredSoftDeletedMemories(client, options = {}) {
   const purgeArchived = archDays !== void 0;
   const BATCH_SIZE = 2e3;
   const MAX_BATCHES = 500;
-  const { cleanupCardsForMemories, cleanupGraphLinksForMemories } = await import("./graph-rag-HHNAX7YO.js");
+  const { cleanupCardsForMemories, cleanupGraphLinksForMemories } = await import("./graph-rag-2I24BQC2.js");
   const softCutoff = `-${softDays} days`;
   const selectArgsBase = [softCutoff];
   let predicate = `status = 'deleted' AND COALESCE(deleted_at, timestamp) < datetime('now', ?)`;
@@ -2150,7 +2220,7 @@ function getRawClient() {
 function tryGetRawClient() {
   return _client;
 }
-var CURRENT_SCHEMA_VERSION = 20;
+var CURRENT_SCHEMA_VERSION = 21;
 var _migrationBlockRuns = 0;
 function _getMigrationBlockRuns() {
   return _migrationBlockRuns;
@@ -2196,6 +2266,23 @@ async function ensureSchema() {
     } catch (e) {
       process.stderr.write(
         `[database] idempotency index repair check failed: ${e instanceof Error ? e.message : String(e)}
+`
+      );
+    }
+    try {
+      const scopedHashIdxProbe = await client.execute({
+        sql: "SELECT name FROM sqlite_master WHERE type = 'index' AND name = ?",
+        args: ["idx_memories_unique_scoped_hash"]
+      });
+      if (scopedHashIdxProbe.rows.length === 0) {
+        process.stderr.write(
+          "[database] repairing missing idx_memories_unique_scoped_hash on already-current DB (bug 8d711f75)\n"
+        );
+        await ensureScopedMemoryHashIndexes(client);
+      }
+    } catch (e) {
+      process.stderr.write(
+        `[database] scoped memory hash index repair check failed: ${e instanceof Error ? e.message : String(e)}
 `
       );
     }
@@ -3363,17 +3450,22 @@ async function ensureSchema() {
     "ALTER TABLE tasks ADD COLUMN claimed_at TEXT",
     "ALTER TABLE tasks ADD COLUMN last_heartbeat_at TEXT",
     "ALTER TABLE tasks ADD COLUMN lease_expires_at TEXT",
+    "ALTER TABLE tasks ADD COLUMN claim_session_instance_id TEXT",
     "ALTER TABLE tasks ADD COLUMN claim_count INTEGER NOT NULL DEFAULT 0"
   ]) {
     await executeAddColumn(client, col);
   }
+  await executeAddColumn(client, "ALTER TABLE tasks ADD COLUMN checkpoint_session TEXT");
+  await executeAddColumn(client, "ALTER TABLE tasks ADD COLUMN checkpoint_session_instance_id TEXT");
   await executeAddColumn(client, "ALTER TABLE tasks ADD COLUMN assertions TEXT");
   await executeAddColumn(client, "ALTER TABLE tasks ADD COLUMN verification_receipts TEXT");
   await executeAddColumn(client, "ALTER TABLE tasks ADD COLUMN review_sampled INTEGER NOT NULL DEFAULT 0");
   for (const idx of [
     "CREATE INDEX IF NOT EXISTS idx_tasks_heartbeat_stale ON tasks(status, last_heartbeat_at) WHERE status = 'in_progress'",
     "CREATE INDEX IF NOT EXISTS idx_tasks_lease_expiry ON tasks(status, lease_expires_at) WHERE status = 'in_progress'",
-    "CREATE INDEX IF NOT EXISTS idx_tasks_claimed_by ON tasks(claimed_by) WHERE claimed_by IS NOT NULL"
+    "CREATE INDEX IF NOT EXISTS idx_tasks_claimed_by ON tasks(claimed_by) WHERE claimed_by IS NOT NULL",
+    "CREATE INDEX IF NOT EXISTS idx_tasks_claim_session_instance ON tasks(claim_session_instance_id) WHERE claim_session_instance_id IS NOT NULL",
+    "CREATE INDEX IF NOT EXISTS idx_tasks_checkpoint_session_instance ON tasks(checkpoint_session_instance_id) WHERE checkpoint_session_instance_id IS NOT NULL"
   ]) {
     try {
       await client.execute(idx);
@@ -3755,58 +3847,7 @@ async function ensureSchema() {
   } catch (e) {
     logCatchDebug("migration", e);
   }
-  try {
-    await client.execute(
-      `CREATE INDEX IF NOT EXISTS idx_memories_scoped_content_hash
-         ON memories(content_hash, agent_id, project_name, memory_type)
-         WHERE content_hash IS NOT NULL`
-    );
-  } catch (e) {
-    logCatchDebug("migration", e);
-  }
-  try {
-    await client.execute(
-      `CREATE UNIQUE INDEX IF NOT EXISTS idx_memories_unique_scoped_hash
-         ON memories(content_hash, agent_id, project_name, memory_type)
-         WHERE content_hash IS NOT NULL
-           AND COALESCE(status, 'active') != 'deleted'`
-    );
-  } catch (e) {
-    if (e instanceof Error && e.message.includes("UNIQUE constraint")) {
-      process.stderr.write("[migration] Cleaning up existing duplicate memories before creating unique index...\n");
-      try {
-        await client.execute(`
-          UPDATE memories SET status = 'deleted', outcome = 'dedup-migration'
-          WHERE id IN (
-            SELECT m.id FROM memories m
-            JOIN (
-              SELECT content_hash, agent_id, project_name, memory_type, MAX(timestamp) as max_ts
-              FROM memories
-              WHERE content_hash IS NOT NULL AND COALESCE(status, 'active') != 'deleted'
-              GROUP BY content_hash, agent_id, project_name, memory_type
-              HAVING COUNT(*) > 1
-            ) d ON m.content_hash = d.content_hash
-              AND m.agent_id = d.agent_id
-              AND m.project_name = d.project_name
-              AND COALESCE(m.memory_type, 'raw') = COALESCE(d.memory_type, 'raw')
-              AND m.timestamp < d.max_ts
-              AND COALESCE(m.status, 'active') != 'deleted'
-          )
-        `);
-        await client.execute(
-          `CREATE UNIQUE INDEX IF NOT EXISTS idx_memories_unique_scoped_hash
-             ON memories(content_hash, agent_id, project_name, memory_type)
-             WHERE content_hash IS NOT NULL
-               AND COALESCE(status, 'active') != 'deleted'`
-        );
-        process.stderr.write("[migration] Duplicate cleanup + unique index created successfully\n");
-      } catch (retryErr) {
-        logCatchDebug("migration-dedup-retry", retryErr);
-      }
-    } else {
-      logCatchDebug("migration", e);
-    }
-  }
+  await ensureScopedMemoryHashIndexes(client);
   await executeAddColumn(client, `ALTER TABLE memories ADD COLUMN trajectory TEXT`);
   for (const col of [
     "ALTER TABLE memories ADD COLUMN intent TEXT",

package/dist/{chunk-ORVC4XVZ.js → chunk-3WELJGZN.js}

@@ -1,6 +1,6 @@
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-SDPOSTDC.js";
+} from "./chunk-EU2GUT67.js";
 import {
   atomicWriteJsonSync
 } from "./chunk-HSGBZSCA.js";

package/dist/{chunk-QEHVKL27.js → chunk-44ZGOBMU.js}

@@ -1,7 +1,7 @@
 import {
   getCurrentSessionScope,
   strictSessionScopeFilter
-} from "./chunk-VNYSLHHX.js";
+} from "./chunk-PJOHJ7Q4.js";
 import {
   getProjectName
 } from "./chunk-OPU3NYOO.js";

package/dist/{chunk-CBZPE5J4.js → chunk-4A6RX2N6.js}

@@ -207,7 +207,7 @@ function clearSetupState() {
 }
 async function probeDaemonHealthAfterInstall() {
   try {
-    const { waitForDaemonReady } = await import("./daemon-ready-QGU7MZZB.js");
+    const { waitForDaemonReady } = await import("./daemon-ready-56VAPZU6.js");
     return await waitForDaemonReady(4, 500);
   } catch {
     return false;

package/dist/{chunk-U6NQ6OEU.js → chunk-4BQYN4IJ.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-B6TI3TZT.js";
 import {
   loadEmployeesSync
-} from "./chunk-3BO6S3L2.js";
+} from "./chunk-3QYE5U6D.js";
 
 // src/adapters/mcp-http-config.ts
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";

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

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

package/dist/{chunk-OYDXYENC.js → chunk-4KLQ4GH5.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-WCGNCH3Q.js";
 import {
   registerAllTools
-} from "./chunk-NLVOLANR.js";
+} from "./chunk-HBJAMWHT.js";
 
 // src/mcp/mcp-surface-hash.ts
 function computeMcpSurfaceHash() {

package/dist/{chunk-BLV57HND.js → chunk-6F3OMSZJ.js}

@@ -2,7 +2,7 @@ import {
   getClient,
   isCoordinatorName,
   loadEmployeesSync
-} from "./chunk-3BO6S3L2.js";
+} from "./chunk-3QYE5U6D.js";
 
 // src/lib/steward-gate.ts
 import crypto from "crypto";

package/dist/{chunk-LEESW32W.js → chunk-6I6OMBYY.js}

@@ -3,12 +3,12 @@ import {
   getClient,
   isInitialized,
   loadEmployees
-} from "./chunk-3BO6S3L2.js";
+} from "./chunk-3QYE5U6D.js";
 import {
   PLAN_LIMITS,
   checkLicense,
   isFeatureAllowed
-} from "./chunk-RSMOYIVR.js";
+} from "./chunk-BUDVHNV2.js";
 import {
   EXE_AI_DIR
 } from "./chunk-BCZF3AGJ.js";

package/dist/{chunk-XDO4DVSB.js → chunk-6LLDY7AL.js}

@@ -9,7 +9,7 @@ import {
   getCoordinatorEmployee,
   getEmployee,
   loadEmployeesSync
-} from "./chunk-3BO6S3L2.js";
+} from "./chunk-3QYE5U6D.js";
 import {
   EXE_AI_DIR
 } from "./chunk-BCZF3AGJ.js";

package/dist/{chunk-IM6FMNTO.js → chunk-6OEMGMOV.js}

@@ -4,10 +4,10 @@ import {
 import {
   reserveVersions,
   vectorToBlob
-} from "./chunk-XWD6F6EZ.js";
+} from "./chunk-GGHH54QD.js";
 import {
   getClient
-} from "./chunk-3BO6S3L2.js";
+} from "./chunk-3QYE5U6D.js";
 
 // src/lib/documents.ts
 import crypto from "crypto";
@@ -270,7 +270,7 @@ async function ingestDocument(input) {
   await client.batch([documentStmt, ...chunkStmts], "write");
   const embedded = vectors.filter((v) => v !== null).length;
   const originalTexts = input.chunks.map((c) => c.text);
-  import("./doc-graph-extractor-VZ6SE7BC.js").then(
+  import("./doc-graph-extractor-E5SXO6NZ.js").then(
     ({ extractAndStoreDocumentGraph }) => extractAndStoreDocumentGraph(documentId, originalTexts)
   ).catch((err) => {
     process.stderr.write(

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

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

package/dist/{chunk-QHDUGZVP.js → chunk-ACYZER3P.js}

@@ -4,17 +4,17 @@ import {
   resolveExeSession,
   sendIntercom,
   strictSessionScopeFilter
-} from "./chunk-VNYSLHHX.js";
+} from "./chunk-PJOHJ7Q4.js";
 import {
   parseMessage,
   serializeMessage
 } from "./chunk-4JERP7NT.js";
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-SDPOSTDC.js";
+} from "./chunk-EU2GUT67.js";
 import {
   getClient
-} from "./chunk-3BO6S3L2.js";
+} from "./chunk-3QYE5U6D.js";
 
 // src/lib/messaging.ts
 import crypto from "crypto";

package/dist/{chunk-B77H77VF.js → chunk-BCFWDNH7.js}

@@ -1,6 +1,6 @@
 import {
   getClient
-} from "./chunk-3BO6S3L2.js";
+} from "./chunk-3QYE5U6D.js";
 
 // src/lib/boot-generation.ts
 var SYNC_META_KEY = "daemon_boot_generation";

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

@@ -1,17 +1,17 @@
 import {
   isExeSession,
   strictSessionScopeFilter
-} from "./chunk-VNYSLHHX.js";
+} from "./chunk-PJOHJ7Q4.js";
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-SDPOSTDC.js";
+} from "./chunk-EU2GUT67.js";
 import {
   getProjectName
 } from "./chunk-OPU3NYOO.js";
 import {
   DEFAULT_COORDINATOR_TEMPLATE_NAME,
   getCoordinatorName
-} from "./chunk-3BO6S3L2.js";
+} from "./chunk-3QYE5U6D.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-INJKVN63.js");
       const cwd = process.cwd();
       await createReviewForCompletedTask(
         task,

package/dist/{chunk-RSMOYIVR.js → chunk-BUDVHNV2.js}

@@ -1,6 +1,6 @@
 import {
   getDeviceInfo
-} from "./chunk-DQOBH5VO.js";
+} from "./chunk-DY7WDHMC.js";
 import {
   EXE_AI_DIR
 } from "./chunk-BCZF3AGJ.js";

package/dist/{chunk-EK2R7ORH.js → chunk-CFA4T2HP.js}

@@ -1,7 +1,7 @@
 import {
   executeAction,
   substituteTemplate
-} from "./chunk-KHIBBGMT.js";
+} from "./chunk-PDWIUSQH.js";
 
 // src/automation/workflow-engine.ts
 import { randomUUID } from "crypto";

package/dist/{chunk-7DZYO3Z5.js → chunk-CMTS2MLG.js}

@@ -9,10 +9,10 @@ import {
 import {
   buildClaudeHttpMcpEntry,
   buildClaudeStdioProxyMcpEntry
-} from "./chunk-U6NQ6OEU.js";
+} from "./chunk-4BQYN4IJ.js";
 import {
   ensureAllAgentSymlinks
-} from "./chunk-OJBWWOSM.js";
+} from "./chunk-E6TLQG2T.js";
 import {
   MCP_LEGACY_KEY,
   MCP_PRIMARY_KEY

package/dist/{chunk-W5SRIJU4.js → chunk-CR7XPLLC.js}

@@ -1,6 +1,6 @@
 import {
   completeReminder
-} from "./chunk-JELPA53I.js";
+} from "./chunk-2LC2ASCN.js";
 
 // src/mcp/tools/complete-reminder.ts
 import { z } from "zod";

package/dist/{chunk-IGF7YLMD.js → chunk-DKKMBEU6.js}

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