@askexenow/exe-os 0.9.227 → 0.9.229

package/dist/push-notifications-3GNJ5SZS.js

@@ -0,0 +1,15 @@
+import {
+  _resetPushConfig,
+  loadPushConfig,
+  pushNotify,
+  pushNotifyAsync
+} from "./chunk-6MP5NOOR.js";
+import "./chunk-TNTFEWU5.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-R5U7XKVJ.js";
+export {
+  _resetPushConfig,
+  loadPushConfig,
+  pushNotify,
+  pushNotifyAsync
+};

package/dist/reranker-U6DEAT4S.js

@@ -0,0 +1,19 @@
+import {
+  disposeReranker,
+  getRerankerModelPath,
+  isRerankerAvailable,
+  rerank,
+  rerankWithContext,
+  rerankWithScores
+} from "./chunk-LHOIY5LQ.js";
+import "./chunk-TNTFEWU5.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-R5U7XKVJ.js";
+export {
+  disposeReranker,
+  getRerankerModelPath,
+  isRerankerAvailable,
+  rerank,
+  rerankWithContext,
+  rerankWithScores
+};

package/dist/review-gate-I66GDXNR.js

@@ -0,0 +1,120 @@
+import "./chunk-R5U7XKVJ.js";
+
+// src/lib/review-gate.ts
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+function checkCommitsExist(taskCreatedAt) {
+  try {
+    const since = new Date(taskCreatedAt).toISOString();
+    const output = execSync(
+      `git log --oneline --since="${since}" --no-merges 2>/dev/null`,
+      { encoding: "utf8", timeout: 5e3 }
+    ).trim();
+    const count = output ? output.split("\n").length : 0;
+    if (count === 0) {
+      return { pass: false, count: 0, error: "REVIEW GATE: No commits found since task was created. Did the engineer actually ship code?" };
+    }
+    return { pass: true, count };
+  } catch {
+    return { pass: true, count: -1 };
+  }
+}
+function checkLayerBoundaries(taskCreatedAt) {
+  const violations = [];
+  try {
+    const since = new Date(taskCreatedAt).toISOString();
+    const filesOutput = execSync(
+      `git log --since="${since}" --no-merges --name-only --pretty=format: 2>/dev/null`,
+      { encoding: "utf8", timeout: 5e3 }
+    ).trim();
+    if (!filesOutput) return { pass: true, violations: [] };
+    const changedFiles = [...new Set(filesOutput.split("\n").filter(Boolean))];
+    const libFiles = changedFiles.filter((f) => f.startsWith("src/lib/"));
+    for (const file of libFiles) {
+      try {
+        const grepResult = execSync(
+          `grep -nE "from ['"]\\.\\./(adapters|tui|runtime)/" "${file}" 2>/dev/null`,
+          { encoding: "utf8", timeout: 3e3 }
+        ).trim();
+        if (grepResult) {
+          for (const line of grepResult.split("\n").filter(Boolean)) {
+            violations.push(`REVIEW GATE: Layer boundary violation in ${file} \u2014 ${line.trim()}`);
+          }
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return { pass: violations.length === 0, violations };
+}
+function checkTestCoverage(taskCreatedAt) {
+  const warnings = [];
+  try {
+    const since = new Date(taskCreatedAt).toISOString();
+    const output = execSync(
+      `git log --since="${since}" --no-merges --diff-filter=A --name-only --pretty=format: 2>/dev/null`,
+      { encoding: "utf8", timeout: 5e3 }
+    ).trim();
+    if (!output) return { warnings: [] };
+    const newFiles = [...new Set(output.split("\n").filter(Boolean))];
+    const implFiles = newFiles.filter(
+      (f) => (f.startsWith("src/lib/") || f.startsWith("src/adapters/")) && f.endsWith(".ts") && !f.endsWith(".test.ts") && !f.endsWith(".d.ts")
+    );
+    for (const file of implFiles) {
+      const testPath = file.replace(/^src\//, "tests/").replace(/\.ts$/, ".test.ts");
+      const baseName = file.split("/").pop()?.replace(/\.ts$/, "") ?? "";
+      const testDir = testPath.substring(0, testPath.lastIndexOf("/"));
+      const hasDirectTest = existsSync(testPath);
+      let hasRelatedTest = false;
+      try {
+        const related = execSync(
+          `find "${testDir}" -name "*${baseName}*" -name "*.test.ts" 2>/dev/null`,
+          { encoding: "utf8", timeout: 3e3 }
+        ).trim();
+        hasRelatedTest = related.length > 0;
+      } catch {
+      }
+      if (!hasDirectTest && !hasRelatedTest) {
+        warnings.push(`REVIEW GATE WARNING: ${file} has no corresponding test file`);
+      }
+    }
+  } catch {
+  }
+  return { warnings };
+}
+var MIN_RESULT_LENGTH = 20;
+function checkResultLength(result) {
+  if (!result || result.trim().length < MIN_RESULT_LENGTH) {
+    return {
+      pass: false,
+      error: "REVIEW GATE: Task result is too short. Provide specific deliverables, files changed, and test status."
+    };
+  }
+  return { pass: true };
+}
+function runReviewGate(params) {
+  const errors = [];
+  const warnings = [];
+  const commits = checkCommitsExist(params.taskCreatedAt);
+  if (!commits.pass && commits.error) errors.push(commits.error);
+  const boundaries = checkLayerBoundaries(params.taskCreatedAt);
+  errors.push(...boundaries.violations);
+  const tests = checkTestCoverage(params.taskCreatedAt);
+  warnings.push(...tests.warnings);
+  const resultCheck = checkResultLength(params.result);
+  if (!resultCheck.pass && resultCheck.error) errors.push(resultCheck.error);
+  return {
+    pass: errors.length === 0,
+    errors,
+    warnings,
+    commitCount: commits.count
+  };
+}
+export {
+  checkCommitsExist,
+  checkLayerBoundaries,
+  checkResultLength,
+  checkTestCoverage,
+  runReviewGate
+};

package/dist/review-polling-W2S3XAAU.js

@@ -0,0 +1,123 @@
+import {
+  isExeSession,
+  strictSessionScopeFilter
+} from "./chunk-UBMGUX6T.js";
+import "./chunk-I2CDSGQW.js";
+import "./chunk-QI4IXJN7.js";
+import "./chunk-4JERP7NT.js";
+import "./chunk-G4LLKD4Z.js";
+import "./chunk-MVW62NIZ.js";
+import "./chunk-OYNKIAVW.js";
+import "./chunk-CX6GL3ZJ.js";
+import "./chunk-CTFKTUYN.js";
+import "./chunk-GVP5U4WL.js";
+import "./chunk-NGP6LSV2.js";
+import "./chunk-V3QAAU2U.js";
+import "./chunk-CVYC6DUW.js";
+import "./chunk-OPU3NYOO.js";
+import "./chunk-GJV3WDWM.js";
+import "./chunk-MP2AFCGL.js";
+import "./chunk-RMPAMMYW.js";
+import "./chunk-HYZV25LY.js";
+import {
+  DEFAULT_COORDINATOR_TEMPLATE_NAME,
+  getCoordinatorName
+} from "./chunk-UJOSFVWG.js";
+import "./chunk-QHIGMP2M.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-D4IVTUNN.js";
+import "./chunk-TNTFEWU5.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-R5U7XKVJ.js";
+
+// src/lib/review-polling.ts
+import { execSync } from "child_process";
+async function pollPendingReviews(deps, _state) {
+  let sessions;
+  try {
+    sessions = deps.listTmuxSessions().filter((s) => isExeSession(s));
+  } catch (err) {
+    process.stderr.write(
+      `[review-polling] tmux session listing failed: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return [];
+  }
+  if (sessions.length === 0) return [];
+  const sent = [];
+  for (const exeSession of sessions) {
+    try {
+      const orphans = await deps.findOrphanedDoneTasks(exeSession);
+      for (const orphan of orphans) {
+        try {
+          await deps.createReviewForOrphan(orphan);
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  return sent;
+}
+function createRealDeps(getClient) {
+  return {
+    listTmuxSessions: () => {
+      try {
+        return execSync("tmux list-sessions -F '#{session_name}' 2>/dev/null", {
+          encoding: "utf8",
+          timeout: 3e3
+        }).trim().split("\n").filter(Boolean);
+      } catch {
+        return [];
+      }
+    },
+    countPendingReviews: async (sessionScope) => {
+      const client = getClient();
+      const rpScope = strictSessionScopeFilter(sessionScope);
+      const result = await client.execute({
+        sql: `SELECT COUNT(*) as count FROM tasks
+              WHERE status = 'needs_review'${rpScope.sql}`,
+        args: [...rpScope.args]
+      });
+      return Number(result.rows[0]?.count ?? 0);
+    },
+    sendIntercom: (session) => {
+      import("./lib/tmux-routing.js").then(({ sendIntercom: centralSend }) => centralSend(session)).catch(() => {
+      });
+    },
+    findOrphanedDoneTasks: async (sessionScope) => {
+      const client = getClient();
+      const coordinatorName = getCoordinatorName();
+      const odScope = strictSessionScopeFilter(sessionScope, "t");
+      const result = await client.execute({
+        sql: `SELECT t.id, t.title, t.assigned_to, t.assigned_by,
+                     t.project_name, t.task_file, t.result, t.status
+              FROM tasks t
+              WHERE t.status = 'needs_review'
+                AND t.assigned_to != ?
+                AND t.assigned_to != ?${odScope.sql}
+                AND (t.result IS NULL OR t.result NOT LIKE '%## Review notes%')`,
+        args: [coordinatorName, DEFAULT_COORDINATOR_TEMPLATE_NAME, ...odScope.args]
+      });
+      return result.rows;
+    },
+    createReviewForOrphan: async (task) => {
+      const { createReviewForCompletedTask } = await import("./tasks-review-OHR2P4QE.js");
+      const cwd = process.cwd();
+      await createReviewForCompletedTask(
+        task,
+        task.result ?? void 0,
+        cwd,
+        (/* @__PURE__ */ new Date()).toISOString()
+      );
+      process.stderr.write(`[exed] Created missing review for: ${task.title} (${task.assigned_to})
+`);
+    }
+    // findUrgentUnread and findUnstartedTasks removed (2026-05-25 consolidation).
+    // All employee nudging handled by task-enforcement → sendIntercom.
+  };
+}
+export {
+  createRealDeps,
+  pollPendingReviews
+};

package/dist/runtime/index.js

@@ -0,0 +1,129 @@
+import {
+  IPCServer,
+  SessionManager,
+  checkGitSafety,
+  targetsMainBranch
+} from "../chunk-RTXGUKY3.js";
+import {
+  MultiAgentOrchestrator
+} from "../chunk-JSH5MAMM.js";
+import {
+  createQuietRenderer,
+  createTerminalRenderer,
+  renderAgentEvents
+} from "../chunk-YZFZDJWZ.js";
+import {
+  checkPathSafety,
+  checkReadPathSafety,
+  containsPathTraversal
+} from "../chunk-NGVOA6ZQ.js";
+import {
+  checkDangerousPatterns,
+  hasCriticalPattern
+} from "../chunk-AVE2B4DQ.js";
+import {
+  ContextManager,
+  agentLoop,
+  compactMessages,
+  createContextManager,
+  createDenialTrackingState,
+  estimateTokens,
+  getContextLimit,
+  needsCompaction,
+  recordDenial,
+  recordSuccess,
+  shouldFallbackToAsk
+} from "../chunk-AJWFPKQS.js";
+import {
+  ToolRegistry,
+  partitionTools,
+  zodToJsonSchema
+} from "../chunk-JQ6TLNIV.js";
+import {
+  EMPLOYEE_PERMISSIONS,
+  checkPermission,
+  createPermissionsFromPreset,
+  createRestrictedPermissions
+} from "../chunk-PRKVT4KN.js";
+import {
+  PERMISSION_PRESETS,
+  evaluatePermission,
+  getPresetByRole,
+  matchInputPattern,
+  matchToolPattern
+} from "../chunk-HF25XPZE.js";
+import {
+  composeHooks,
+  createDefaultHooks
+} from "../chunk-O377P7GM.js";
+import "../chunk-Z3TT2SVJ.js";
+import "../chunk-UBMGUX6T.js";
+import "../chunk-I2CDSGQW.js";
+import "../chunk-QI4IXJN7.js";
+import "../chunk-4JERP7NT.js";
+import "../chunk-G4LLKD4Z.js";
+import "../chunk-MVW62NIZ.js";
+import "../chunk-OYNKIAVW.js";
+import "../chunk-CX6GL3ZJ.js";
+import "../chunk-CTFKTUYN.js";
+import "../chunk-GVP5U4WL.js";
+import "../chunk-NGP6LSV2.js";
+import "../chunk-V3QAAU2U.js";
+import "../chunk-CVYC6DUW.js";
+import "../chunk-OPU3NYOO.js";
+import "../chunk-GJV3WDWM.js";
+import {
+  StateBus,
+  orgBus
+} from "../chunk-MP2AFCGL.js";
+import "../chunk-RMPAMMYW.js";
+import "../chunk-HYZV25LY.js";
+import "../chunk-UJOSFVWG.js";
+import "../chunk-QHIGMP2M.js";
+import "../chunk-FXU7JOXK.js";
+import "../chunk-D4IVTUNN.js";
+import "../chunk-TNTFEWU5.js";
+import "../chunk-LYH5HE24.js";
+import "../chunk-R5U7XKVJ.js";
+export {
+  ContextManager,
+  EMPLOYEE_PERMISSIONS,
+  IPCServer,
+  MultiAgentOrchestrator,
+  PERMISSION_PRESETS,
+  SessionManager,
+  StateBus,
+  ToolRegistry,
+  agentLoop,
+  checkDangerousPatterns,
+  checkGitSafety,
+  checkPathSafety,
+  checkPermission,
+  checkReadPathSafety,
+  compactMessages,
+  composeHooks,
+  containsPathTraversal,
+  createContextManager,
+  createDefaultHooks,
+  createDenialTrackingState,
+  createPermissionsFromPreset,
+  createQuietRenderer,
+  createRestrictedPermissions,
+  createTerminalRenderer,
+  estimateTokens,
+  evaluatePermission,
+  getContextLimit,
+  getPresetByRole,
+  hasCriticalPattern,
+  matchInputPattern,
+  matchToolPattern,
+  needsCompaction,
+  orgBus,
+  partitionTools,
+  recordDenial,
+  recordSuccess,
+  renderAgentEvents,
+  shouldFallbackToAsk,
+  targetsMainBranch,
+  zodToJsonSchema
+};

package/dist/self-query-router-QMK5ZSZR.js

@@ -0,0 +1,188 @@
+import "./chunk-R5U7XKVJ.js";
+
+// src/lib/self-query-router.ts
+var EXTRACT_TOOL = {
+  name: "extract_search_filters",
+  description: "Extract metadata filters from a memory search query to improve retrieval precision.",
+  input_schema: {
+    type: "object",
+    properties: {
+      semantic_query: {
+        type: "string",
+        description: "The core semantic meaning of the query, stripped of metadata references. This is used for embedding search."
+      },
+      project_filter: {
+        type: ["string", "null"],
+        description: "Project name if the query references a specific project (e.g., 'exe-os', 'exe-create'). Null if no project specified."
+      },
+      role_filter: {
+        type: ["string", "null"],
+        description: "Agent role if the query targets a specific role (e.g., 'CTO', 'CMO'). Null if no role specified."
+      },
+      time_filter: {
+        type: ["string", "null"],
+        description: "ISO 8601 timestamp lower bound if the query references a time period (e.g., 'last week', 'yesterday'). Null if no time reference."
+      },
+      is_broad_query: {
+        type: "boolean",
+        description: "True if the query is exploratory/broad (e.g., 'what has the CTO been working on', 'summarize recent activity'). False if targeted (e.g., 'how did we fix the auth bug')."
+      },
+      inferred_terms: {
+        type: "array",
+        items: { type: "string" },
+        description: "Entities or concepts NOT explicitly in the query but likely relevant for retrieval. Infer related terms from context clues. E.g., 'nephew of Ivory Lee Brown' \u2192 ['NFL', 'Oklahoma', 'football']. 'the auth bug we fixed' \u2192 ['JWT', 'token', 'login']. Return empty array if no useful inference. Max 5 terms."
+      }
+    },
+    required: ["semantic_query", "project_filter", "role_filter", "time_filter", "is_broad_query", "inferred_terms"]
+  }
+};
+var CACHE_MAX_SIZE = Number(process.env.EXE_QUERY_CACHE_SIZE) || 200;
+var CACHE_TTL_MS = Number(process.env.EXE_QUERY_CACHE_TTL_MS) || 5 * 60 * 1e3;
+var queryCache = /* @__PURE__ */ new Map();
+function normalizeCacheKey(query) {
+  return query.toLowerCase().trim().replace(/\s+/g, " ");
+}
+function evictCache() {
+  const now = Date.now();
+  for (const [key, entry] of queryCache) {
+    if (now - entry.timestamp > CACHE_TTL_MS) {
+      queryCache.delete(key);
+    }
+  }
+  while (queryCache.size > CACHE_MAX_SIZE) {
+    const firstKey = queryCache.keys().next().value;
+    if (firstKey !== void 0) queryCache.delete(firstKey);
+    else break;
+  }
+}
+function getQueryCacheStats() {
+  return {
+    size: queryCache.size,
+    maxSize: CACHE_MAX_SIZE,
+    ttlMs: CACHE_TTL_MS,
+    hitRate: _cacheTotal > 0 ? `${(_cacheHits / _cacheTotal * 100).toFixed(1)}%` : "n/a"
+  };
+}
+function _resetQueryCache() {
+  queryCache.clear();
+  _cacheHits = 0;
+  _cacheTotal = 0;
+}
+var _cacheHits = 0;
+var _cacheTotal = 0;
+var _warnedNoAnthropicKey = false;
+function cacheResult(cacheKey, result) {
+  evictCache();
+  queryCache.set(cacheKey, { result, timestamp: Date.now() });
+  return result;
+}
+function inferTimeFilter(queryLower) {
+  const now = Date.now();
+  const day = 24 * 60 * 60 * 1e3;
+  if (/\byesterday\b/.test(queryLower)) return new Date(now - day).toISOString();
+  if (/\blast\s+24\s*h(?:ours?)?\b/.test(queryLower)) return new Date(now - day).toISOString();
+  if (/\blast\s+7\s+days?\b|\blast\s+week\b|\bthis\s+week\b/.test(queryLower)) return new Date(now - 7 * day).toISOString();
+  if (/\blast\s+30\s+days?\b|\blast\s+month\b|\bthis\s+month\b/.test(queryLower)) return new Date(now - 30 * day).toISOString();
+  return null;
+}
+function inferProjectFilter(query) {
+  const explicit = query.match(/\b(?:project|repo)\s*[:=]\s*([a-z0-9._-]+)/i);
+  if (explicit?.[1]) return explicit[1];
+  const named = query.match(/\b(exe-[a-z0-9._-]+)\b/i);
+  if (named?.[1]) return named[1];
+  return null;
+}
+function inferTerms(queryLower) {
+  const terms = /* @__PURE__ */ new Set();
+  const mappings = [
+    [/\b(orchestration|delegate|delegation|dispatch|agent|tmux|session)\b/, ["dispatch", "tmux", "intercom", "session", "task lifecycle"]],
+    [/\b(memory|recall|search|retrieval|fts|vector|embedding|wiki)\b/, ["hybrid search", "FTS5", "graph", "vector", "wiki"]],
+    [/\b(crash|blocked|block|daemon|self[- ]heal|event loop|rss|oom)\b/, ["event loop", "daemon", "self-heal", "RSS", "watchdog"]],
+    [/\b(deploy|stack|docker|registry|image|ghcr|compose)\b/, ["stack-update", "docker", "registry", "GHCR", "compose"]],
+    [/\b(task|review|close|claim|lease|heartbeat)\b/, ["task status", "claim", "lease", "review", "heartbeat"]],
+    [/\b(security|secret|token|key|auth|permission)\b/, ["redaction", "token", "credential", "auth", "permission"]]
+  ];
+  for (const [pattern, values] of mappings) {
+    if (pattern.test(queryLower)) values.forEach((v) => terms.add(v));
+  }
+  return [...terms].slice(0, 5);
+}
+function fallbackRouteQuery(query) {
+  const lower = query.toLowerCase();
+  const broad = /\b(all|everything|overview|summari[sz]e|recap|history|what do we know|recent activity|audit|map out|deep dive)\b/.test(lower);
+  return {
+    semanticQuery: query,
+    projectFilter: inferProjectFilter(query),
+    roleFilter: /\bcto\b/.test(lower) ? "CTO" : /\bcmo\b/.test(lower) ? "CMO" : /\bcoo\b|chief of staff\b/.test(lower) ? "COO" : null,
+    timeFilter: inferTimeFilter(lower),
+    isBroadQuery: broad,
+    inferredTerms: inferTerms(lower)
+  };
+}
+async function routeQuery(query, model = "claude-haiku-4-5-20251001", _agentId) {
+  if (query.length < 10) {
+    return {
+      semanticQuery: query,
+      projectFilter: null,
+      roleFilter: null,
+      timeFilter: null,
+      isBroadQuery: false,
+      inferredTerms: []
+    };
+  }
+  const cacheKey = normalizeCacheKey(query);
+  _cacheTotal++;
+  const cached = queryCache.get(cacheKey);
+  if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
+    _cacheHits++;
+    queryCache.delete(cacheKey);
+    queryCache.set(cacheKey, cached);
+    return cached.result;
+  }
+  if (!process.env.ANTHROPIC_API_KEY) {
+    if (!_warnedNoAnthropicKey && !process.env.VITEST) {
+      process.stderr.write("[self-query-router] ANTHROPIC_API_KEY missing; using rule-based query routing fallback\n");
+      _warnedNoAnthropicKey = true;
+    }
+    return cacheResult(cacheKey, fallbackRouteQuery(query));
+  }
+  try {
+    const Anthropic = (await import("@anthropic-ai/sdk")).default;
+    const client = new Anthropic();
+    const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const response = await client.messages.create({
+      model,
+      max_tokens: 256,
+      system: `You are a search query router and context enricher. Extract metadata filters from the user's memory search query. Also infer related entities/concepts that aren't explicitly stated but would help retrieval (like Apple CLaRa's Query Reasoner). Today is ${now}. Convert relative time references (yesterday, last week) to ISO timestamps.`,
+      messages: [{ role: "user", content: query }],
+      tools: [EXTRACT_TOOL],
+      tool_choice: { type: "tool", name: "extract_search_filters" }
+    });
+    const toolBlock = response.content.find((b) => b.type === "tool_use");
+    if (toolBlock && toolBlock.type === "tool_use") {
+      const input = toolBlock.input;
+      const rawTerms = input.inferred_terms;
+      const inferredTerms = Array.isArray(rawTerms) ? rawTerms.filter((t) => typeof t === "string" && t.length > 0).slice(0, 5) : [];
+      const result = {
+        semanticQuery: input.semantic_query || query,
+        projectFilter: input.project_filter || null,
+        roleFilter: input.role_filter || null,
+        timeFilter: input.time_filter || null,
+        isBroadQuery: Boolean(input.is_broad_query),
+        inferredTerms
+      };
+      return cacheResult(cacheKey, result);
+    }
+  } catch (err) {
+    process.stderr.write(
+      `[self-query-router] LLM extraction failed, using rule-based fallback: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+  return cacheResult(cacheKey, fallbackRouteQuery(query));
+}
+export {
+  _resetQueryCache,
+  getQueryCacheStats,
+  routeQuery
+};

package/dist/session-events-MNWHGZY5.js

@@ -0,0 +1,35 @@
+import {
+  ensureSessionEventsTable,
+  listRecentSessionEvents,
+  recordSessionEvent
+} from "./chunk-YCTCKUZE.js";
+import "./chunk-UBMGUX6T.js";
+import "./chunk-I2CDSGQW.js";
+import "./chunk-QI4IXJN7.js";
+import "./chunk-4JERP7NT.js";
+import "./chunk-G4LLKD4Z.js";
+import "./chunk-MVW62NIZ.js";
+import "./chunk-OYNKIAVW.js";
+import "./chunk-CX6GL3ZJ.js";
+import "./chunk-CTFKTUYN.js";
+import "./chunk-GVP5U4WL.js";
+import "./chunk-NGP6LSV2.js";
+import "./chunk-V3QAAU2U.js";
+import "./chunk-CVYC6DUW.js";
+import "./chunk-OPU3NYOO.js";
+import "./chunk-GJV3WDWM.js";
+import "./chunk-MP2AFCGL.js";
+import "./chunk-RMPAMMYW.js";
+import "./chunk-HYZV25LY.js";
+import "./chunk-UJOSFVWG.js";
+import "./chunk-QHIGMP2M.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-D4IVTUNN.js";
+import "./chunk-TNTFEWU5.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-R5U7XKVJ.js";
+export {
+  ensureSessionEventsTable,
+  listRecentSessionEvents,
+  recordSessionEvent
+};

package/dist/session-kill-telemetry-JHSI7D3F.js

@@ -0,0 +1,28 @@
+import {
+  IDLE_KILL_MIN_LIVE_SESSIONS,
+  IDLE_KILL_STREAK_META_KEY,
+  IDLE_KILL_SUSPECT_DAY_THRESHOLD,
+  TOKENS_PER_IDLE_MINUTE,
+  computeIdleKillSuspectStreak,
+  countKillsSince,
+  parseStreakState,
+  recordSessionKill,
+  sumTokensSavedSince
+} from "./chunk-FIPU4BDF.js";
+import "./chunk-UJOSFVWG.js";
+import "./chunk-QHIGMP2M.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-TNTFEWU5.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-R5U7XKVJ.js";
+export {
+  IDLE_KILL_MIN_LIVE_SESSIONS,
+  IDLE_KILL_STREAK_META_KEY,
+  IDLE_KILL_SUSPECT_DAY_THRESHOLD,
+  TOKENS_PER_IDLE_MINUTE,
+  computeIdleKillSuspectStreak,
+  countKillsSince,
+  parseStreakState,
+  recordSessionKill,
+  sumTokensSavedSince
+};