@askexenow/exe-os 0.9.264 → 0.9.266

package/dist/chunk-RXMVPGH2.js

@@ -0,0 +1,346 @@
+import {
+  recordSessionKill
+} from "./chunk-XREWTPZM.js";
+import {
+  sessionScopeFilter,
+  verifyPaneAtCapacity,
+  writeNotification
+} from "./chunk-P2QTTEYP.js";
+import {
+  listSessions
+} from "./chunk-TSBMSHMM.js";
+import {
+  getTransport
+} from "./chunk-MVW62NIZ.js";
+import {
+  recordOrchestrationEventBestEffort
+} from "./chunk-XIT6ONPY.js";
+import {
+  getClient,
+  isCoordinatorName
+} from "./chunk-RHZ2CRJU.js";
+
+// src/lib/capacity-monitor.ts
+var CAPACITY_PATTERNS = [
+  /conversation is too long/i,
+  /maximum context length/i,
+  /context window.*(?:limit|exceed|full)/i,
+  /reached.*(?:token|context).*limit/i
+];
+var CONTENT_LINE_PREFIX = /^[\s>#\-*[]/;
+var CONTENT_LINE_MARKERS = [
+  "RESUME:",
+  "intercom",
+  "capacity-monitor",
+  "CAPACITY_PATTERNS",
+  "isAtCapacity",
+  "CONTENT_LINE_MARKERS",
+  "pollCapacityDead",
+  "confirmCapacityKill",
+  "session_kills",
+  "capacity-monitor.test"
+];
+var SOURCE_CODE_MARKERS = [
+  /["'`/].*(?:maximum context length|conversation is too long)/i,
+  /(?:maximum context length|conversation is too long).*["'`/]/i
+];
+var RELAUNCH_COOLDOWN_MS = 5 * 60 * 1e3;
+var _lastRelaunch = /* @__PURE__ */ new Map();
+var RESUME_TITLE_PREFIX = "RESUME:";
+var RESUME_TITLE_LIKE_PATTERN = `${RESUME_TITLE_PREFIX} % hit context capacity%`;
+var RESUME_ACTIVE_STATUSES = ["open", "in_progress"];
+function resumeTaskTitle(agentId) {
+  return `${RESUME_TITLE_PREFIX} ${agentId} hit context capacity \u2014 continue open tasks`;
+}
+function buildResumeContext(agentId, openTasks) {
+  const taskList = openTasks.map(
+    (r, i) => `${i + 1}. [${String(r.priority).toUpperCase()}] ${String(r.title)} (${String(r.task_file)})`
+  ).join("\n");
+  return [
+    "## Context",
+    "",
+    `${agentId} hit context capacity and was auto-relaunched by the capacity monitor.`,
+    "Call recall_my_memory first \u2014 search for 'CONTEXT CHECKPOINT'. Pick up where the previous session stopped.",
+    "",
+    `You have ${openTasks.length} open task(s). Work through them in priority order:`,
+    "",
+    taskList,
+    "",
+    "Read each task file and chain through them. Build and commit after each one."
+  ].join("\n");
+}
+var CONFIRMATION_WINDOW_MS = 3 * 60 * 1e3;
+var _pendingCapacityKill = /* @__PURE__ */ new Map();
+function filterPaneContent(paneOutput) {
+  return paneOutput.split("\n").filter((line) => {
+    if (CONTENT_LINE_PREFIX.test(line)) return false;
+    for (const marker of CONTENT_LINE_MARKERS) {
+      if (line.includes(marker)) return false;
+    }
+    for (const re of SOURCE_CODE_MARKERS) {
+      if (re.test(line)) return false;
+    }
+    return true;
+  }).join("\n");
+}
+var CC_CONTEXT_BAR_RE = /([\u2588\u2591\u2592\u2593]{10})\s+(\d+)%/;
+var CTX_FLOOR_PERCENT = 50;
+function extractContextPercent(paneOutput) {
+  const match = paneOutput.match(CC_CONTEXT_BAR_RE);
+  if (!match) return null;
+  const parsed = Number.parseInt(match[2], 10);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function isAtCapacity(paneOutput) {
+  const filtered = filterPaneContent(paneOutput);
+  return CAPACITY_PATTERNS.some((p) => p.test(filtered));
+}
+function confirmCapacityKill(agentId, now = Date.now()) {
+  const pendingSince = _pendingCapacityKill.get(agentId);
+  if (pendingSince === void 0) {
+    _pendingCapacityKill.set(agentId, now);
+    return false;
+  }
+  if (now - pendingSince > CONFIRMATION_WINDOW_MS) {
+    _pendingCapacityKill.set(agentId, now);
+    return false;
+  }
+  _pendingCapacityKill.delete(agentId);
+  return true;
+}
+function _resetPendingCapacityKills() {
+  _pendingCapacityKill.clear();
+}
+function _resetLastRelaunchCache() {
+  _lastRelaunch.clear();
+}
+async function lastResumeCreatedAtMs(agentId, sessionScope) {
+  const client = getClient();
+  const cmScope = sessionScopeFilter(sessionScope ?? null);
+  const result = await client.execute({
+    sql: `SELECT MAX(created_at) AS last_created_at
+          FROM tasks
+          WHERE assigned_to = ? AND title LIKE ?${cmScope.sql}`,
+    args: [agentId, `${RESUME_TITLE_PREFIX} %`, ...cmScope.args]
+  });
+  const raw = result.rows[0]?.last_created_at;
+  if (raw === null || raw === void 0) return null;
+  const parsed = Date.parse(String(raw));
+  return Number.isNaN(parsed) ? null : parsed;
+}
+async function isWithinRelaunchCooldown(agentId, now = Date.now(), sessionScope) {
+  const cacheKey = sessionScope ? `${agentId}::${sessionScope}` : agentId;
+  const cached = _lastRelaunch.get(cacheKey);
+  if (cached !== void 0) return now - cached < RELAUNCH_COOLDOWN_MS;
+  const persisted = await lastResumeCreatedAtMs(agentId, sessionScope);
+  if (persisted === null) return false;
+  if (now - persisted >= RELAUNCH_COOLDOWN_MS) return false;
+  _lastRelaunch.set(cacheKey, persisted);
+  return true;
+}
+async function createOrRefreshResumeTask(agentId, projectDir, openTasks, sessionScope) {
+  const client = getClient();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const context = buildResumeContext(agentId, openTasks);
+  const rdScope = sessionScopeFilter(sessionScope ?? null);
+  const existing = await client.execute({
+    sql: `SELECT id FROM tasks
+          WHERE assigned_to = ?
+            AND title LIKE ?
+            AND status IN (${RESUME_ACTIVE_STATUSES.map(() => "?").join(", ")})${rdScope.sql}
+          ORDER BY created_at DESC
+          LIMIT 1`,
+    args: [agentId, RESUME_TITLE_LIKE_PATTERN, ...RESUME_ACTIVE_STATUSES, ...rdScope.args]
+  });
+  if (existing.rows.length > 0) {
+    const taskId = String(existing.rows[0].id);
+    await client.execute({
+      sql: `UPDATE tasks SET context = ?, updated_at = ? WHERE id = ?`,
+      args: [context, now, taskId]
+    });
+    recordOrchestrationEventBestEffort({
+      eventType: "session.resumed",
+      source: "capacity-monitor.createOrRefreshResumeTask",
+      agentId,
+      taskId,
+      payload: { created: false, action: "refreshed" }
+    });
+    return { created: false, taskId };
+  }
+  const { createTask } = await import("./lib/tasks.js");
+  const task = await createTask({
+    title: resumeTaskTitle(agentId),
+    assignedTo: agentId,
+    assignedBy: "system",
+    projectName: projectDir.split("/").pop() ?? "unknown",
+    priority: "p0",
+    context,
+    baseDir: projectDir
+  });
+  recordOrchestrationEventBestEffort({
+    eventType: "session.resumed",
+    source: "capacity-monitor.createOrRefreshResumeTask",
+    agentId,
+    taskId: task.id,
+    payload: { created: true, action: "created", openTaskCount: openTasks.length }
+  });
+  return { created: true, taskId: task.id };
+}
+async function pollCapacityDead() {
+  const transport = getTransport();
+  const relaunched = [];
+  const registered = listSessions();
+  if (registered.length === 0) return [];
+  let liveSessions;
+  try {
+    liveSessions = transport.listSessions();
+  } catch {
+    return [];
+  }
+  for (const entry of registered) {
+    const { windowName, agentId, projectDir } = entry;
+    if (!liveSessions.includes(windowName)) continue;
+    const cmDashIdx = windowName.indexOf("-");
+    const cmDerivedScope = cmDashIdx >= 0 ? windowName.slice(cmDashIdx + 1) : null;
+    if (await isWithinRelaunchCooldown(agentId, Date.now(), cmDerivedScope)) continue;
+    let pane;
+    try {
+      pane = transport.capturePane(windowName, 15);
+    } catch {
+      continue;
+    }
+    if (!isAtCapacity(pane)) continue;
+    const ctxPct = extractContextPercent(pane);
+    if (ctxPct !== null && ctxPct < CTX_FLOOR_PERCENT) {
+      process.stderr.write(
+        `[capacity-monitor] ctx-floor: ${agentId} at ${ctxPct}% in ${windowName} \u2014 below ${CTX_FLOOR_PERCENT}%. Skipping capacity kill (likely self-referential content or false positive).
+`
+      );
+      continue;
+    }
+    if (!confirmCapacityKill(agentId)) {
+      process.stderr.write(
+        `[capacity-monitor] ${agentId} matched capacity pattern once in ${windowName}. Awaiting confirmation on next tick.
+`
+      );
+      continue;
+    }
+    const verify = await verifyPaneAtCapacity(windowName);
+    if (!verify.atCapacity) {
+      process.stderr.write(
+        `[capacity-monitor] verifyPaneAtCapacity rejected kill for ${agentId} in ${windowName} (reason: ${verify.reason}). Skipping.
+`
+      );
+      void recordSessionKill({
+        sessionName: windowName,
+        agentId,
+        reason: "capacity_false_positive_blocked"
+      });
+      continue;
+    }
+    process.stderr.write(
+      `[capacity-monitor] Detected ${agentId} at capacity in session ${windowName} (confirmed). Auto-relaunching.
+`
+    );
+    if (isCoordinatorName(agentId)) {
+      try {
+        const { loadConfigSync } = await import("./lib/config.js");
+        const cfg = loadConfigSync();
+        if (cfg.sessionLifecycle.autoRelaunchCoordinator !== false) {
+          const fs = await import("fs");
+          const path = await import("path");
+          const os = await import("os");
+          const markerDir = path.join(os.homedir(), ".exe-os", "session-cache");
+          fs.mkdirSync(markerDir, { recursive: true });
+          const markerPath = path.join(markerDir, `relaunch-${windowName}.json`);
+          fs.writeFileSync(markerPath, JSON.stringify({
+            reason: "context_full",
+            agentId,
+            projectDir,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          }));
+          process.stderr.write(
+            `[capacity-monitor] Coordinator relaunch marker written: ${markerPath}
+`
+          );
+        }
+        transport.kill(windowName);
+        void recordSessionKill({ sessionName: windowName, agentId, reason: "capacity" });
+        const coordCacheKey = cmDerivedScope ? `${agentId}::${cmDerivedScope}` : agentId;
+        _lastRelaunch.set(coordCacheKey, Date.now());
+        relaunched.push(agentId);
+      } catch (err) {
+        process.stderr.write(
+          `[capacity-monitor] Coordinator relaunch marker write failed: ${err instanceof Error ? err.message : String(err)}
+`
+        );
+      }
+      continue;
+    }
+    try {
+      transport.kill(windowName);
+      void recordSessionKill({
+        sessionName: windowName,
+        agentId,
+        reason: "capacity"
+      });
+      const client = getClient();
+      const dashIdx = windowName.indexOf("-");
+      const derivedScope = dashIdx >= 0 ? windowName.slice(dashIdx + 1) : null;
+      const rlScope = sessionScopeFilter(derivedScope);
+      const openTasks = await client.execute({
+        sql: `SELECT id, title, priority, task_file, status
+              FROM tasks
+              WHERE assigned_to = ? AND status IN ('open', 'in_progress')${rlScope.sql}
+              ORDER BY
+                CASE priority WHEN 'p0' THEN 0 WHEN 'p1' THEN 1 WHEN 'p2' THEN 2 ELSE 3 END,
+                created_at ASC
+              LIMIT 10`,
+        args: [agentId, ...rlScope.args]
+      });
+      if (openTasks.rows.length === 0) {
+        process.stderr.write(
+          `[capacity-monitor] ${agentId} has no open tasks \u2014 skipping relaunch.
+`
+        );
+        continue;
+      }
+      const { created } = await createOrRefreshResumeTask(
+        agentId,
+        projectDir,
+        openTasks.rows,
+        derivedScope
+      );
+      if (created) {
+        await writeNotification({
+          agentId: "system",
+          agentRole: "daemon",
+          event: "capacity_relaunch",
+          project: projectDir.split("/").pop() ?? "unknown",
+          summary: `${agentId} hit context capacity. Auto-relaunched with ${openTasks.rows.length} open task(s).`
+        });
+      }
+      const cacheKey = derivedScope ? `${agentId}::${derivedScope}` : agentId;
+      _lastRelaunch.set(cacheKey, Date.now());
+      if (created) relaunched.push(agentId);
+    } catch (err) {
+      process.stderr.write(
+        `[capacity-monitor] Failed to relaunch ${agentId}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+  }
+  return relaunched;
+}
+
+export {
+  CTX_FLOOR_PERCENT,
+  extractContextPercent,
+  isAtCapacity,
+  confirmCapacityKill,
+  _resetPendingCapacityKills,
+  _resetLastRelaunchCache,
+  isWithinRelaunchCooldown,
+  createOrRefreshResumeTask,
+  pollCapacityDead
+};

package/dist/chunk-S2ARWNS6.js

@@ -0,0 +1,135 @@
+import {
+  isCoordinatorRole
+} from "./chunk-RHZ2CRJU.js";
+
+// src/lib/task-router.ts
+import { randomUUID } from "crypto";
+var DEFAULT_BLOOM_CONFIG = {
+  complexityToTier: {
+    routine: "junior",
+    standard: "standard",
+    complex: "senior",
+    critical: "specialist"
+  },
+  tierRules: {
+    junior: {
+      eligible: [],
+      // resolved dynamically from roster (Principal Engineer role)
+      reviewRequired: false,
+      manualOnly: false
+    },
+    standard: {
+      eligible: [],
+      // resolved dynamically from roster (Principal Engineer role)
+      reviewRequired: false,
+      manualOnly: false
+    },
+    senior: {
+      eligible: [],
+      // any specialist, but review required
+      reviewRequired: true,
+      manualOnly: false
+    },
+    specialist: {
+      eligible: [],
+      reviewRequired: true,
+      manualOnly: true
+    }
+  }
+};
+function resolveBloomRouting(complexity, config = DEFAULT_BLOOM_CONFIG) {
+  const tier = config.complexityToTier[complexity];
+  const rule = config.tierRules[tier];
+  return {
+    tier,
+    reviewRequired: rule.reviewRequired,
+    manualOnly: rule.manualOnly,
+    eligible: rule.eligible
+  };
+}
+async function scoreEmployee(taskVector, agentId, searchFn) {
+  const results = await searchFn(taskVector, agentId, { limit: 5 });
+  if (results.length === 0) {
+    return { agentId, score: 0 };
+  }
+  const distances = results.map((r) => r["_distance"]).filter((d) => typeof d === "number");
+  if (distances.length > 0) {
+    const avgDistance = distances.reduce((sum, d) => sum + d, 0) / distances.length;
+    return { agentId, score: 1 / (1 + avgDistance) };
+  }
+  return { agentId, score: results.length / 5 };
+}
+async function routeTask(taskDescription, employees, embedFn, searchFn, options) {
+  let specialists = employees.filter((e) => !isCoordinatorRole(e.role));
+  if (specialists.length === 0) {
+    throw new Error(
+      "No specialist employees available. Create one with /exe-new-employee."
+    );
+  }
+  let bloomRouting;
+  if (options?.complexity) {
+    bloomRouting = resolveBloomRouting(options.complexity, options.bloomConfig);
+    if (bloomRouting.manualOnly) {
+      throw new Error(
+        `Task complexity "${options.complexity}" requires manual assignment (tier: ${bloomRouting.tier}).`
+      );
+    }
+    if (bloomRouting.eligible.length > 0) {
+      const eligible = new Set(bloomRouting.eligible);
+      const filtered = specialists.filter((e) => eligible.has(e.name));
+      if (filtered.length > 0) {
+        specialists = filtered;
+      }
+    }
+  }
+  const taskVector = await embedFn(taskDescription);
+  const scored = await Promise.all(
+    specialists.map(async (emp) => {
+      const { score } = await scoreEmployee(taskVector, emp.name, searchFn);
+      return { employee: emp, score };
+    })
+  );
+  scored.sort((a, b) => b.score - a.score);
+  return { ...scored[0], bloomRouting };
+}
+function createAssignmentMemory(taskDescription, assignedTo, assignedBy) {
+  return {
+    id: randomUUID(),
+    agent_id: assignedTo.name,
+    agent_role: assignedTo.role,
+    session_id: `assign-${Date.now()}`,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    tool_name: "assignment",
+    project_name: "",
+    has_error: false,
+    raw_text: `Task assigned by ${assignedBy}: ${taskDescription}`,
+    vector: null
+    // Will be backfilled
+  };
+}
+function formatAssignmentOutput(employee, task, score, mode, bloomRouting) {
+  const modeLabel = mode === "auto" ? "auto-routed" : "direct";
+  const percent = Math.round(score * 100);
+  const lines = [
+    `Assigned to ${employee.name} (${employee.role})`,
+    `Mode: ${modeLabel}`,
+    `Relevance: ${percent}%`,
+    `Task: ${task}`
+  ];
+  if (bloomRouting) {
+    lines.push(`Complexity tier: ${bloomRouting.tier}`);
+    if (bloomRouting.reviewRequired) {
+      lines.push(`Review: required`);
+    }
+  }
+  return lines.join("\n");
+}
+
+export {
+  DEFAULT_BLOOM_CONFIG,
+  resolveBloomRouting,
+  scoreEmployee,
+  routeTask,
+  createAssignmentMemory,
+  formatAssignmentOutput
+};

package/dist/chunk-SHPIATX7.js

@@ -0,0 +1,90 @@
+import {
+  loadEmployeesSync
+} from "./chunk-RHZ2CRJU.js";
+
+// src/adapters/mcp-http-config.ts
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { randomBytes } from "crypto";
+import { execFileSync } from "child_process";
+import path from "path";
+import os from "os";
+var DEFAULT_MCP_HTTP_PORT = "48739";
+function resolveDefaultAgentId() {
+  if (process.env.AGENT_ID && process.env.AGENT_ID !== "default") return process.env.AGENT_ID;
+  try {
+    const coo = loadEmployeesSync().find((e) => e.role === "COO");
+    if (coo) return coo.name;
+  } catch {
+  }
+  return "exe";
+}
+var DEFAULT_MCP_HTTP_AGENT_ID = resolveDefaultAgentId();
+var DEFAULT_MCP_HTTP_AGENT_ROLE = "COO";
+function mcpHttpPort() {
+  return process.env.EXE_MCP_PORT || DEFAULT_MCP_HTTP_PORT;
+}
+function mcpHttpUrl() {
+  return `http://127.0.0.1:${mcpHttpPort()}/mcp`;
+}
+function readOrCreateDaemonToken(homeDir = os.homedir()) {
+  const exeDir = path.join(homeDir, ".exe-os");
+  const tokenPath = path.join(exeDir, "exed.token");
+  if (existsSync(tokenPath)) {
+    try {
+      const token2 = readFileSync(tokenPath, "utf-8").trim();
+      if (/^[a-f0-9]{64}$/i.test(token2)) return token2;
+    } catch {
+    }
+  }
+  const token = randomBytes(32).toString("hex");
+  mkdirSync(exeDir, { recursive: true });
+  writeFileSync(tokenPath, `${token}
+`, "utf-8");
+  try {
+    chmodSync(tokenPath, 384);
+  } catch {
+  }
+  return token;
+}
+function buildMcpHttpHeaders(homeDir = os.homedir(), opts = {}) {
+  const agentId = opts.useShellPlaceholders ? "${AGENT_ID:-exe}" : opts.agentId ?? DEFAULT_MCP_HTTP_AGENT_ID;
+  const agentRole = opts.useShellPlaceholders ? "${AGENT_ROLE:-COO}" : opts.agentRole ?? DEFAULT_MCP_HTTP_AGENT_ROLE;
+  let sessionName = process.env.EXE_SESSION_NAME ?? "";
+  if (!sessionName && !opts.useShellPlaceholders) {
+    try {
+      const tmuxSession = execFileSync("tmux", ["display-message", "-p", "#{session_name}"], {
+        encoding: "utf8",
+        timeout: 2e3
+      }).trim();
+      if (tmuxSession) sessionName = tmuxSession;
+    } catch {
+    }
+  }
+  const headers = {
+    Authorization: `Bearer ${readOrCreateDaemonToken(homeDir)}`,
+    "X-Agent-Id": agentId,
+    "X-Agent-Role": agentRole
+  };
+  if (sessionName && !opts.useShellPlaceholders) headers["X-Exe-Session"] = sessionName;
+  return headers;
+}
+function buildClaudeHttpMcpEntry(homeDir = os.homedir()) {
+  const entry = {
+    type: "http",
+    url: mcpHttpUrl(),
+    headers: buildMcpHttpHeaders(homeDir, { useShellPlaceholders: true })
+  };
+  delete entry.headers["X-Exe-Session"];
+  return entry;
+}
+
+export {
+  DEFAULT_MCP_HTTP_PORT,
+  DEFAULT_MCP_HTTP_AGENT_ID,
+  DEFAULT_MCP_HTTP_AGENT_ROLE,
+  mcpHttpPort,
+  mcpHttpUrl,
+  readOrCreateDaemonToken,
+  buildMcpHttpHeaders,
+  buildClaudeHttpMcpEntry
+};

package/dist/chunk-SPOA7EOD.js

@@ -0,0 +1,81 @@
+// src/bin/fast-db-init.ts
+async function fastDbInit() {
+  const { isInitialized, getClient, setExternalClient } = await import("./lib/database.js");
+  if (isInitialized()) {
+    return getClient();
+  }
+  const forceDirect = process.env.EXE_DB_DIRECT === "1" || process.env.EXE_DB_READONLY === "1" || process.env.EXE_SKIP_DAEMON === "1";
+  if (!forceDirect) {
+    try {
+      const { connectEmbedDaemon, sendDaemonRequest, isClientConnected, disconnectClient } = await import("./lib/exe-daemon-client.js");
+      const { deserializeResultSet } = await import("./daemon-protocol-XW2OLNBS.js");
+      await Promise.race([
+        connectEmbedDaemon(),
+        new Promise((_, reject) => setTimeout(() => reject(new Error("Daemon socket timeout (2s)")), 2e3))
+      ]);
+      if (isClientConnected()) {
+        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 sendDaemonRequest({ type: "db-execute", sql, args });
+            if (resp.error) throw new Error(String(resp.error));
+            if (resp.db) return deserializeResultSet(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 sendDaemonRequest({ 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(deserializeResultSet);
+            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";
+          }
+        };
+        try {
+          await daemonClient.execute("SELECT 1");
+        } catch {
+          try {
+            disconnectClient();
+          } catch {
+          }
+          throw new Error("Daemon socket validation failed");
+        }
+        setExternalClient(daemonClient);
+        return daemonClient;
+      }
+    } catch {
+    }
+  }
+  const { initStore } = await import("./lib/store.js");
+  await initStore({ lightweight: true });
+  return getClient();
+}
+
+export {
+  fastDbInit
+};