@askexenow/exe-os 0.9.200 → 0.9.202

package/dist/{chunk-6UZHYTLV.js → chunk-KMAYFYW7.js}

@@ -6,7 +6,7 @@ import {
   findScopedDuplicate,
   governMemoryRecord,
   schedulePostWriteMemoryHygiene
-} from "./chunk-SY4TZ224.js";
+} from "./chunk-HGU4YCR3.js";
 import {
   orgBus
 } from "./chunk-MP2AFCGL.js";
@@ -15,7 +15,7 @@ import {
   ensureSchema,
   getClient,
   initTurso
-} from "./chunk-3HM6MZ4O.js";
+} from "./chunk-YCEJCFU5.js";
 import {
   EMBEDDING_DIM
 } from "./chunk-FXU7JOXK.js";
@@ -139,7 +139,7 @@ async function initStore(options) {
   if (!options?.lightweight) {
     try {
       if (process.env.EXE_DISABLE_SHARDING !== "1") {
-        const { initShardManager } = await import("./shard-manager-KXLEDDBB.js");
+        const { initShardManager } = await import("./shard-manager-4PWRZW4V.js");
         initShardManager(hexKey);
       }
     } catch (e) {
@@ -152,7 +152,7 @@ async function initStore(options) {
     );
     _nextVersion = (Number(vResult.rows[0]?.max_v) || 0) + 1;
     try {
-      const { loadGlobalProcedures } = await import("./global-procedures-PQKUKKM6.js");
+      const { loadGlobalProcedures } = await import("./global-procedures-K3B3GTHA.js");
       await loadGlobalProcedures();
     } catch (e) {
       logStoreWarn("catch", e);
@@ -279,7 +279,7 @@ async function writeMemory(record) {
     keywords: record.keywords ?? keywordsToString(extractKeywords(record.raw_text))
   };
   try {
-    const { checkMemoryPoisoning } = await import("./memory-poisoning-defense-M4E6D6NI.js");
+    const { checkMemoryPoisoning } = await import("./memory-poisoning-defense-EKMAAXMH.js");
     const poisonResult = await checkMemoryPoisoning({
       memoryId: dbRow.id,
       vector: Array.isArray(dbRow.vector) ? dbRow.vector : void 0,
@@ -465,19 +465,19 @@ async function flushBatch() {
     }
     _nextVersion = baseVersion;
     try {
-      const { insertMemoryCardsForBatch } = await import("./memory-cards-QHCHERFV.js");
+      const { insertMemoryCardsForBatch } = await import("./memory-cards-VIKEUPGO.js");
       await insertMemoryCardsForBatch(batch);
     } catch (e) {
       logStoreWarn("catch", e);
     }
     try {
-      const { insertOntologyForBatch } = await import("./agentic-ontology-N5HXDWIN.js");
+      const { insertOntologyForBatch } = await import("./agentic-ontology-HPFKQFA2.js");
       await insertOntologyForBatch(batch);
     } catch (e) {
       logStoreWarn("catch", e);
     }
     try {
-      const { extractGraphForBatch } = await import("./memory-graph-extractor-RAF4M3YY.js");
+      const { extractGraphForBatch } = await import("./memory-graph-extractor-OP2BSF43.js");
       await extractGraphForBatch(batch);
     } catch (e) {
       logStoreWarn("catch", e);
@@ -485,7 +485,7 @@ async function flushBatch() {
     schedulePostWriteMemoryHygiene(batch.map((row) => row.id));
     _pendingRecords.splice(0, batch.length);
     try {
-      const { isShardingEnabled, getReadyShardClient } = await import("./shard-manager-KXLEDDBB.js");
+      const { isShardingEnabled, getReadyShardClient } = await import("./shard-manager-4PWRZW4V.js");
       if (process.env.EXE_DISABLE_SHARDING !== "1" && isShardingEnabled()) {
         const byProject = /* @__PURE__ */ new Map();
         let skippedUnknown = 0;
@@ -562,7 +562,7 @@ function buildRawVisibilityFilter(options, columnPrefix) {
 async function searchMemories(queryVector, agentId, options) {
   let client;
   try {
-    const { isShardingEnabled, shardExists, getReadyShardClient } = await import("./shard-manager-KXLEDDBB.js");
+    const { isShardingEnabled, shardExists, getReadyShardClient } = await import("./shard-manager-4PWRZW4V.js");
     if (isShardingEnabled() && options?.projectName && shardExists(options.projectName)) {
       client = await getReadyShardClient(options.projectName);
     } else {

package/dist/{chunk-LWYXWPZZ.js → chunk-KPUVDGLP.js}

@@ -3,24 +3,24 @@ import {
 } from "./chunk-MLXJ5EZG.js";
 import {
   createTask
-} from "./chunk-AVRQWLQR.js";
+} from "./chunk-DDH7QVQN.js";
 import {
   getActiveAgent
-} from "./chunk-QOW5EEYO.js";
+} from "./chunk-Q3FTA4GX.js";
 import {
   ensureEmployee,
   logTaskDispatch,
   resolveExeSession
-} from "./chunk-WXQRFDY4.js";
+} from "./chunk-JUKSHMDE.js";
 import {
   getLicenseSync
-} from "./chunk-VQB4VBEQ.js";
+} from "./chunk-CCYOB56Q.js";
 import {
   getAgentContext
 } from "./chunk-GJV3WDWM.js";
 import {
   isCoordinatorName
-} from "./chunk-3HM6MZ4O.js";
+} from "./chunk-YCEJCFU5.js";
 
 // src/mcp/tools/create-task.ts
 import { z } from "zod";
@@ -33,7 +33,8 @@ async function resolveProjectDir(projectName, callerSession) {
     try {
       const { listSessions } = await import("./lib/session-registry.js");
       const sessions = listSessions();
-      const coordSession = sessions.find((s) => s.windowName === callerSession);
+      const coordName = callerSession.includes("-") ? callerSession.slice(callerSession.indexOf("-") + 1) : callerSession;
+      const coordSession = sessions.find((s) => s.windowName === coordName) ?? sessions.find((s) => s.windowName === callerSession);
       if (coordSession?.projectDir && existsSync(coordSession.projectDir)) {
         const dirBasename = (await import("path")).basename(coordSession.projectDir).toLowerCase();
         const normalizedProject = projectName.toLowerCase();
@@ -208,7 +209,7 @@ function registerCreateTask(server) {
             let projectConflictOpts = {};
             try {
               const { getClient } = await import("./lib/database.js");
-              const { sessionScopeFilter } = await import("./task-scope-C7QECQSB.js");
+              const { sessionScopeFilter } = await import("./task-scope-SSM56VHZ.js");
               const client = getClient();
               const scope = sessionScopeFilter();
               const existing = await client.execute({

package/dist/{chunk-XPOMXVWI.js → chunk-L756L654.js}

@@ -196,24 +196,50 @@ async function ensureShardSchema(client) {
     CREATE INDEX IF NOT EXISTS idx_memories_agent_project ON memories(agent_id, project_name);
     CREATE INDEX IF NOT EXISTS idx_memories_version ON memories(version);
   `);
+  let needsFtsMigration = false;
+  try {
+    await client.execute("SELECT keywords FROM memories_fts LIMIT 0");
+  } catch {
+    needsFtsMigration = true;
+  }
+  if (needsFtsMigration) {
+    for (const drop of [
+      "DROP TRIGGER IF EXISTS memories_fts_ai",
+      "DROP TRIGGER IF EXISTS memories_fts_ad",
+      "DROP TRIGGER IF EXISTS memories_fts_au",
+      "DROP TRIGGER IF EXISTS memories_fts_soft_delete",
+      "DROP TABLE IF EXISTS memories_fts"
+    ]) {
+      try {
+        await client.execute(drop);
+      } catch {
+      }
+    }
+  }
   await client.executeMultiple(`
     CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
       raw_text,
+      keywords,
       content='memories',
       content_rowid='rowid'
     );
 
     CREATE TRIGGER IF NOT EXISTS memories_fts_ai AFTER INSERT ON memories BEGIN
-      INSERT INTO memories_fts(rowid, raw_text) VALUES (new.rowid, new.raw_text);
+      INSERT INTO memories_fts(rowid, raw_text, keywords) VALUES (new.rowid, new.raw_text, COALESCE(new.keywords, ''));
     END;
 
     CREATE TRIGGER IF NOT EXISTS memories_fts_ad AFTER DELETE ON memories BEGIN
-      INSERT INTO memories_fts(memories_fts, rowid, raw_text) VALUES('delete', old.rowid, old.raw_text);
+      INSERT INTO memories_fts(memories_fts, rowid, raw_text, keywords) VALUES('delete', old.rowid, old.raw_text, COALESCE(old.keywords, ''));
     END;
 
     CREATE TRIGGER IF NOT EXISTS memories_fts_au AFTER UPDATE ON memories BEGIN
-      INSERT INTO memories_fts(memories_fts, rowid, raw_text) VALUES('delete', old.rowid, old.raw_text);
-      INSERT INTO memories_fts(rowid, raw_text) VALUES (new.rowid, new.raw_text);
+      INSERT INTO memories_fts(memories_fts, rowid, raw_text, keywords) VALUES('delete', old.rowid, old.raw_text, COALESCE(old.keywords, ''));
+      INSERT INTO memories_fts(rowid, raw_text, keywords) VALUES (new.rowid, new.raw_text, COALESCE(new.keywords, ''));
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS memories_fts_soft_delete AFTER UPDATE OF status ON memories
+      WHEN new.status = 'deleted' AND (old.status IS NULL OR old.status != 'deleted') BEGIN
+      INSERT INTO memories_fts(memories_fts, rowid, raw_text, keywords) VALUES('delete', old.rowid, old.raw_text, COALESCE(old.keywords, ''));
     END;
   `);
   for (const col of [
@@ -271,7 +297,7 @@ async function ensureShardSchema(client) {
     // Memory strength scoring — Ebbinghaus decay (must match database.ts)
     "ALTER TABLE memories ADD COLUMN strength REAL DEFAULT 1.0",
     // Source trust level (must match database.ts)
-    "ALTER TABLE memories ADD COLUMN source_trust_level TEXT",
+    "ALTER TABLE memories ADD COLUMN source_trust_level TEXT DEFAULT 'unknown'",
     // Poisoning defense (must match database.ts)
     "ALTER TABLE memories ADD COLUMN quarantined INTEGER DEFAULT 0",
     "ALTER TABLE memories ADD COLUMN quarantine_reason TEXT",
@@ -280,7 +306,9 @@ async function ensureShardSchema(client) {
     "ALTER TABLE memories ADD COLUMN media_type TEXT",
     "ALTER TABLE memories ADD COLUMN media_meta TEXT",
     // Session scope (must match database.ts)
-    "ALTER TABLE memories ADD COLUMN session_scope TEXT"
+    "ALTER TABLE memories ADD COLUMN session_scope TEXT",
+    // Keywords for FTS5 dual-column search (must match database.ts)
+    "ALTER TABLE memories ADD COLUMN keywords TEXT DEFAULT ''"
   ]) {
     try {
       await client.execute(col);
@@ -367,13 +395,62 @@ async function ensureShardSchema(client) {
   `);
   for (const col of [
     "ALTER TABLE relationships ADD COLUMN confidence REAL DEFAULT 1.0",
-    "ALTER TABLE relationships ADD COLUMN confidence_label TEXT DEFAULT 'extracted'"
+    "ALTER TABLE relationships ADD COLUMN confidence_label TEXT DEFAULT 'extracted'",
+    // Temporal validity (must match database.ts)
+    "ALTER TABLE relationships ADD COLUMN valid_from TEXT",
+    "ALTER TABLE relationships ADD COLUMN valid_until TEXT"
   ]) {
     try {
       await client.execute(col);
     } catch {
     }
   }
+  try {
+    await client.execute("ALTER TABLE entities ADD COLUMN parent_type TEXT");
+  } catch {
+  }
+  for (const idx of [
+    "CREATE INDEX IF NOT EXISTS idx_memories_session ON memories(session_id)",
+    "CREATE INDEX IF NOT EXISTS idx_memories_project ON memories(project_name)",
+    "CREATE INDEX IF NOT EXISTS idx_memories_tool ON memories(tool_name)",
+    "CREATE INDEX IF NOT EXISTS idx_memories_content_hash ON memories(content_hash, agent_id)",
+    "CREATE INDEX IF NOT EXISTS idx_memories_quarantined ON memories(quarantined) WHERE quarantined = 1",
+    "CREATE INDEX IF NOT EXISTS idx_memories_draft ON memories(draft) WHERE draft = 1",
+    "CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(memory_type)",
+    "CREATE INDEX IF NOT EXISTS idx_memories_agent_scope_project ON memories(agent_id, session_scope, project_name)",
+    // UNIQUE dedup index — prevents duplicate memories at DB level
+    "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'",
+    // Entity indexes
+    "CREATE INDEX IF NOT EXISTS idx_entities_type_name ON entities(type, name)",
+    // Relationship temporal indexes
+    "CREATE INDEX IF NOT EXISTS idx_relationships_valid_from ON relationships(valid_from)",
+    "CREATE INDEX IF NOT EXISTS idx_relationships_valid_until ON relationships(valid_until)"
+  ]) {
+    try {
+      await client.execute(idx);
+    } catch {
+    }
+  }
+  await client.executeMultiple(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS entities_fts USING fts5(
+      name,
+      content='entities',
+      content_rowid='rowid'
+    );
+
+    CREATE TRIGGER IF NOT EXISTS entities_fts_ai AFTER INSERT ON entities BEGIN
+      INSERT INTO entities_fts(rowid, name) VALUES (new.rowid, new.name);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS entities_fts_ad AFTER DELETE ON entities BEGIN
+      INSERT INTO entities_fts(entities_fts, rowid, name) VALUES('delete', old.rowid, old.name);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS entities_fts_au AFTER UPDATE ON entities BEGIN
+      INSERT INTO entities_fts(entities_fts, rowid, name) VALUES('delete', old.rowid, old.name);
+      INSERT INTO entities_fts(rowid, name) VALUES (new.rowid, new.name);
+    END;
+  `);
 }
 async function getReadyShardClient(projectName) {
   if (!_keyValidated) {

package/dist/{chunk-ZZODXCWK.js → chunk-LT26OOIB.js}

@@ -1,6 +1,6 @@
 import {
   getClient
-} from "./chunk-3HM6MZ4O.js";
+} from "./chunk-YCEJCFU5.js";
 
 // src/lib/session-kill-telemetry.ts
 import crypto from "crypto";

package/dist/{chunk-ATVB6CY7.js → chunk-MLQFGVFJ.js}

@@ -1,6 +1,6 @@
 import {
   loadEmployees
-} from "./chunk-3HM6MZ4O.js";
+} from "./chunk-YCEJCFU5.js";
 
 // src/lib/agent-symlinks.ts
 import os from "os";

package/dist/{chunk-GR53PEEH.js → chunk-NC3NOZHH.js}

@@ -1,6 +1,6 @@
 import {
   getGlobalProceduresBlock
-} from "./chunk-E5P2TY4E.js";
+} from "./chunk-XASY3SCH.js";
 
 // src/lib/employee-templates.ts
 var BASE_OPERATING_PROCEDURES = `

package/dist/{chunk-F3QROFHP.js → chunk-NF7JH5IY.js}

@@ -1,13 +1,13 @@
 import {
   vectorToBlob
-} from "./chunk-6UZHYTLV.js";
+} from "./chunk-KMAYFYW7.js";
 import {
   extractKeywords,
   keywordsToString
 } from "./chunk-CHCA3ZM2.js";
 import {
   isCoordinatorName
-} from "./chunk-3HM6MZ4O.js";
+} from "./chunk-YCEJCFU5.js";
 
 // src/lib/consolidation.ts
 import { randomUUID } from "crypto";

package/dist/{chunk-KVVCXK3J.js → chunk-P7QVZZBS.js}

@@ -1,13 +1,13 @@
 import {
   deactivateBehavior
-} from "./chunk-ZB3TDCXG.js";
+} from "./chunk-BCTU72UR.js";
 import {
   getActiveAgent
-} from "./chunk-QOW5EEYO.js";
+} from "./chunk-Q3FTA4GX.js";
 import {
   canCoordinate,
   getClient
-} from "./chunk-3HM6MZ4O.js";
+} from "./chunk-YCEJCFU5.js";
 
 // src/mcp/tools/deactivate-behavior.ts
 import { z } from "zod";

package/dist/{chunk-YZNGBIXU.js → chunk-POS4PUM7.js}

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

package/dist/{chunk-AWYLVIGA.js → chunk-PQMCT335.js}

@@ -2,7 +2,7 @@ import {
   listWorkflowDefinitions,
   runWorkflow,
   startWorkflow
-} from "./chunk-SUNFUS3O.js";
+} from "./chunk-3YP46SPZ.js";
 import {
   initCRMBridge
 } from "./chunk-ONKIWA3R.js";
@@ -11,7 +11,7 @@ import {
 } from "./chunk-MP2AFCGL.js";
 import {
   getClient
-} from "./chunk-3HM6MZ4O.js";
+} from "./chunk-YCEJCFU5.js";
 
 // src/gateway/router.ts
 function matchesPlatform(msgPlatform, matchPlatform) {

package/dist/{chunk-QOW5EEYO.js → chunk-Q3FTA4GX.js}

@@ -9,7 +9,7 @@ import {
   getCoordinatorEmployee,
   getEmployee,
   loadEmployeesSync
-} from "./chunk-3HM6MZ4O.js";
+} from "./chunk-YCEJCFU5.js";
 import {
   EXE_AI_DIR
 } from "./chunk-4GXRETYL.js";

package/dist/{chunk-TJHE2HYS.js → chunk-Q4XGOMGF.js}

@@ -1,9 +1,9 @@
 import {
   updateTask
-} from "./chunk-AVRQWLQR.js";
+} from "./chunk-DDH7QVQN.js";
 import {
   TASK_ALREADY_CLAIMED_PREFIX
-} from "./chunk-WXQRFDY4.js";
+} from "./chunk-JUKSHMDE.js";
 
 // src/mcp/tools/update-task.ts
 import { z } from "zod";
@@ -23,7 +23,7 @@ function registerUpdateTask(server) {
       const status = rawStatus;
       let callerAgentId;
       try {
-        const { getActiveAgent: getAgent } = await import("./active-agent-J3YKAXE2.js");
+        const { getActiveAgent: getAgent } = await import("./active-agent-MTJPQ57G.js");
         callerAgentId = getAgent().agentId;
       } catch {
       }

package/dist/{chunk-EEG6E34W.js → chunk-QR7CQJVJ.js}

@@ -1,6 +1,6 @@
 import {
   listReminders
-} from "./chunk-Z4FV45FW.js";
+} from "./chunk-DXFNVS44.js";
 
 // src/mcp/tools/list-reminders.ts
 import { z } from "zod";

package/dist/{chunk-P6PKNRFD.js → chunk-T2WX4H6T.js}

@@ -1,6 +1,6 @@
 import {
   routeTask
-} from "./chunk-X2KLWLCB.js";
+} from "./chunk-B4K4EJH7.js";
 import {
   createTaskCore,
   employeeSessionName,
@@ -9,11 +9,11 @@ import {
   isEmployeeAlive,
   sessionScopeFilter,
   updateTaskStatus
-} from "./chunk-WXQRFDY4.js";
+} from "./chunk-JUKSHMDE.js";
 import {
   DEFAULT_COORDINATOR_TEMPLATE_NAME,
   getCoordinatorName
-} from "./chunk-3HM6MZ4O.js";
+} from "./chunk-YCEJCFU5.js";
 
 // src/runtime/orchestrator.ts
 var STALE_THRESHOLD_MS = 2 * 60 * 60 * 1e3;

package/dist/{chunk-GKQXZZBT.js → chunk-T4EQ5SKI.js}

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

package/dist/{chunk-K6A7ZE2F.js → chunk-UCDMLKE5.js}

@@ -1,6 +1,6 @@
 import {
   loadEmployeesSync
-} from "./chunk-3HM6MZ4O.js";
+} from "./chunk-YCEJCFU5.js";
 
 // src/adapters/mcp-http-config.ts
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";

package/dist/{chunk-7YTVWNSS.js → chunk-VBKEAVEU.js}

@@ -1,6 +1,6 @@
 import {
   getClient
-} from "./chunk-3HM6MZ4O.js";
+} from "./chunk-YCEJCFU5.js";
 
 // src/lib/memory-graph-extractor.ts
 function entityId(type, name) {
@@ -179,7 +179,7 @@ async function upsertMemoryGraph(result, memoryId) {
     });
   }
   try {
-    const { createCoOccurrenceEdges } = await import("./co-occurrence-6OAMOUTF.js");
+    const { createCoOccurrenceEdges } = await import("./co-occurrence-J5WOOCWD.js");
     await createCoOccurrenceEdges(result.entities, memoryId);
   } catch {
   }

package/dist/{chunk-OOMA2AEM.js → chunk-W3LYG7QF.js}

@@ -1,6 +1,6 @@
 import {
   processCRMEvent
-} from "./chunk-I3B4QG5C.js";
+} from "./chunk-25YHJFSE.js";
 
 // src/gateway/adapters/crm-webhook.ts
 function parseTwentyWebhook(payload) {

package/dist/{chunk-WVNKXOWZ.js → chunk-WFE44FUV.js}

@@ -111,7 +111,7 @@ function releaseBackfillLock() {
 }
 async function getTaskAwareCapacity() {
   const { getClient } = await import("./lib/database.js");
-  const { sessionScopeFilter } = await import("./task-scope-C7QECQSB.js");
+  const { sessionScopeFilter } = await import("./task-scope-SSM56VHZ.js");
   const client = getClient();
   const scope = sessionScopeFilter();
   const result = await client.execute({

package/dist/{chunk-E5P2TY4E.js → chunk-XASY3SCH.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-2ZYEO7U7.js";
 import {
   getClient
-} from "./chunk-3HM6MZ4O.js";
+} from "./chunk-YCEJCFU5.js";
 
 // src/lib/global-procedures.ts
 import { randomUUID } from "crypto";

package/dist/{chunk-LWM3FUGY.js → chunk-XIXDMUGJ.js}

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

package/dist/{chunk-TBZB4PPZ.js → chunk-XKFIU4UF.js}

@@ -1,21 +1,21 @@
 import {
   recordSessionKill
-} from "./chunk-ZZODXCWK.js";
+} from "./chunk-LT26OOIB.js";
 import {
   sessionScopeFilter,
   verifyPaneAtCapacity,
   writeNotification
-} from "./chunk-WXQRFDY4.js";
+} from "./chunk-JUKSHMDE.js";
 import {
   listSessions
 } from "./chunk-64WZEXXA.js";
 import {
   getTransport
-} from "./chunk-TXWQPL2U.js";
+} from "./chunk-5YDHBZCO.js";
 import {
   getClient,
   isCoordinatorName
-} from "./chunk-3HM6MZ4O.js";
+} from "./chunk-YCEJCFU5.js";
 
 // src/lib/capacity-monitor.ts
 var CAPACITY_PATTERNS = [

package/dist/{chunk-C5A3L3HS.js → chunk-XTHI2OPC.js}

@@ -589,7 +589,7 @@ function auditHookOwnership() {
 }
 async function auditShards() {
   try {
-    const { auditShardHealth } = await import("./shard-manager-KXLEDDBB.js");
+    const { auditShardHealth } = await import("./shard-manager-4PWRZW4V.js");
     const report = await auditShardHealth();
     return {
       total: report.total,
@@ -849,7 +849,7 @@ function formatReport(report, flags) {
   return lines.join("\n");
 }
 async function fixNullVectors() {
-  const { tryAcquireWorkerSlot, registerWorkerPid } = await import("./worker-gate-POIBNVX7.js");
+  const { tryAcquireWorkerSlot, registerWorkerPid } = await import("./worker-gate-BFVWIKDF.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));
@@ -933,7 +933,7 @@ async function fixBloated(client, bloated, dryRun) {
   return chunksCreated;
 }
 async function fixShards(dryRun) {
-  const { auditShardHealth } = await import("./shard-manager-KXLEDDBB.js");
+  const { auditShardHealth } = await import("./shard-manager-4PWRZW4V.js");
   const report = await auditShardHealth({ repair: true, dryRun });
   return {
     total: report.total,
@@ -970,7 +970,7 @@ function splitAtSentences(text, maxChunkSize) {
 }
 async function main(argv = process.argv.slice(2)) {
   const flags = parseFlags(argv);
-  const { fastDbInit } = await import("./fast-db-init-GC4SYSFV.js");
+  const { fastDbInit } = await import("./fast-db-init-BCU67WEQ.js");
   const client = await fastDbInit();
   const report = await runAudit(client, flags);
   console.log(formatReport(report, flags));

package/dist/{chunk-3HM6MZ4O.js → chunk-YCEJCFU5.js}

@@ -13,10 +13,10 @@ import {
 } from "./chunk-LYH5HE24.js";
 
 // src/lib/database.ts
-import { chmodSync, existsSync as existsSync3, statSync, copyFileSync, unlinkSync as unlinkSync2, openSync, closeSync, mkdirSync as mkdirSync2, renameSync as renameSync2 } from "fs";
+import { chmodSync, existsSync as existsSync3, statSync, copyFileSync, unlinkSync as unlinkSync2, openSync, closeSync, mkdirSync as mkdirSync2, renameSync as renameSync2, readdirSync as readdirSync2 } from "fs";
 import { createClient } from "@libsql/client";
 import { homedir } from "os";
-import { join } from "path";
+import { join, dirname, basename } from "path";
 
 // src/lib/db-retry.ts
 var MAX_RETRIES = 5;
@@ -1307,6 +1307,26 @@ async function initDatabase(config) {
       _adapterClient = _resilientClient;
     }
   }
+  try {
+    const dbDir = dirname(config.dbPath);
+    const dbBase = basename(config.dbPath);
+    const maxAge = 7 * 24 * 60 * 60 * 1e3;
+    const now = Date.now();
+    for (const f of readdirSync2(dbDir)) {
+      if (!f.startsWith(dbBase + ".corrupt-") && !f.startsWith(dbBase + ".zeroed-")) continue;
+      const filePath = join(dbDir, f);
+      try {
+        const st = statSync(filePath);
+        if (now - st.mtimeMs > maxAge) {
+          unlinkSync2(filePath);
+          process.stderr.write(`[database] Cleaned up old corrupt backup: ${f} (${Math.round(st.size / 1024 / 1024)}MB)
+`);
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
   if (_walCheckpointTimer) clearInterval(_walCheckpointTimer);
   _walCheckpointTimer = setInterval(() => {
     _client?.execute("PRAGMA wal_checkpoint(PASSIVE)").catch(() => {