@askexenow/exe-os 0.9.294 → 0.9.296

package/dist/prospective-memory-BTIVUJSB.js

@@ -0,0 +1,232 @@
+import {
+  getClient
+} from "./chunk-WUKHLCBE.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-2E43UXRH.js";
+import "./chunk-PNQDP3OA.js";
+import "./chunk-7HLWBYH7.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-R36FAN53.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+
+// src/lib/prospective-memory.ts
+import crypto from "crypto";
+var PROSPECTIVE_RECURRENCES = [
+  "daily",
+  "weekly",
+  "monthly",
+  "once"
+];
+var PROSPECTIVE_STATUSES = [
+  "pending",
+  "completed",
+  "deferred"
+];
+function normalizeRecurrence(value) {
+  return PROSPECTIVE_RECURRENCES.includes(value) ? value : "once";
+}
+function clampPriority(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) return 5;
+  return Math.min(10, Math.max(1, Math.round(n)));
+}
+function rowToProspective(row) {
+  return {
+    id: String(row.id),
+    agentId: String(row.agent_id),
+    content: String(row.content ?? ""),
+    dueDate: row.due_date != null ? String(row.due_date) : null,
+    recurrence: normalizeRecurrence(row.recurrence),
+    priority: clampPriority(row.priority),
+    status: PROSPECTIVE_STATUSES.includes(String(row.status)) ? String(row.status) : "pending",
+    lastSurfaced: row.last_surfaced != null ? String(row.last_surfaced) : null,
+    projectName: row.project_name != null ? String(row.project_name) : null,
+    sessionScope: row.session_scope != null ? String(row.session_scope) : null,
+    createdAt: String(row.created_at),
+    updatedAt: String(row.updated_at)
+  };
+}
+function nextDueDate(current, recurrence) {
+  if (recurrence === "once") return null;
+  const base = current ? new Date(current) : /* @__PURE__ */ new Date();
+  if (Number.isNaN(base.getTime())) return null;
+  const next = new Date(base.getTime());
+  switch (recurrence) {
+    case "daily":
+      next.setUTCDate(next.getUTCDate() + 1);
+      break;
+    case "weekly":
+      next.setUTCDate(next.getUTCDate() + 7);
+      break;
+    case "monthly":
+      next.setUTCMonth(next.getUTCMonth() + 1);
+      break;
+  }
+  return next.toISOString();
+}
+async function createProspectiveMemory(input) {
+  const id = crypto.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const record = {
+    id,
+    agentId: input.agentId.toLowerCase(),
+    content: input.content,
+    dueDate: input.dueDate ?? null,
+    recurrence: normalizeRecurrence(input.recurrence ?? "once"),
+    priority: clampPriority(input.priority ?? 5),
+    status: "pending",
+    lastSurfaced: null,
+    projectName: input.projectName ?? null,
+    sessionScope: input.sessionScope ?? null,
+    createdAt: now,
+    updatedAt: now
+  };
+  const client = getClient();
+  await client.execute({
+    sql: `INSERT INTO prospective_memories
+            (id, agent_id, content, due_date, recurrence, priority, status,
+             last_surfaced, project_name, session_scope, created_at, updated_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    args: [
+      record.id,
+      record.agentId,
+      record.content,
+      record.dueDate,
+      record.recurrence,
+      record.priority,
+      record.status,
+      record.lastSurfaced,
+      record.projectName,
+      record.sessionScope,
+      record.createdAt,
+      record.updatedAt
+    ]
+  });
+  return record;
+}
+async function getPendingProspective(agentId, options = {}) {
+  const client = getClient();
+  const cutoff = options.dueBefore ?? (/* @__PURE__ */ new Date()).toISOString();
+  const limit = options.limit ?? 10;
+  const args = [agentId.toLowerCase(), cutoff];
+  let projectClause = "";
+  if (options.projectName) {
+    projectClause = " AND (project_name IS NULL OR project_name = ?)";
+    args.push(options.projectName);
+  }
+  args.push(limit);
+  const result = await client.execute({
+    sql: `SELECT id, agent_id, content, due_date, recurrence, priority, status,
+                 last_surfaced, project_name, session_scope, created_at, updated_at
+          FROM prospective_memories
+          WHERE agent_id = ?
+            AND status = 'pending'
+            AND (due_date IS NULL OR due_date <= ?)${projectClause}
+          ORDER BY (due_date IS NULL) ASC, due_date ASC, priority ASC, created_at ASC
+          LIMIT ?`,
+    args
+  });
+  return result.rows.map((r) => rowToProspective(r));
+}
+async function markSurfaced(ids) {
+  if (ids.length === 0) return;
+  const client = getClient();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const placeholders = ids.map(() => "?").join(",");
+  await client.execute({
+    sql: `UPDATE prospective_memories SET last_surfaced = ?, updated_at = ?
+           WHERE id IN (${placeholders})`,
+    args: [now, now, ...ids]
+  });
+}
+async function getOverdueProspective(agentId, asOf) {
+  const client = getClient();
+  const cutoff = asOf ?? (/* @__PURE__ */ new Date()).toISOString();
+  const result = await client.execute({
+    sql: `SELECT id, agent_id, content, due_date, recurrence, priority, status,
+                 last_surfaced, project_name, session_scope, created_at, updated_at
+          FROM prospective_memories
+          WHERE agent_id = ?
+            AND status = 'pending'
+            AND due_date IS NOT NULL
+            AND due_date < ?
+          ORDER BY due_date ASC, priority ASC`,
+    args: [agentId.toLowerCase(), cutoff]
+  });
+  return result.rows.map((r) => rowToProspective(r));
+}
+async function completeProspective(id) {
+  const client = getClient();
+  const existing = await client.execute({
+    sql: `SELECT id, agent_id, content, due_date, recurrence, priority, status,
+                 last_surfaced, project_name, session_scope, created_at, updated_at
+          FROM prospective_memories WHERE id = ?`,
+    args: [id]
+  });
+  if (existing.rows.length === 0) return null;
+  const record = rowToProspective(existing.rows[0]);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (record.recurrence === "once") {
+    await client.execute({
+      sql: `UPDATE prospective_memories SET status = 'completed', updated_at = ? WHERE id = ?`,
+      args: [now, id]
+    });
+    return { ...record, status: "completed", updatedAt: now };
+  }
+  const advanced = nextDueDate(record.dueDate, record.recurrence);
+  await client.execute({
+    sql: `UPDATE prospective_memories SET due_date = ?, updated_at = ? WHERE id = ?`,
+    args: [advanced, now, id]
+  });
+  return { ...record, dueDate: advanced, updatedAt: now };
+}
+async function deferProspective(id, newDueDate) {
+  const client = getClient();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const existing = await client.execute({
+    sql: `SELECT id, agent_id, content, due_date, recurrence, priority, status,
+                 last_surfaced, project_name, session_scope, created_at, updated_at
+          FROM prospective_memories WHERE id = ?`,
+    args: [id]
+  });
+  if (existing.rows.length === 0) return null;
+  await client.execute({
+    sql: `UPDATE prospective_memories SET due_date = ?, status = 'deferred', updated_at = ? WHERE id = ?`,
+    args: [newDueDate, now, id]
+  });
+  const record = rowToProspective(existing.rows[0]);
+  return { ...record, dueDate: newDueDate, status: "deferred", updatedAt: now };
+}
+async function listProspective(agentId, options = {}) {
+  const client = getClient();
+  const args = [agentId.toLowerCase()];
+  let statusClause = "";
+  if (options.status) {
+    statusClause = " AND status = ?";
+    args.push(options.status);
+  }
+  args.push(options.limit ?? 50);
+  const result = await client.execute({
+    sql: `SELECT id, agent_id, content, due_date, recurrence, priority, status,
+                 last_surfaced, project_name, session_scope, created_at, updated_at
+          FROM prospective_memories
+          WHERE agent_id = ?${statusClause}
+          ORDER BY (due_date IS NULL) ASC, due_date ASC, priority ASC
+          LIMIT ?`,
+    args
+  });
+  return result.rows.map((r) => rowToProspective(r));
+}
+export {
+  PROSPECTIVE_RECURRENCES,
+  PROSPECTIVE_STATUSES,
+  completeProspective,
+  createProspectiveMemory,
+  deferProspective,
+  getOverdueProspective,
+  getPendingProspective,
+  listProspective,
+  markSurfaced,
+  nextDueDate
+};

package/dist/reranker-UA6WVESJ.js

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

package/dist/retrieval-health-7XNZJEBF.js

@@ -0,0 +1,12 @@
+import {
+  computeDegradations,
+  formatDegradations,
+  getRetrievalHealth
+} from "./chunk-6MZZREZY.js";
+import "./chunk-EJIF4FNT.js";
+import "./chunk-MLKGABMK.js";
+export {
+  computeDegradations,
+  formatDegradations,
+  getRetrievalHealth
+};

package/dist/review-polling-4ALGMXC3.js

@@ -0,0 +1,126 @@
+import {
+  isExeSession,
+  strictSessionScopeFilter
+} from "./chunk-K5ZO532Q.js";
+import "./chunk-JVHHXRFY.js";
+import "./chunk-4JERP7NT.js";
+import "./chunk-4FVVJ7ME.js";
+import "./chunk-Y3PMNUM5.js";
+import "./chunk-KOO3J5PV.js";
+import "./chunk-22TVSRQQ.js";
+import "./chunk-SSTLTIF3.js";
+import "./chunk-NLZHVIOP.js";
+import "./chunk-QRTJNSKU.js";
+import "./chunk-NGP6LSV2.js";
+import "./chunk-5CCXU2AW.js";
+import "./chunk-CVYC6DUW.js";
+import "./chunk-OPU3NYOO.js";
+import "./chunk-GJV3WDWM.js";
+import "./chunk-MP2AFCGL.js";
+import "./chunk-N7I2A667.js";
+import "./chunk-HYZV25LY.js";
+import {
+  DEFAULT_COORDINATOR_TEMPLATE_NAME,
+  getCoordinatorName
+} from "./chunk-WUKHLCBE.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-2E43UXRH.js";
+import "./chunk-PNQDP3OA.js";
+import "./chunk-7HLWBYH7.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-YTKVJJSU.js";
+import "./chunk-R36FAN53.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.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-3V4WOIRG.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

@@ -3,10 +3,10 @@ import {
   SessionManager,
   checkGitSafety,
   targetsMainBranch
-} from "../chunk-M2IOPGVR.js";
+} from "../chunk-OSNUP45F.js";
 import {
   MultiAgentOrchestrator
-} from "../chunk-RT5NXMH2.js";
+} from "../chunk-EIVNMA3Q.js";
 import {
   createQuietRenderer,
   createTerminalRenderer,
@@ -56,19 +56,19 @@ import {
   composeHooks,
   createDefaultHooks
 } from "../chunk-O377P7GM.js";
-import "../chunk-ALYNEMIH.js";
-import "../chunk-2ZXMXFGH.js";
-import "../chunk-E45SQG7C.js";
+import "../chunk-WVPLHGDG.js";
+import "../chunk-K5ZO532Q.js";
+import "../chunk-JVHHXRFY.js";
 import "../chunk-4JERP7NT.js";
 import "../chunk-4FVVJ7ME.js";
-import "../chunk-RAERYWCL.js";
-import "../chunk-HN3HGFBL.js";
-import "../chunk-YNORJIBH.js";
+import "../chunk-Y3PMNUM5.js";
+import "../chunk-KOO3J5PV.js";
+import "../chunk-22TVSRQQ.js";
 import "../chunk-SSTLTIF3.js";
-import "../chunk-DVFHAY2J.js";
+import "../chunk-NLZHVIOP.js";
 import "../chunk-QRTJNSKU.js";
 import "../chunk-NGP6LSV2.js";
-import "../chunk-GJS7CJRC.js";
+import "../chunk-5CCXU2AW.js";
 import "../chunk-CVYC6DUW.js";
 import "../chunk-OPU3NYOO.js";
 import "../chunk-GJV3WDWM.js";
@@ -76,11 +76,11 @@ import {
   StateBus,
   orgBus
 } from "../chunk-MP2AFCGL.js";
-import "../chunk-HH3MBGMJ.js";
+import "../chunk-N7I2A667.js";
 import "../chunk-HYZV25LY.js";
-import "../chunk-TM2GZWIT.js";
+import "../chunk-WUKHLCBE.js";
 import "../chunk-2I23RPSI.js";
-import "../chunk-D3X64YSB.js";
+import "../chunk-2E43UXRH.js";
 import "../chunk-PNQDP3OA.js";
 import "../chunk-7HLWBYH7.js";
 import "../chunk-FXU7JOXK.js";

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

@@ -0,0 +1,192 @@
+import {
+  resolveAnthropicAuth
+} from "./chunk-EJIF4FNT.js";
+import "./chunk-MLKGABMK.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;
+  }
+  const auth = resolveAnthropicAuth();
+  if (!auth) {
+    if (!_warnedNoAnthropicKey && !process.env.VITEST) {
+      process.stderr.write("[self-query-router] No Anthropic credentials (ANTHROPIC_API_KEY / ANTHROPIC_AUTH_TOKEN); 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(auth);
+    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-CK44XOU4.js

@@ -0,0 +1,38 @@
+import {
+  ensureSessionEventsTable,
+  listRecentSessionEvents,
+  recordSessionEvent
+} from "./chunk-YYAD2GXX.js";
+import "./chunk-K5ZO532Q.js";
+import "./chunk-JVHHXRFY.js";
+import "./chunk-4JERP7NT.js";
+import "./chunk-4FVVJ7ME.js";
+import "./chunk-Y3PMNUM5.js";
+import "./chunk-KOO3J5PV.js";
+import "./chunk-22TVSRQQ.js";
+import "./chunk-SSTLTIF3.js";
+import "./chunk-NLZHVIOP.js";
+import "./chunk-QRTJNSKU.js";
+import "./chunk-NGP6LSV2.js";
+import "./chunk-5CCXU2AW.js";
+import "./chunk-CVYC6DUW.js";
+import "./chunk-OPU3NYOO.js";
+import "./chunk-GJV3WDWM.js";
+import "./chunk-MP2AFCGL.js";
+import "./chunk-N7I2A667.js";
+import "./chunk-HYZV25LY.js";
+import "./chunk-WUKHLCBE.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-2E43UXRH.js";
+import "./chunk-PNQDP3OA.js";
+import "./chunk-7HLWBYH7.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-YTKVJJSU.js";
+import "./chunk-R36FAN53.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+export {
+  ensureSessionEventsTable,
+  listRecentSessionEvents,
+  recordSessionEvent
+};