@askexenow/exe-os 0.9.21 → 0.9.23

package/dist/hooks/subagent-stop.js

@@ -1266,6 +1266,17 @@ var init_daemon_auth = __esm({
 });
 
 // src/lib/exe-daemon-client.ts
+var exe_daemon_client_exports = {};
+__export(exe_daemon_client_exports, {
+  connectEmbedDaemon: () => connectEmbedDaemon,
+  disconnectClient: () => disconnectClient,
+  embedBatchViaClient: () => embedBatchViaClient,
+  embedViaClient: () => embedViaClient,
+  isClientConnected: () => isClientConnected,
+  pingDaemon: () => pingDaemon,
+  sendDaemonRequest: () => sendDaemonRequest,
+  sendIngestRequest: () => sendIngestRequest
+});
 import net from "net";
 import os6 from "os";
 import { spawn } from "child_process";
@@ -1502,6 +1513,9 @@ async function connectEmbedDaemon() {
   }
   return false;
 }
+function sendRequest(texts, priority) {
+  return sendDaemonRequest({ texts, priority });
+}
 function sendDaemonRequest(payload, timeoutMs = REQUEST_TIMEOUT_MS) {
   return new Promise((resolve) => {
     if (!_socket || !_connected) {
@@ -1524,10 +1538,170 @@ function sendDaemonRequest(payload, timeoutMs = REQUEST_TIMEOUT_MS) {
     }
   });
 }
+async function pingDaemon() {
+  if (!_socket || !_connected) return null;
+  const response = await sendDaemonRequest({ type: "health" }, 5e3);
+  if (response.health) {
+    return response.health;
+  }
+  return null;
+}
+function killAndRespawnDaemon() {
+  if (!acquireSpawnLock()) {
+    process.stderr.write("[exed-client] Another process is already restarting daemon \u2014 skipping\n");
+    if (_socket) {
+      _socket.destroy();
+      _socket = null;
+    }
+    _connected = false;
+    _buffer = "";
+    return;
+  }
+  try {
+    process.stderr.write("[exed-client] Killing daemon for restart...\n");
+    if (existsSync7(PID_PATH)) {
+      try {
+        const pid = parseInt(readFileSync7(PID_PATH, "utf8").trim(), 10);
+        if (pid > 0) {
+          try {
+            process.kill(pid, "SIGKILL");
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+    if (_socket) {
+      _socket.destroy();
+      _socket = null;
+    }
+    _connected = false;
+    _buffer = "";
+    try {
+      unlinkSync3(PID_PATH);
+    } catch {
+    }
+    try {
+      unlinkSync3(SOCKET_PATH);
+    } catch {
+    }
+    spawnDaemon();
+  } finally {
+    releaseSpawnLock();
+  }
+}
+function isDaemonTooYoung() {
+  try {
+    const stat = statSync(PID_PATH);
+    return Date.now() - stat.mtimeMs < MIN_DAEMON_AGE_MS;
+  } catch {
+    return false;
+  }
+}
+async function retryThenRestart(doRequest, label) {
+  const result = await doRequest();
+  if (!result.error) {
+    _consecutiveFailures = 0;
+    return result;
+  }
+  _consecutiveFailures++;
+  for (let i = 0; i < MAX_RETRIES_BEFORE_RESTART; i++) {
+    const delayMs = RETRY_DELAYS_MS[i] ?? 5e3;
+    process.stderr.write(`[exed-client] ${label} failed (${result.error}), retry ${i + 1}/${MAX_RETRIES_BEFORE_RESTART} in ${delayMs}ms
+`);
+    await new Promise((r) => setTimeout(r, delayMs));
+    if (!_connected) {
+      if (!await connectToSocket()) continue;
+    }
+    const retry = await doRequest();
+    if (!retry.error) {
+      _consecutiveFailures = 0;
+      return retry;
+    }
+    _consecutiveFailures++;
+  }
+  if (isDaemonTooYoung()) {
+    process.stderr.write(`[exed-client] ${label}: daemon too young (< ${MIN_DAEMON_AGE_MS / 1e3}s) \u2014 skipping restart
+`);
+    return { error: result.error };
+  }
+  process.stderr.write(`[exed-client] ${label}: ${_consecutiveFailures} consecutive failures \u2014 restarting daemon
+`);
+  killAndRespawnDaemon();
+  const start = Date.now();
+  let delay2 = 200;
+  while (Date.now() - start < CONNECT_TIMEOUT_MS) {
+    await new Promise((r) => setTimeout(r, delay2));
+    if (await connectToSocket()) break;
+    delay2 = Math.min(delay2 * 2, 3e3);
+  }
+  if (!_connected) return { error: "Daemon restart failed" };
+  const final = await doRequest();
+  if (!final.error) _consecutiveFailures = 0;
+  return final;
+}
+async function embedViaClient(text, priority = "high") {
+  if (!_connected && !await connectEmbedDaemon()) return null;
+  _requestCount++;
+  if (_requestCount % HEALTH_CHECK_INTERVAL === 0) {
+    const health = await pingDaemon();
+    if (!health && !isDaemonTooYoung()) {
+      process.stderr.write(`[exed-client] Periodic health check failed at request ${_requestCount} \u2014 restarting daemon
+`);
+      killAndRespawnDaemon();
+      const start = Date.now();
+      let d = 200;
+      while (Date.now() - start < CONNECT_TIMEOUT_MS) {
+        await new Promise((r) => setTimeout(r, d));
+        if (await connectToSocket()) break;
+        d = Math.min(d * 2, 3e3);
+      }
+      if (!_connected) return null;
+    }
+  }
+  const result = await retryThenRestart(
+    () => sendRequest([text], priority),
+    "Embed"
+  );
+  return !result.error && result.vectors?.[0] ? result.vectors[0] : null;
+}
+async function embedBatchViaClient(texts, priority = "high") {
+  if (!_connected && !await connectEmbedDaemon()) return null;
+  _requestCount++;
+  const result = await retryThenRestart(
+    () => sendRequest(texts, priority),
+    "Batch embed"
+  );
+  return !result.error && result.vectors ? result.vectors : null;
+}
+function disconnectClient() {
+  if (_socket) {
+    _socket.destroy();
+    _socket = null;
+  }
+  _connected = false;
+  _buffer = "";
+  for (const [id, entry] of _pending) {
+    clearTimeout(entry.timer);
+    _pending.delete(id);
+    entry.resolve({ error: "Client disconnected" });
+  }
+}
 function isClientConnected() {
   return _connected;
 }
-var SOCKET_PATH, PID_PATH, SPAWN_LOCK_PATH, SPAWN_LOCK_STALE_MS, CONNECT_TIMEOUT_MS, REQUEST_TIMEOUT_MS, DAEMON_TOKEN_ENV, _socket, _connected, _buffer, _pending, MAX_BUFFER;
+function sendIngestRequest(payload) {
+  if (!_socket || !_connected) return false;
+  try {
+    const id = randomUUID();
+    const token = process.env[DAEMON_TOKEN_ENV] ?? readDaemonToken();
+    _socket.write(JSON.stringify({ id, token, type: "ingest", ...payload }) + "\n");
+    return true;
+  } catch {
+    return false;
+  }
+}
+var SOCKET_PATH, PID_PATH, SPAWN_LOCK_PATH, SPAWN_LOCK_STALE_MS, CONNECT_TIMEOUT_MS, REQUEST_TIMEOUT_MS, DAEMON_TOKEN_ENV, _socket, _connected, _buffer, _requestCount, _consecutiveFailures, HEALTH_CHECK_INTERVAL, MAX_RETRIES_BEFORE_RESTART, RETRY_DELAYS_MS, MIN_DAEMON_AGE_MS, _pending, MAX_BUFFER;
 var init_exe_daemon_client = __esm({
   "src/lib/exe-daemon-client.ts"() {
     "use strict";
@@ -1543,12 +1717,27 @@ var init_exe_daemon_client = __esm({
     _socket = null;
     _connected = false;
     _buffer = "";
+    _requestCount = 0;
+    _consecutiveFailures = 0;
+    HEALTH_CHECK_INTERVAL = 100;
+    MAX_RETRIES_BEFORE_RESTART = 3;
+    RETRY_DELAYS_MS = [1e3, 3e3, 5e3];
+    MIN_DAEMON_AGE_MS = 3e4;
     _pending = /* @__PURE__ */ new Map();
     MAX_BUFFER = 1e7;
   }
 });
 
 // src/lib/daemon-protocol.ts
+var daemon_protocol_exports = {};
+__export(daemon_protocol_exports, {
+  deserializeArgs: () => deserializeArgs,
+  deserializeResultSet: () => deserializeResultSet,
+  deserializeValue: () => deserializeValue,
+  serializeArgs: () => serializeArgs,
+  serializeResultSet: () => serializeResultSet,
+  serializeValue: () => serializeValue
+});
 function serializeValue(v) {
   if (v === null || v === void 0) return null;
   if (typeof v === "bigint") return Number(v);
@@ -1573,6 +1762,32 @@ function deserializeValue(v) {
   }
   return v;
 }
+function serializeArgs(args) {
+  return args.map(serializeValue);
+}
+function deserializeArgs(args) {
+  return args.map(deserializeValue);
+}
+function serializeResultSet(rs) {
+  const rows = [];
+  for (const row of rs.rows) {
+    const obj = {};
+    for (let i = 0; i < rs.columns.length; i++) {
+      const col = rs.columns[i];
+      if (col !== void 0) {
+        obj[col] = serializeValue(row[i]);
+      }
+    }
+    rows.push(obj);
+  }
+  return {
+    columns: [...rs.columns],
+    columnTypes: [...rs.columnTypes ?? []],
+    rows,
+    rowsAffected: typeof rs.rowsAffected === "bigint" ? Number(rs.rowsAffected) : rs.rowsAffected ?? 0,
+    lastInsertRowid: rs.lastInsertRowid != null ? typeof rs.lastInsertRowid === "bigint" ? Number(rs.lastInsertRowid) : rs.lastInsertRowid : null
+  };
+}
 function deserializeResultSet(srs) {
   const rows = srs.rows.map((obj) => {
     const values = srs.columns.map(
@@ -3137,8 +3352,8 @@ function getShardClient(projectName) {
     throw new Error("Shard manager not initialized. Call initShardManager() first.");
   }
   const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
-  if (!safeName) {
-    throw new Error(`Invalid project name for shard: "${projectName}"`);
+  if (!safeName || safeName === "unknown") {
+    throw new Error(`Invalid project name for shard: "${projectName}" (resolved to "${safeName}")`);
   }
   const cached = _shards.get(safeName);
   if (cached) {
@@ -4007,19 +4222,32 @@ async function flushBatch() {
       const { isShardingEnabled: isShardingEnabled2, getReadyShardClient: getReadyShardClient2 } = await Promise.resolve().then(() => (init_shard_manager(), shard_manager_exports));
       if (isShardingEnabled2()) {
         const byProject = /* @__PURE__ */ new Map();
+        let skippedUnknown = 0;
         for (const row of batch) {
-          const proj = row.project_name || "unknown";
+          const proj = row.project_name?.trim();
+          if (!proj) {
+            skippedUnknown++;
+            continue;
+          }
           if (!byProject.has(proj)) byProject.set(proj, []);
           byProject.get(proj).push(row);
         }
+        if (skippedUnknown > 0) {
+          process.stderr.write(
+            `[store] Shard skip: ${skippedUnknown} record(s) with empty project_name (kept in main DB only)
+`
+          );
+        }
         for (const [project, rows] of byProject) {
           try {
             const shardClient = await getReadyShardClient2(project);
             const shardStmts = rows.map(buildStmt);
             await shardClient.batch(shardStmts, "write");
           } catch (err) {
+            const fullError = err instanceof Error ? `${err.name}: ${err.message}${err.stack ? `
+${err.stack.split("\n").slice(1, 3).join("\n")}` : ""}` : String(err);
             process.stderr.write(
-              `[store] Shard write failed for ${project}: ${err instanceof Error ? err.message : String(err)}
+              `[store] Shard write failed for ${project} (${rows.length} records): ${fullError}
 `
             );
           }
@@ -4258,6 +4486,77 @@ var init_store = __esm({
   }
 });
 
+// src/bin/fast-db-init.ts
+var fast_db_init_exports = {};
+__export(fast_db_init_exports, {
+  fastDbInit: () => fastDbInit
+});
+async function fastDbInit() {
+  const { isInitialized: isInitialized2, getClient: getClient2 } = await Promise.resolve().then(() => (init_database(), database_exports));
+  if (isInitialized2()) {
+    return getClient2();
+  }
+  try {
+    const { connectEmbedDaemon: connectEmbedDaemon2, sendDaemonRequest: sendDaemonRequest2, isClientConnected: isClientConnected2 } = await Promise.resolve().then(() => (init_exe_daemon_client(), exe_daemon_client_exports));
+    const { deserializeResultSet: deserializeResultSet2 } = await Promise.resolve().then(() => (init_daemon_protocol(), daemon_protocol_exports));
+    await connectEmbedDaemon2();
+    if (isClientConnected2()) {
+      const daemonClient = {
+        async execute(stmt) {
+          const sql = typeof stmt === "string" ? stmt : stmt.sql;
+          const args = typeof stmt === "string" ? [] : Array.isArray(stmt.args) ? stmt.args : [];
+          const resp = await sendDaemonRequest2({ type: "db-execute", sql, args });
+          if (resp.error) throw new Error(String(resp.error));
+          if (resp.db) return deserializeResultSet2(resp.db);
+          throw new Error("Unexpected daemon response");
+        },
+        async batch(stmts, mode) {
+          const statements = stmts.map((s) => {
+            const sql = typeof s === "string" ? s : s.sql;
+            const args = typeof s === "string" ? [] : Array.isArray(s.args) ? s.args : [];
+            return { sql, args };
+          });
+          const resp = await sendDaemonRequest2({ type: "db-batch", statements, mode: mode ?? "deferred" });
+          if (resp.error) throw new Error(String(resp.error));
+          const batchResults = resp["db-batch"];
+          if (batchResults) return batchResults.map(deserializeResultSet2);
+          throw new Error("Unexpected daemon batch response");
+        },
+        async transaction(_mode) {
+          throw new Error("Transactions not supported via daemon socket");
+        },
+        async executeMultiple(_sql) {
+          throw new Error("executeMultiple not supported via daemon socket");
+        },
+        async migrate(_stmts) {
+          throw new Error("migrate not supported via daemon socket");
+        },
+        sync() {
+          return Promise.resolve(void 0);
+        },
+        close() {
+        },
+        get closed() {
+          return false;
+        },
+        get protocol() {
+          return "file";
+        }
+      };
+      return daemonClient;
+    }
+  } catch {
+  }
+  const { initStore: initStore2 } = await Promise.resolve().then(() => (init_store(), store_exports));
+  await initStore2({ lightweight: true });
+  return getClient2();
+}
+var init_fast_db_init = __esm({
+  "src/bin/fast-db-init.ts"() {
+    "use strict";
+  }
+});
+
 // src/lib/active-agent.ts
 init_config();
 init_session_key();
@@ -4379,10 +4678,8 @@ process.stdin.on("end", async () => {
     if (canCoordinate(agent.agentId, agent.agentRole)) {
       process.exit(0);
     }
-    const { initStore: initStore2 } = await Promise.resolve().then(() => (init_store(), store_exports));
-    await initStore2();
-    const { getClient: getClient2 } = await Promise.resolve().then(() => (init_database(), database_exports));
-    const client = getClient2();
+    const { fastDbInit: fastDbInit2 } = await Promise.resolve().then(() => (init_fast_db_init(), fast_db_init_exports));
+    const client = await fastDbInit2();
     const saScope = sessionScopeFilter();
     const pendingResult = await client.execute({
       sql: `SELECT title, status FROM tasks WHERE assigned_to = ? AND status IN ('open', 'in_progress')${saScope.sql} ORDER BY status DESC, priority ASC`,

package/dist/hooks/summary-worker.js

@@ -3050,8 +3050,8 @@ function getShardClient(projectName) {
     throw new Error("Shard manager not initialized. Call initShardManager() first.");
   }
   const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
-  if (!safeName) {
-    throw new Error(`Invalid project name for shard: "${projectName}"`);
+  if (!safeName || safeName === "unknown") {
+    throw new Error(`Invalid project name for shard: "${projectName}" (resolved to "${safeName}")`);
   }
   const cached = _shards.get(safeName);
   if (cached) {

package/dist/index.js

@@ -6892,8 +6892,8 @@ function getShardClient(projectName) {
     throw new Error("Shard manager not initialized. Call initShardManager() first.");
   }
   const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
-  if (!safeName) {
-    throw new Error(`Invalid project name for shard: "${projectName}"`);
+  if (!safeName || safeName === "unknown") {
+    throw new Error(`Invalid project name for shard: "${projectName}" (resolved to "${safeName}")`);
   }
   const cached = _shards.get(safeName);
   if (cached) {
@@ -7762,19 +7762,32 @@ async function flushBatch() {
       const { isShardingEnabled: isShardingEnabled2, getReadyShardClient: getReadyShardClient2 } = await Promise.resolve().then(() => (init_shard_manager(), shard_manager_exports));
       if (isShardingEnabled2()) {
         const byProject = /* @__PURE__ */ new Map();
+        let skippedUnknown = 0;
         for (const row of batch) {
-          const proj = row.project_name || "unknown";
+          const proj = row.project_name?.trim();
+          if (!proj) {
+            skippedUnknown++;
+            continue;
+          }
           if (!byProject.has(proj)) byProject.set(proj, []);
           byProject.get(proj).push(row);
         }
+        if (skippedUnknown > 0) {
+          process.stderr.write(
+            `[store] Shard skip: ${skippedUnknown} record(s) with empty project_name (kept in main DB only)
+`
+          );
+        }
         for (const [project, rows] of byProject) {
           try {
             const shardClient = await getReadyShardClient2(project);
             const shardStmts = rows.map(buildStmt);
             await shardClient.batch(shardStmts, "write");
           } catch (err) {
+            const fullError = err instanceof Error ? `${err.name}: ${err.message}${err.stack ? `
+${err.stack.split("\n").slice(1, 3).join("\n")}` : ""}` : String(err);
             process.stderr.write(
-              `[store] Shard write failed for ${project}: ${err instanceof Error ? err.message : String(err)}
+              `[store] Shard write failed for ${project} (${rows.length} records): ${fullError}
 `
             );
           }

package/dist/lib/exe-daemon.js

@@ -723,8 +723,8 @@ function getShardClient(projectName) {
     throw new Error("Shard manager not initialized. Call initShardManager() first.");
   }
   const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
-  if (!safeName) {
-    throw new Error(`Invalid project name for shard: "${projectName}"`);
+  if (!safeName || safeName === "unknown") {
+    throw new Error(`Invalid project name for shard: "${projectName}" (resolved to "${safeName}")`);
   }
   const cached = _shards.get(safeName);
   if (cached) {
@@ -4464,19 +4464,32 @@ async function flushBatch() {
       const { isShardingEnabled: isShardingEnabled2, getReadyShardClient: getReadyShardClient2 } = await Promise.resolve().then(() => (init_shard_manager(), shard_manager_exports));
       if (isShardingEnabled2()) {
         const byProject = /* @__PURE__ */ new Map();
+        let skippedUnknown = 0;
         for (const row of batch) {
-          const proj = row.project_name || "unknown";
+          const proj = row.project_name?.trim();
+          if (!proj) {
+            skippedUnknown++;
+            continue;
+          }
           if (!byProject.has(proj)) byProject.set(proj, []);
           byProject.get(proj).push(row);
         }
+        if (skippedUnknown > 0) {
+          process.stderr.write(
+            `[store] Shard skip: ${skippedUnknown} record(s) with empty project_name (kept in main DB only)
+`
+          );
+        }
         for (const [project, rows] of byProject) {
           try {
             const shardClient = await getReadyShardClient2(project);
             const shardStmts = rows.map(buildStmt);
             await shardClient.batch(shardStmts, "write");
           } catch (err) {
+            const fullError = err instanceof Error ? `${err.name}: ${err.message}${err.stack ? `
+${err.stack.split("\n").slice(1, 3).join("\n")}` : ""}` : String(err);
             process.stderr.write(
-              `[store] Shard write failed for ${project}: ${err instanceof Error ? err.message : String(err)}
+              `[store] Shard write failed for ${project} (${rows.length} records): ${fullError}
 `
             );
           }
@@ -9330,8 +9343,8 @@ function createReviewNudgeRealDeps(getClient2) {
       return Number(result.rows[0]?.cnt ?? 0);
     },
     sendNudge: (sessionName) => {
-      const { getTransport: getTransport2 } = (init_transport(), __toCommonJS(transport_exports));
-      getTransport2().sendKeys(sessionName, "check reviews");
+      const { queueIntercom: qi } = (init_intercom_queue(), __toCommonJS(intercom_queue_exports));
+      qi(sessionName, "review nudge: pending reviews");
     },
     persistState: saveNudgeState
   };
@@ -12453,7 +12466,7 @@ function _resetNudgeState() {
   _lastNudge.clear();
 }
 async function runTaskEnforcementTick(deps) {
-  const { transport, agentConfig, employees, client, scopeFilter } = deps;
+  const { transport, employees, client, scopeFilter } = deps;
   const now = deps.now ?? Date.now();
   const sessions = transport.listSessions();
   for (const session of sessions) {
@@ -12466,6 +12479,17 @@ async function runTaskEnforcementTick(deps) {
     }
     const employee = employees.find((e) => e.name === agentName);
     if (!employee) continue;
+    let effectiveScope = scopeFilter;
+    const dashIndex = session.indexOf("-");
+    if (dashIndex > 0) {
+      const coordinatorSession = session.slice(dashIndex + 1);
+      if (coordinatorSession) {
+        effectiveScope = {
+          sql: " AND (session_scope IS NULL OR session_scope = ?)",
+          args: [coordinatorSession]
+        };
+      }
+    }
     const isManager = MANAGER_ROLES.includes(employee.role);
     try {
       let action = "skip";
@@ -12475,8 +12499,8 @@ async function runTaskEnforcementTick(deps) {
       let paneIdle;
       if (isManager) {
         const openResult = await client.execute({
-          sql: `SELECT COUNT(*) as cnt FROM tasks WHERE assigned_to = ? AND status = 'open'${scopeFilter.sql}`,
-          args: [agentName, ...scopeFilter.args]
+          sql: `SELECT COUNT(*) as cnt FROM tasks WHERE assigned_to = ? AND status = 'open'${effectiveScope.sql}`,
+          args: [agentName, ...effectiveScope.args]
         });
         openTasks = Number(openResult.rows[0]?.cnt ?? 0);
         if (openTasks > 0) {
@@ -12528,8 +12552,8 @@ async function runTaskEnforcementTick(deps) {
         );
       } else {
         const taskResult = await client.execute({
-          sql: `SELECT COUNT(*) as cnt FROM tasks WHERE assigned_to = ? AND status IN ('open', 'in_progress')${scopeFilter.sql}`,
-          args: [agentName, ...scopeFilter.args]
+          sql: `SELECT COUNT(*) as cnt FROM tasks WHERE assigned_to = ? AND status IN ('open', 'in_progress')${effectiveScope.sql}`,
+          args: [agentName, ...effectiveScope.args]
         });
         const taskCount = Number(taskResult.rows[0]?.cnt ?? 0);
         openTasks = taskCount;
@@ -12557,9 +12581,7 @@ async function runTaskEnforcementTick(deps) {
         );
       }
       if (action === "skip" || action === "idle" || action === "grace_period" || action === "active") continue;
-      const config = agentConfig[agentName];
-      const runtime = config?.runtime ?? "claude";
-      sendNudge(transport, session, runtime, action);
+      queueIntercom(session, `enforcement: ${reason}`);
       _lastNudge.set(session, now);
     } catch {
     }
@@ -12569,6 +12591,7 @@ var TASK_ENFORCEMENT_INTERVAL_MS, TASK_ENFORCEMENT_DEBOUNCE_MS, MANAGER_GRACE_PE
 var init_task_enforcement = __esm({
   "src/lib/task-enforcement.ts"() {
     "use strict";
+    init_intercom_queue();
     TASK_ENFORCEMENT_INTERVAL_MS = 6e4;
     TASK_ENFORCEMENT_DEBOUNCE_MS = 18e4;
     MANAGER_GRACE_PERIOD_MS = 6e5;

package/dist/lib/hybrid-search.js

@@ -2911,8 +2911,8 @@ function getShardClient(projectName) {
     throw new Error("Shard manager not initialized. Call initShardManager() first.");
   }
   const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
-  if (!safeName) {
-    throw new Error(`Invalid project name for shard: "${projectName}"`);
+  if (!safeName || safeName === "unknown") {
+    throw new Error(`Invalid project name for shard: "${projectName}" (resolved to "${safeName}")`);
   }
   const cached = _shards.get(safeName);
   if (cached) {
@@ -3781,19 +3781,32 @@ async function flushBatch() {
       const { isShardingEnabled: isShardingEnabled2, getReadyShardClient: getReadyShardClient2 } = await Promise.resolve().then(() => (init_shard_manager(), shard_manager_exports));
       if (isShardingEnabled2()) {
         const byProject = /* @__PURE__ */ new Map();
+        let skippedUnknown = 0;
         for (const row of batch) {
-          const proj = row.project_name || "unknown";
+          const proj = row.project_name?.trim();
+          if (!proj) {
+            skippedUnknown++;
+            continue;
+          }
           if (!byProject.has(proj)) byProject.set(proj, []);
           byProject.get(proj).push(row);
         }
+        if (skippedUnknown > 0) {
+          process.stderr.write(
+            `[store] Shard skip: ${skippedUnknown} record(s) with empty project_name (kept in main DB only)
+`
+          );
+        }
         for (const [project, rows] of byProject) {
           try {
             const shardClient = await getReadyShardClient2(project);
             const shardStmts = rows.map(buildStmt);
             await shardClient.batch(shardStmts, "write");
           } catch (err) {
+            const fullError = err instanceof Error ? `${err.name}: ${err.message}${err.stack ? `
+${err.stack.split("\n").slice(1, 3).join("\n")}` : ""}` : String(err);
             process.stderr.write(
-              `[store] Shard write failed for ${project}: ${err instanceof Error ? err.message : String(err)}
+              `[store] Shard write failed for ${project} (${rows.length} records): ${fullError}
 `
             );
           }
@@ -5209,10 +5222,12 @@ async function hybridSearch(queryText, agentId, options) {
     );
   }
   let rerankerAvailable = false;
-  try {
-    const { isRerankerAvailable: isRerankerAvailable2 } = await Promise.resolve().then(() => (init_reranker(), reranker_exports));
-    rerankerAvailable = isRerankerAvailable2();
-  } catch {
+  if (process.env.EXE_IS_DAEMON === "1") {
+    try {
+      const { isRerankerAvailable: isRerankerAvailable2 } = await Promise.resolve().then(() => (init_reranker(), reranker_exports));
+      rerankerAvailable = isRerankerAvailable2();
+    } catch {
+    }
   }
   const broadFetchTopK = config.scalingRoadmap?.rerankerAutoTrigger?.fetchTopK ?? 150;
   const fetchLimit = effectiveIsBroad ? Math.max(limit * 5, broadFetchTopK) : rerankerAvailable ? Math.max(limit * 4, 60) : Math.max(limit * 3, 30);

package/dist/lib/schedules.js

@@ -2595,8 +2595,8 @@ function getShardClient(projectName) {
     throw new Error("Shard manager not initialized. Call initShardManager() first.");
   }
   const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
-  if (!safeName) {
-    throw new Error(`Invalid project name for shard: "${projectName}"`);
+  if (!safeName || safeName === "unknown") {
+    throw new Error(`Invalid project name for shard: "${projectName}" (resolved to "${safeName}")`);
   }
   const cached = _shards.get(safeName);
   if (cached) {