@askexenow/exe-os 0.9.340 → 0.9.342

package/dist/{chunk-ZREGOV2Q.js → chunk-N7QJKQMX.js}

@@ -8,21 +8,225 @@ import {
   buildStatusFilter,
   buildWikiScopeFilter,
   searchMemories
-} from "./chunk-H37HHX3E.js";
+} from "./chunk-VSRPS3J7.js";
 import {
   blobToVector
 } from "./chunk-OTVEIJUQ.js";
+import {
+  normalizeSessionScope,
+  resolveCurrentTask
+} from "./chunk-76CJBM36.js";
+import {
+  getAgentContext
+} from "./chunk-GJV3WDWM.js";
 import {
   getClient
-} from "./chunk-HEPR6QTL.js";
+} from "./chunk-AOHXREB7.js";
+
+// src/lib/memory-reads.ts
+import crypto from "crypto";
+var MAX_BUFFER = 5e3;
+var FLUSH_AT = 256;
+var FLUSH_DEBOUNCE_MS = 2e3;
+var ATTRIBUTION_TTL_MS = 5e3;
+var DEFAULT_RETENTION_DAYS = 30;
+var DEFAULT_MAX_ROWS = 2e5;
+var SWEEP_INTERVAL_MS = 60 * 60 * 1e3;
+var buffer = [];
+var flushTimer = null;
+var flushing = false;
+var lastSweepAt = 0;
+function readLogEnabled() {
+  return process.env.EXE_READ_LOG !== "0";
+}
+var attributionCache = /* @__PURE__ */ new Map();
+function loadAttribution(agentId, sessionScope) {
+  try {
+    const marker = resolveCurrentTask(agentId, sessionScope);
+    return {
+      taskId: marker?.taskId ?? null,
+      sessionScope: marker?.sessionScope ?? sessionScope ?? null
+    };
+  } catch {
+    return { taskId: null, sessionScope: sessionScope ?? null };
+  }
+}
+function getAttribution(agentId, sessionScope) {
+  const key = `${agentId}::${sessionScope ?? ""}`;
+  const entry = attributionCache.get(key);
+  const now = Date.now();
+  if (!entry) {
+    const value = loadAttribution(agentId, sessionScope);
+    attributionCache.set(key, { value, at: now, refreshing: false });
+    return value;
+  }
+  if (now - entry.at > ATTRIBUTION_TTL_MS && !entry.refreshing) {
+    entry.refreshing = true;
+    setImmediate(() => {
+      try {
+        entry.value = loadAttribution(agentId, sessionScope);
+        entry.at = Date.now();
+      } catch {
+      } finally {
+        entry.refreshing = false;
+      }
+    });
+  }
+  return entry.value;
+}
+function recordMemoryReads(input) {
+  try {
+    if (!readLogEnabled()) return;
+    const { memoryIds } = input;
+    if (!memoryIds || memoryIds.length === 0) return;
+    const scopeHint = input.sessionScope ?? getAgentContext()?.sessionHint;
+    let taskId = input.taskId ?? null;
+    let sessionScope = normalizeSessionScope(scopeHint) ?? null;
+    if (input.taskId === void 0) {
+      const attribution = getAttribution(input.agentId, scopeHint);
+      taskId = attribution.taskId;
+      sessionScope = attribution.sessionScope;
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const query = input.query ? input.query.slice(0, 500) : null;
+    const seen = /* @__PURE__ */ new Set();
+    let rank = 0;
+    for (const memoryId of memoryIds) {
+      if (!memoryId || seen.has(memoryId)) continue;
+      seen.add(memoryId);
+      rank++;
+      buffer.push({
+        id: crypto.randomUUID(),
+        memory_id: memoryId,
+        agent_id: input.agentId ?? null,
+        task_id: taskId,
+        session_scope: sessionScope,
+        source: input.source,
+        query,
+        rank_position: rank,
+        timestamp
+      });
+    }
+    if (buffer.length > MAX_BUFFER) {
+      buffer = buffer.slice(buffer.length - MAX_BUFFER);
+    }
+    scheduleFlush();
+  } catch {
+  }
+}
+function scheduleFlush() {
+  if (buffer.length >= FLUSH_AT) {
+    void flushMemoryReads();
+    return;
+  }
+  if (flushTimer) return;
+  flushTimer = setTimeout(() => {
+    flushTimer = null;
+    void flushMemoryReads();
+  }, FLUSH_DEBOUNCE_MS);
+  flushTimer.unref?.();
+}
+async function flushMemoryReads() {
+  if (flushing) return;
+  if (buffer.length === 0) return;
+  flushing = true;
+  const batch = buffer;
+  buffer = [];
+  if (flushTimer) {
+    clearTimeout(flushTimer);
+    flushTimer = null;
+  }
+  try {
+    const client = getClient();
+    const CHUNK = 200;
+    for (let i = 0; i < batch.length; i += CHUNK) {
+      const chunk = batch.slice(i, i + CHUNK);
+      const placeholders = chunk.map(() => "(?,?,?,?,?,?,?,?,?)").join(",");
+      const args = [];
+      for (const r of chunk) {
+        args.push(
+          r.id,
+          r.memory_id,
+          r.agent_id,
+          r.task_id,
+          r.session_scope,
+          r.source,
+          r.query,
+          r.rank_position,
+          r.timestamp
+        );
+      }
+      await client.execute({
+        sql: `INSERT INTO memory_reads
+                (id, memory_id, agent_id, task_id, session_scope, source, query, rank_position, timestamp)
+              VALUES ${placeholders}`,
+        args
+      });
+    }
+    void maybeSweep();
+  } catch {
+  } finally {
+    flushing = false;
+  }
+}
+function retentionDays() {
+  const raw = Number(process.env.EXE_READ_LOG_RETENTION_DAYS);
+  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_RETENTION_DAYS;
+}
+function maxRows() {
+  const raw = Number(process.env.EXE_READ_LOG_MAX_ROWS);
+  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_MAX_ROWS;
+}
+async function maybeSweep() {
+  const now = Date.now();
+  if (now - lastSweepAt < SWEEP_INTERVAL_MS) return;
+  lastSweepAt = now;
+  await sweepMemoryReads({ retentionDays: retentionDays(), maxRows: maxRows() });
+}
+async function sweepMemoryReads(options) {
+  const days = options?.retentionDays ?? retentionDays();
+  const cap = options?.maxRows ?? maxRows();
+  try {
+    const client = getClient();
+    const cutoff = new Date(Date.now() - days * 24 * 3600 * 1e3).toISOString();
+    await client.execute({
+      sql: `DELETE FROM memory_reads WHERE timestamp < ?`,
+      args: [cutoff]
+    });
+    const counted = await client.execute("SELECT COUNT(*) AS c FROM memory_reads");
+    const total = Number(counted.rows[0]?.c ?? 0);
+    if (total > cap) {
+      await client.execute({
+        sql: `DELETE FROM memory_reads WHERE id IN (
+                SELECT id FROM memory_reads ORDER BY timestamp ASC LIMIT ?
+              )`,
+        args: [total - cap]
+      });
+    }
+    if (options?.force) lastSweepAt = Date.now();
+  } catch {
+  }
+}
 
 // src/lib/hybrid-search.ts
+import { createHash } from "crypto";
 var RRF_K = 60;
 var DAEMON_SAFE_FTS_TERM_THRESHOLD = 3;
 var DAEMON_SAFE_FTS_MAX_TERMS = 5;
 var _daemonBroadFtsSkipLogged = false;
 var _daemonGraphFtsSkipLogged = false;
 var _hybridDegradeWarned = false;
+function searchQualityQuerySnapshot(queryText) {
+  const normalized = queryText.replace(/\s+/g, " ").trim();
+  const queryHash = createHash("sha256").update(queryText).digest("hex");
+  const maxPreview = Number(process.env.EXE_SEARCH_LOG_QUERY_PREVIEW_CHARS ?? 96);
+  const safeMaxPreview = Number.isFinite(maxPreview) && maxPreview > 0 ? Math.min(maxPreview, 256) : 96;
+  const query = normalized.length > safeMaxPreview ? `${normalized.slice(0, safeMaxPreview)}\u2026` : normalized;
+  if (process.env.EXE_SEARCH_LOG_FULL_TEXT === "1") {
+    return { query, queryHash, queryFull: queryText };
+  }
+  return { query, queryHash };
+}
 function isDaemonProcess() {
   return process.env.EXE_IS_DAEMON === "1";
 }
@@ -359,7 +563,7 @@ async function hybridSearch(queryText, agentId, options) {
   let rerankerAvailable = false;
   if (process.env.EXE_IS_DAEMON === "1") {
     try {
-      const { isRerankerAvailable } = await import("./reranker-QATGTAPC.js");
+      const { isRerankerAvailable } = await import("./reranker-GYYRPANK.js");
       rerankerAvailable = isRerankerAvailable();
     } catch {
     }
@@ -384,7 +588,8 @@ async function hybridSearch(queryText, agentId, options) {
     }
   }
   let grepPromise = Promise.resolve([]);
-  if (config.fileGrepEnabled === true && !process.env.VITEST) {
+  const onFailOpenHotPath = process.env.EXE_HOOK_FAIL_OPEN === "1";
+  if (config.fileGrepEnabled === true && !process.env.VITEST && !onFailOpenHotPath) {
     try {
       if (process.env.EXE_IS_DAEMON !== "1") {
         const { getProjectName } = await import("./project-name-EWG5KAZP.js");
@@ -427,7 +632,7 @@ async function hybridSearch(queryText, agentId, options) {
     ]).catch(() => []),
     includeStructuredCards ? (async () => {
       try {
-        const { searchMemoryCards } = await import("./memory-cards-TQRLZI4D.js");
+        const { searchMemoryCards } = await import("./memory-cards-ZRDW7QBX.js");
         return await searchMemoryCards(effectiveQuery, agentId, fetchOptions);
       } catch {
         return [];
@@ -436,7 +641,7 @@ async function hybridSearch(queryText, agentId, options) {
     // Reflection insights: patterns, contradictions, summaries across sessions
     includeStructuredCards ? (async () => {
       try {
-        const { searchReflections } = await import("./memory-reflection-6N4J2FL7.js");
+        const { searchReflections } = await import("./memory-reflection-WVNFBJAA.js");
         const insights = await searchReflections(effectiveQuery, agentId, 5, {
           includeArchived: options?.includeArchived
         });
@@ -537,7 +742,7 @@ async function hybridSearch(queryText, agentId, options) {
   let entityBoostRan = false;
   if (merged.length > 0) {
     try {
-      const { applyEntityBoost } = await import("./entity-boost-DNI4A5I7.js");
+      const { applyEntityBoost } = await import("./entity-boost-NT6UO2Z3.js");
       const boosted = await applyEntityBoost(merged, effectiveQuery, getClient());
       merged = boosted.results;
       graphContextMap = boosted.graphContext;
@@ -561,7 +766,7 @@ async function hybridSearch(queryText, agentId, options) {
     try {
       let rerankedRecords;
       if (graphContextMap.size > 0) {
-        const { rerankWithContext } = await import("./reranker-QATGTAPC.js");
+        const { rerankWithContext } = await import("./reranker-GYYRPANK.js");
         const candidates = merged.map((m) => ({
           text: m.raw_text,
           context: graphContextMap.get(m.id)
@@ -569,7 +774,7 @@ async function hybridSearch(queryText, agentId, options) {
         const scored = await rerankWithContext(effectiveQuery, candidates, rerankReturnLimit);
         rerankedRecords = scored.map((s) => merged[s.index]);
       } else {
-        const { rerank } = await import("./reranker-QATGTAPC.js");
+        const { rerank } = await import("./reranker-GYYRPANK.js");
         rerankedRecords = await rerank(effectiveQuery, merged, rerankReturnLimit);
       }
       if (rerankedRecords.length > 0) {
@@ -619,9 +824,10 @@ async function hybridSearch(queryText, agentId, options) {
     await attachDocumentMetadata(finalResults);
   }
   if (process.env.EXE_SEARCH_LOG !== "0") {
+    const querySnapshot = searchQualityQuerySnapshot(queryText);
     const logEntry = {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      query: queryText,
+      ...querySnapshot,
       agentId,
       signals: {
         fts: ftsResults.length,
@@ -657,12 +863,24 @@ async function hybridSearch(queryText, agentId, options) {
       const path = await import("path");
       const os = await import("os");
       const logPath = path.join(os.homedir(), ".exe-os", "search-quality.jsonl");
-      fs.mkdirSync(path.dirname(logPath), { recursive: true });
+      fs.mkdirSync(path.dirname(logPath), { recursive: true, mode: 448 });
+      try {
+        fs.chmodSync(path.dirname(logPath), 448);
+      } catch {
+      }
       const MAX_LOG_BYTES = 5 * 1024 * 1024;
       try {
         const stat = fs.statSync(logPath);
+        try {
+          fs.chmodSync(logPath, 384);
+        } catch {
+        }
         if (stat.size > MAX_LOG_BYTES) {
           fs.renameSync(logPath, logPath + ".1");
+          try {
+            fs.chmodSync(logPath + ".1", 384);
+          } catch {
+          }
         }
       } catch {
       }
@@ -674,10 +892,28 @@ async function hybridSearch(queryText, agentId, options) {
         }
       } catch {
       }
+      const fd = fs.openSync(logPath, "a", 384);
+      fs.closeSync(fd);
+      try {
+        fs.chmodSync(logPath, 384);
+      } catch {
+      }
       fs.appendFileSync(logPath, JSON.stringify(logEntry) + "\n");
+      try {
+        fs.chmodSync(logPath, 384);
+      } catch {
+      }
     } catch {
     }
   }
+  if (finalResults.length > 0) {
+    recordMemoryReads({
+      agentId,
+      query: queryText,
+      source: "memory",
+      memoryIds: finalResults.map((r) => r.id)
+    });
+  }
   if (finalResults.length > 0) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const ids = finalResults.filter((r) => !r._isNeighbor).map((r) => r.id);
@@ -931,15 +1167,23 @@ async function lightweightSearch(queryText, agentId, options) {
   }
   if (results.length >= 2) {
     try {
-      const { recordCoActivations } = await import("./co-activation-XMPHKGHR.js");
+      const { recordCoActivations } = await import("./co-activation-ZCHPLLP6.js");
       const ids = results.slice(0, 10).map((r) => r.id);
-      void recordCoActivations(ids);
+      void recordCoActivations(ids).catch((e) => {
+        try {
+          process.stderr.write(
+            `[hybrid-search] co-activation recording failed (non-fatal): ${e instanceof Error ? e.message : String(e)}
+`
+          );
+        } catch {
+        }
+      });
     } catch {
     }
   }
   if (options?.includeStructuredCards !== true) return results;
   try {
-    const { searchMemoryCards } = await import("./memory-cards-TQRLZI4D.js");
+    const { searchMemoryCards } = await import("./memory-cards-ZRDW7QBX.js");
     const cardResults = await searchMemoryCards(queryText, agentId, options);
     if (cardResults.length > 0) {
       return rrfMergeMulti([results, cardResults], limit, RRF_K, [1, 0.85]);

package/dist/{chunk-QLFRCA6I.js → chunk-NBZL5CGA.js}

@@ -1,8 +1,20 @@
+import {
+  decryptSyncBlob,
+  encryptSyncBlob,
+  isSyncCryptoInitialized
+} from "./chunk-S3THSOWV.js";
+
 // src/lib/crdt-sync.ts
 import * as Y from "yjs";
-import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync, renameSync } from "fs";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync, renameSync, chmodSync } from "fs";
 import path from "path";
 import { homedir } from "os";
+var CRDT_STATE_ENC_MAGIC = "EXEO-CRDT-ENC1:";
+function isEncryptedCrdtState(buf) {
+  const magic = Buffer.from(CRDT_STATE_ENC_MAGIC, "utf8");
+  if (buf.length < magic.length) return false;
+  return Buffer.from(buf.subarray(0, magic.length)).equals(magic);
+}
 var DEFAULT_STATE_PATH = path.join(homedir(), ".exe-os", "crdt-state.bin");
 var _statePathOverride = null;
 function getStatePath() {
@@ -12,6 +24,9 @@ function _setStatePath(p) {
   _statePathOverride = p;
 }
 var doc = null;
+var loadSkippedPendingCrypto = false;
+var _warnedPersistNoCrypto = false;
+var _warnedPersistBlocked = false;
 var SYNC_TYPES = [
   {
     mapName: "memories",
@@ -106,28 +121,73 @@ function importRecords(mapName, records) {
   });
   return imported;
 }
+function quarantineStateFile(sp, reason) {
+  try {
+    const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const dest = `${sp}.unreadable-${ts}`;
+    renameSync(sp, dest);
+    try {
+      chmodSync(dest, 384);
+    } catch {
+    }
+    console.warn(`[crdt-sync] WARN: ${reason}: quarantined ${path.basename(sp)} -> ${path.basename(dest)} (NOT deleted); rebuilding from DB`);
+  } catch (err) {
+    console.warn(`[crdt-sync] WARN: ${reason}: could not quarantine ${path.basename(sp)} (${err instanceof Error ? err.message : String(err)}); leaving it in place and rebuilding from DB`);
+  }
+}
+function scheduleRebuildFromDb() {
+  rebuildFromDb().catch((err) => {
+    console.warn("[crdt-sync] rebuild from DB failed:", err);
+  });
+}
 function initCrdtDoc() {
   if (doc) return doc;
   doc = new Y.Doc();
   const sp = getStatePath();
+  let migratedLegacyPlaintext = false;
+  loadSkippedPendingCrypto = false;
   if (existsSync(sp)) {
+    let raw = null;
     try {
-      const state = readFileSync(sp);
-      Y.applyUpdate(doc, new Uint8Array(state));
-    } catch {
-      console.warn("[crdt-sync] WARN: corrupted state file, rebuilding from DB");
-      try {
-        unlinkSync(sp);
-      } catch {
+      raw = readFileSync(sp);
+    } catch (err) {
+      console.warn(`[crdt-sync] WARN: could not read state file (${err instanceof Error ? err.message : String(err)}); leaving it in place and rebuilding from DB`);
+      scheduleRebuildFromDb();
+    }
+    if (raw !== null) {
+      if (raw.length === 0) {
+        quarantineStateFile(sp, "empty state file");
+        scheduleRebuildFromDb();
+      } else if (isEncryptedCrdtState(raw)) {
+        if (!isSyncCryptoInitialized()) {
+          loadSkippedPendingCrypto = true;
+          console.warn("[crdt-sync] WARN: encrypted state present but sync crypto not initialized; skipping load and BLOCKING overwrite until a successful load (state preserved)");
+        } else {
+          try {
+            const blob = raw.subarray(CRDT_STATE_ENC_MAGIC.length).toString("utf8");
+            Y.applyUpdate(doc, new Uint8Array(decryptSyncBlob(blob)));
+          } catch (err) {
+            console.warn(`[crdt-sync] WARN: could not decrypt state file (${err instanceof Error ? err.message : String(err)}) \u2014 likely a rotated/foreign key`);
+            quarantineStateFile(sp, "decrypt failed");
+            scheduleRebuildFromDb();
+          }
+        }
+      } else {
+        try {
+          Y.applyUpdate(doc, new Uint8Array(raw));
+          migratedLegacyPlaintext = true;
+        } catch (err) {
+          console.warn(`[crdt-sync] WARN: state file is neither encrypted nor a valid legacy update (${err instanceof Error ? err.message : String(err)})`);
+          quarantineStateFile(sp, "unparseable state file");
+          scheduleRebuildFromDb();
+        }
       }
-      rebuildFromDb().catch((err) => {
-        console.warn("[crdt-sync] rebuild from DB failed:", err);
-      });
     }
   }
   doc.on("update", () => {
     persistState();
   });
+  if (migratedLegacyPlaintext) persistState();
   return doc;
 }
 function getMemoriesMap() {
@@ -208,14 +268,30 @@ function onUpdate(callback) {
 }
 function persistState() {
   if (!doc) return;
+  if (loadSkippedPendingCrypto) {
+    if (!_warnedPersistBlocked) {
+      _warnedPersistBlocked = true;
+      console.warn("[crdt-sync] WARN: refusing to persist \u2014 on-disk encrypted state was not loaded this session (sync crypto uninitialized). CRDT deltas are NOT being written to avoid overwriting recoverable state.");
+    }
+    return;
+  }
+  if (!isSyncCryptoInitialized()) {
+    if (!_warnedPersistNoCrypto) {
+      _warnedPersistNoCrypto = true;
+      console.warn("[crdt-sync] WARN: sync crypto not initialized \u2014 CRDT state cannot be encrypted and will NOT be persisted this session. Deltas remain in memory only.");
+    }
+    return;
+  }
   try {
     const sp = getStatePath();
     const dir = path.dirname(sp);
     if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
     const state = Y.encodeStateAsUpdate(doc);
+    const encoded = CRDT_STATE_ENC_MAGIC + encryptSyncBlob(Buffer.from(state));
     const tmp = `${sp}.tmp-${process.pid}-${Date.now()}`;
     try {
-      writeFileSync(tmp, Buffer.from(state));
+      writeFileSync(tmp, encoded, { mode: 384 });
+      chmodSync(tmp, 384);
       renameSync(tmp, sp);
     } catch (err) {
       try {
@@ -256,9 +332,14 @@ function destroyCrdtDoc() {
     doc.destroy();
     doc = null;
   }
+  loadSkippedPendingCrypto = false;
+  _warnedPersistNoCrypto = false;
+  _warnedPersistBlocked = false;
 }
 
 export {
+  CRDT_STATE_ENC_MAGIC,
+  isEncryptedCrdtState,
   _setStatePath,
   initCrdtDoc,
   applyRemoteUpdate,

package/dist/{chunk-QFPTDSY2.js → chunk-NN2B2QKU.js}

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

package/dist/chunk-NX5INHHG.js

@@ -0,0 +1,40 @@
+import {
+  createReminder
+} from "./chunk-UUEKJDK6.js";
+
+// src/mcp/tools/create-reminder.ts
+import { z } from "zod";
+function registerCreateReminder(server) {
+  server.registerTool(
+    "create_reminder",
+    {
+      title: "Create Reminder",
+      description: "Set a reminder for the founder. Shown in the boot brief every session.",
+      inputSchema: {
+        text: z.string().describe("What to remind about"),
+        due_date: z.string().optional().describe("Optional due date \u2014 ISO date (2026-04-01) or null for persistent"),
+        daily_push: z.string().optional().describe('Optional daily push schedule \u2014 JSON {"hours":[9,18]} (0\u201323, founder timezone). A gateway channel pushes this reminder at those hours.')
+      }
+    },
+    async ({ text, due_date, daily_push }) => {
+      let reminder;
+      try {
+        reminder = await createReminder(text, due_date, daily_push);
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: err instanceof Error ? err.message : String(err) }],
+          isError: true
+        };
+      }
+      const dueStr = reminder.dueDate ? ` (due: ${reminder.dueDate})` : "";
+      const pushStr = reminder.dailyPush ? ` (daily push: ${reminder.dailyPush})` : "";
+      return {
+        content: [{ type: "text", text: `Reminder set: "${reminder.text}"${dueStr}${pushStr}` }]
+      };
+    }
+  );
+}
+
+export {
+  registerCreateReminder
+};

package/dist/{chunk-B75BOKEI.js → chunk-NXUSDL37.js}

@@ -1,10 +1,10 @@
 import {
   isValidX25519Recipient,
   pubKeyHash
-} from "./chunk-JCBKARSK.js";
+} from "./chunk-IOEUAQWP.js";
 import {
   EXE_AI_DIR
-} from "./chunk-7Y5UDEVM.js";
+} from "./chunk-WZHZCDDO.js";
 
 // src/lib/monitor-grants.ts
 import crypto from "crypto";

package/dist/{chunk-TPHCZDE3.js → chunk-O5V57XYE.js}

@@ -1,6 +1,6 @@
 import {
   EXE_AI_DIR
-} from "./chunk-7Y5UDEVM.js";
+} from "./chunk-WZHZCDDO.js";
 
 // src/lib/branding.ts
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";