@askexenow/exe-os 0.9.374 → 0.9.376

package/dist/{chunk-CRCB5S7I.js → chunk-NPXKGBVZ.js}

@@ -10,7 +10,40 @@ var DEFAULT_RELATIONSHIP_LIMIT = 500;
 function escapeLikePattern(value) {
   return value.replace(/[\\%_]/g, (m) => `\\${m}`);
 }
-async function getEntityDegree(client, entityId) {
+function projectScopeExists(entityIdColumn, includeSessionScope) {
+  const sessionClause = includeSessionScope ? " AND (m.session_scope = ? OR m.session_scope IS NULL)" : "";
+  return `EXISTS (
+    SELECT 1 FROM entity_memories em
+    JOIN memories m ON m.id = em.memory_id
+    WHERE em.entity_id = ${entityIdColumn} AND m.project_name = ?${sessionClause}
+  )`;
+}
+async function resolveSessionScopeArg(opts) {
+  if (opts?.allowCrossSession) return void 0;
+  if (opts?.sessionScope !== void 0) return opts.sessionScope;
+  const { resolveExeSession } = await import("./lib/tmux-routing.js");
+  return resolveExeSession();
+}
+function relationshipScopeExists(relationshipIdColumn, includeSessionScope) {
+  const sessionClause = includeSessionScope ? " AND (rm_m.session_scope = ? OR rm_m.session_scope IS NULL)" : "";
+  return `EXISTS (
+    SELECT 1 FROM relationship_memories rm
+    JOIN memories rm_m ON rm_m.id = rm.memory_id
+    WHERE rm.relationship_id = ${relationshipIdColumn} AND rm_m.project_name = ?${sessionClause}
+  )`;
+}
+async function getEntityDegree(client, entityId, scope) {
+  if (scope) {
+    const args = [entityId, entityId, scope.projectName];
+    if (scope.includeSession) args.push(scope.sessionScope ?? null);
+    const result2 = await client.execute({
+      sql: `SELECT COUNT(*) as cnt FROM relationships r
+            WHERE (r.source_entity_id = ? OR r.target_entity_id = ?)
+              AND ${relationshipScopeExists("r.id", scope.includeSession)}`,
+      args
+    });
+    return Number(result2.rows[0]?.cnt ?? 0);
+  }
   const result = await client.execute({
     sql: `SELECT COUNT(*) as cnt FROM relationships
           WHERE source_entity_id = ? OR target_entity_id = ?`,
@@ -18,7 +51,7 @@ async function getEntityDegree(client, entityId) {
   });
   return Number(result.rows[0]?.cnt ?? 0);
 }
-async function getEntityByName(client, name, type) {
+async function getEntityByName(client, name, type, projectName, scopeOpts) {
   let sql;
   let args;
   if (type) {
@@ -29,6 +62,13 @@ async function getEntityByName(client, name, type) {
     sql = `SELECT * FROM entities WHERE LOWER(name) = LOWER(?) LIMIT 1`;
     args = [name];
   }
+  if (projectName) {
+    const sessionScope = await resolveSessionScopeArg(scopeOpts);
+    const includeSession = sessionScope !== void 0;
+    sql = sql.replace(/ LIMIT 1$/, ` AND ${projectScopeExists("entities.id", includeSession)} LIMIT 1`);
+    args.push(projectName);
+    if (includeSession) args.push(sessionScope);
+  }
   const result = await client.execute({ sql, args });
   if (result.rows.length === 0) return null;
   const row = result.rows[0];
@@ -41,11 +81,19 @@ async function getEntityByName(client, name, type) {
     properties: JSON.parse(String(row.properties ?? "{}"))
   };
 }
-async function searchEntities(client, query, limit = 10) {
-  const result = await client.execute({
-    sql: `SELECT * FROM entities WHERE LOWER(name) LIKE ? ESCAPE '\\' ORDER BY last_seen DESC LIMIT ?`,
-    args: [`%${escapeLikePattern(query.toLowerCase())}%`, limit]
-  });
+async function searchEntities(client, query, limit = 10, projectName, scopeOpts) {
+  const args = [`%${escapeLikePattern(query.toLowerCase())}%`];
+  let sql = `SELECT * FROM entities WHERE LOWER(name) LIKE ? ESCAPE '\\'`;
+  if (projectName) {
+    const sessionScope = await resolveSessionScopeArg(scopeOpts);
+    const includeSession = sessionScope !== void 0;
+    sql += ` AND ${projectScopeExists("entities.id", includeSession)}`;
+    args.push(projectName);
+    if (includeSession) args.push(sessionScope);
+  }
+  sql += ` ORDER BY last_seen DESC LIMIT ?`;
+  args.push(limit);
+  const result = await client.execute({ sql, args });
   return result.rows.map((row) => ({
     id: String(row.id),
     name: String(row.name),
@@ -97,6 +145,13 @@ async function getRelationships(client, entityId, options) {
     sql += ` AND r.type = ?`;
     args.push(options.type);
   }
+  if (options?.projectName) {
+    const sessionScope = await resolveSessionScopeArg(options.scopeOpts);
+    const includeSession = sessionScope !== void 0;
+    sql += ` AND ${relationshipScopeExists("r.id", includeSession)}`;
+    args.push(options.projectName);
+    if (includeSession) args.push(sessionScope);
+  }
   sql += ` ORDER BY r.weight DESC, r.timestamp DESC LIMIT ?`;
   args.push(DEFAULT_RELATIONSHIP_LIMIT);
   const result = await client.execute({ sql, args });
@@ -160,9 +215,16 @@ async function traverseChain(client, startEntityId, relationshipType, maxDepth =
     relationship: String(row.rel_type)
   }));
 }
-async function getEntityNeighbors(client, entityId, maxHops = 2, asOf) {
+async function getEntityNeighbors(client, entityId, maxHops = 2, asOf, projectName, scopeOpts) {
   const safeMaxHops = Math.max(1, Math.min(maxHops, MAX_GRAPH_TRAVERSAL_DEPTH));
-  if (await getEntityDegree(client, entityId) > MAX_HUB_DEGREE_FOR_TRAVERSAL) {
+  let includeSession = false;
+  let sessionScope;
+  if (projectName) {
+    sessionScope = await resolveSessionScopeArg(scopeOpts);
+    includeSession = sessionScope !== void 0;
+  }
+  const degree = projectName ? await getEntityDegree(client, entityId, { projectName, sessionScope, includeSession }) : await getEntityDegree(client, entityId);
+  if (degree > MAX_HUB_DEGREE_FOR_TRAVERSAL) {
     return [];
   }
   let temporalFilter;
@@ -173,7 +235,19 @@ async function getEntityNeighbors(client, entityId, maxHops = 2, asOf) {
   } else {
     temporalFilter = `AND r.valid_until IS NULL`;
   }
-  args.push(safeMaxHops, MAX_GRAPH_TRAVERSAL_ROWS);
+  let scopeFilter = "";
+  if (projectName) {
+    scopeFilter = ` AND ${relationshipScopeExists("r.id", includeSession)}`;
+    args.push(projectName);
+    if (includeSession) args.push(sessionScope ?? null);
+  }
+  args.push(safeMaxHops);
+  const hubGuardClause = projectName ? `(SELECT COUNT(*) FROM relationships rd WHERE (rd.source_entity_id = n.entity_id OR rd.target_entity_id = n.entity_id) AND ${relationshipScopeExists("rd.id", includeSession)}) <= ${MAX_HUB_DEGREE_FOR_TRAVERSAL}` : `(SELECT COUNT(*) FROM relationships rd WHERE rd.source_entity_id = n.entity_id OR rd.target_entity_id = n.entity_id) <= ${MAX_HUB_DEGREE_FOR_TRAVERSAL}`;
+  const hubGuardArgs = [];
+  if (projectName) {
+    hubGuardArgs.push(projectName);
+    if (includeSession) hubGuardArgs.push(sessionScope ?? null);
+  }
   const result = await client.execute({
     sql: `WITH RECURSIVE neighborhood(entity_id, depth, rel_type, rel_confidence, path) AS (
             SELECT ?, 0, '', 1.0, '|' || ? || '|'
@@ -189,13 +263,13 @@ async function getEntityNeighbors(client, entityId, maxHops = 2, asOf) {
             FROM neighborhood n
             JOIN relationships r ON (r.source_entity_id = n.entity_id
                                  OR r.target_entity_id = n.entity_id)
-                                 ${temporalFilter}
+                                 ${temporalFilter}${scopeFilter}
             WHERE n.depth < ?
               AND instr(n.path, '|' || CASE
                 WHEN r.source_entity_id = n.entity_id THEN r.target_entity_id
                 ELSE r.source_entity_id
               END || '|') = 0
-              AND (SELECT COUNT(*) FROM relationships rd WHERE rd.source_entity_id = n.entity_id OR rd.target_entity_id = n.entity_id) <= ${MAX_HUB_DEGREE_FOR_TRAVERSAL}
+              AND ${hubGuardClause}
             LIMIT ?
           )
           SELECT * FROM (
@@ -210,7 +284,7 @@ async function getEntityNeighbors(client, entityId, maxHops = 2, asOf) {
           WHERE rn = 1
           ORDER BY depth ASC, last_seen DESC
           LIMIT 50`,
-    args
+    args: [...args, ...hubGuardArgs, MAX_GRAPH_TRAVERSAL_ROWS]
   });
   return result.rows.map((row) => ({
     entity: {
@@ -226,12 +300,41 @@ async function getEntityNeighbors(client, entityId, maxHops = 2, asOf) {
     relConfidence: Number(row.rel_confidence ?? 1)
   }));
 }
-async function getGraphStats(client) {
-  const entityCount = await client.execute("SELECT COUNT(*) as cnt FROM entities");
-  const relCount = await client.execute("SELECT COUNT(*) as cnt FROM relationships");
-  const typeResult = await client.execute(
-    "SELECT type, COUNT(*) as cnt FROM entities GROUP BY type ORDER BY cnt DESC"
-  );
+async function getGraphStats(client, projectName, scopeOpts) {
+  if (!projectName) {
+    const entityCount2 = await client.execute("SELECT COUNT(*) as cnt FROM entities");
+    const relCount2 = await client.execute("SELECT COUNT(*) as cnt FROM relationships");
+    const typeResult2 = await client.execute(
+      "SELECT type, COUNT(*) as cnt FROM entities GROUP BY type ORDER BY cnt DESC"
+    );
+    const types2 = {};
+    for (const row of typeResult2.rows) {
+      types2[String(row.type)] = Number(row.cnt);
+    }
+    return {
+      entities: Number(entityCount2.rows[0]?.cnt ?? 0),
+      relationships: Number(relCount2.rows[0]?.cnt ?? 0),
+      types: types2
+    };
+  }
+  const sessionScope = await resolveSessionScopeArg(scopeOpts);
+  const includeSession = sessionScope !== void 0;
+  const entityScope = projectScopeExists("entities.id", includeSession);
+  const entityArgs = includeSession ? [projectName, sessionScope] : [projectName];
+  const entityCount = await client.execute({
+    sql: `SELECT COUNT(*) as cnt FROM entities WHERE ${entityScope}`,
+    args: entityArgs
+  });
+  const relCount = await client.execute({
+    sql: `SELECT COUNT(*) as cnt FROM relationships r
+          WHERE ${relationshipScopeExists("r.id", includeSession)}`,
+    args: entityArgs
+  });
+  const typeResult = await client.execute({
+    sql: `SELECT type, COUNT(*) as cnt FROM entities WHERE ${entityScope}
+          GROUP BY type ORDER BY cnt DESC`,
+    args: entityArgs
+  });
   const types = {};
   for (const row of typeResult.rows) {
     types[String(row.type)] = Number(row.cnt);
@@ -355,20 +458,34 @@ async function getConversationPartners(client, contactEntityId, since) {
   }
   return partners;
 }
-async function getHotEntities(client, since, limit = 10) {
+async function getHotEntities(client, since, limit = 10, projectName, scopeOpts) {
   const safeSince = isNaN(since.getTime()) ? new Date(Date.now() - 7 * 24 * 60 * 60 * 1e3) : since;
   const sinceISO = safeSince.toISOString();
+  const sessionScope = projectName ? await resolveSessionScopeArg(scopeOpts) : void 0;
+  const includeSession = sessionScope !== void 0;
+  const relClause = projectName ? ` AND ${relationshipScopeExists("r.id", includeSession)}` : "";
+  const args = [sinceISO];
+  if (projectName) {
+    args.push(projectName);
+    if (includeSession) args.push(sessionScope);
+  }
+  args.push(sinceISO);
+  if (projectName) {
+    args.push(projectName);
+    if (includeSession) args.push(sessionScope);
+  }
+  args.push(limit);
   const result = await client.execute({
     sql: `SELECT entity_id, COUNT(*) as rel_count
           FROM (
-            SELECT source_entity_id as entity_id FROM relationships WHERE timestamp >= ?
+            SELECT source_entity_id as entity_id FROM relationships r WHERE timestamp >= ?${relClause}
             UNION ALL
-            SELECT target_entity_id as entity_id FROM relationships WHERE timestamp >= ?
+            SELECT target_entity_id as entity_id FROM relationships r WHERE timestamp >= ?${relClause}
           )
           GROUP BY entity_id
           ORDER BY rel_count DESC
           LIMIT ?`,
-    args: [sinceISO, sinceISO, limit]
+    args
   });
   const hotEntities = [];
   for (const row of result.rows) {

package/dist/{chunk-JSMDRKPJ.js → chunk-NRBGUIPE.js}

@@ -1,6 +1,6 @@
 import {
   isExeSession
-} from "./chunk-AKLQSC6W.js";
+} from "./chunk-KI7O64XV.js";
 import {
   loadConfigSync
 } from "./chunk-ZIG7VPJV.js";

package/dist/{chunk-4LWBC7CM.js → chunk-NY6SBR4O.js}

@@ -35,7 +35,7 @@ function resolveEndpoint() {
 }
 async function loadGoTrueAuthHeader() {
   try {
-    const { getAuthHeader } = await import("./gotrue-session-ODZ2ERJX.js");
+    const { getAuthHeader } = await import("./gotrue-session-U4H3UGHL.js");
     return await getAuthHeader();
   } catch {
     return null;

package/dist/{chunk-UCUOGVDX.js → chunk-O3K2C22L.js}

@@ -1,3 +1,7 @@
+import {
+  isManagementRole
+} from "./chunk-66CGXQUA.js";
+
 // src/lib/transcript-sidechain.ts
 import { readFileSync } from "fs";
 function isSidechainTranscript(transcriptPath) {
@@ -36,9 +40,17 @@ function resolveSidechainAgentIdentity(parent, transcriptPath, env = process.env
     agentRole: agentType
   };
 }
+function resolvePreToolUseAgentIdentity(parent, payload, env = process.env) {
+  const directType = payload.agent_type?.trim();
+  if (directType) {
+    const safeRole = isManagementRole(directType) ? "subagent" : directType;
+    return { agentId: `subagent:${directType}`, agentRole: safeRole };
+  }
+  return resolveSidechainAgentIdentity(parent, payload.transcript_path, env);
+}
 
 export {
   isSidechainTranscript,
   detectSubagentSidechain,
-  resolveSidechainAgentIdentity
+  resolvePreToolUseAgentIdentity
 };

package/dist/{chunk-R522MWAR.js → chunk-OATET4BV.js}

@@ -219,7 +219,7 @@ function clearSetupState() {
 }
 async function probeDaemonHealthAfterInstall() {
   try {
-    const { waitForDaemonReady } = await import("./daemon-ready-P2BR2XP5.js");
+    const { waitForDaemonReady } = await import("./daemon-ready-BN6EZLTQ.js");
     return await waitForDaemonReady(4, 500);
   } catch {
     return false;
@@ -939,7 +939,7 @@ async function runSetupWizard(opts = {}) {
         try {
           const { loadDeviceId } = await import("./lib/license.js");
           const deviceId = loadDeviceId();
-          const gotrueAuth = await import("./gotrue-session-ODZ2ERJX.js").then((m) => m.getAuthHeader()).catch(() => null);
+          const gotrueAuth = await import("./gotrue-session-U4H3UGHL.js").then((m) => m.getAuthHeader()).catch(() => null);
           const headers = {
             "Content-Type": "application/json",
             ...gotrueAuth ? { Authorization: gotrueAuth.authorization } : {}

package/dist/chunk-OOZU5H3T.js

@@ -0,0 +1,86 @@
+import {
+  sendMessage
+} from "./chunk-V5DDXXMP.js";
+import {
+  getActiveAgent
+} from "./chunk-5DF4Y6EC.js";
+import {
+  resolveExeSession
+} from "./chunk-KI7O64XV.js";
+import {
+  getDispatcherSession
+} from "./chunk-GPUOUUHA.js";
+import {
+  getAgentContext
+} from "./chunk-GJV3WDWM.js";
+import {
+  getCoordinatorName,
+  isCoordinatorName
+} from "./chunk-66CGXQUA.js";
+
+// src/mcp/tools/send-message.ts
+import { z } from "zod";
+function resolveMessageTarget(targetAgent) {
+  const explicitTarget = targetAgent?.trim();
+  if (explicitTarget) return { targetAgent: explicitTarget };
+  if (isCoordinatorName(getActiveAgent().agentId)) return null;
+  const dispatcherSession = resolveExeSession() ?? (getAgentContext() === void 0 ? getDispatcherSession() : null);
+  if (!dispatcherSession) return null;
+  return {
+    targetAgent: getCoordinatorName(),
+    sessionScope: dispatcherSession
+  };
+}
+function registerSendMessage(server) {
+  server.registerTool(
+    "send_message",
+    {
+      title: "Send Message",
+      description: "Send a structured message to another agent. Messages are queued and delivered via intercom. NOTE: messages are fire-and-forget. Use default create_task for checklist tracking; only explicit execution_mode='durable_tmux' performs legacy employee dispatch.",
+      inputSchema: {
+        target_agent: z.string().optional().describe("Recipient agent name. Omit to reply to the coordinator session that dispatched this agent."),
+        content: z.string().describe("Message content"),
+        target_project: z.string().optional().describe("Project context (optional)"),
+        priority: z.enum(["normal", "urgent"]).default("normal").describe("Message priority (default: normal)"),
+        target_device: z.string().optional().describe("Target device ID for cross-machine delivery (default: local)")
+      }
+    },
+    async ({ target_agent, content, target_project, priority, target_device }) => {
+      const { agentId } = getActiveAgent();
+      const target = resolveMessageTarget(target_agent);
+      if (!target) {
+        return {
+          content: [{
+            type: "text",
+            text: "target_agent is required when no dispatcher session is available"
+          }],
+          isError: true
+        };
+      }
+      const msg = await sendMessage({
+        fromAgent: agentId,
+        targetAgent: target.targetAgent,
+        targetProject: target_project,
+        targetDevice: target_device,
+        sessionScope: target.sessionScope,
+        content,
+        priority
+      });
+      const statusText = msg.status === "delivered" ? "delivered" : msg.status === "failed" ? `failed: ${msg.failureReason}` : "queued (pending delivery)";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Message sent to ${target.targetAgent}: ${statusText}
+ID: ${msg.id}`
+          }
+        ]
+      };
+    }
+  );
+}
+
+export {
+  resolveMessageTarget,
+  registerSendMessage
+};

package/dist/{chunk-XFTEX77S.js → chunk-OQ4FNDRG.js}

@@ -1,15 +1,16 @@
 import {
   NO_DB_INTEGRITY_EVENTS
-} from "./chunk-UQGSBM3U.js";
+} from "./chunk-RFPMXR6B.js";
 import {
   resolveAnthropicAuth
 } from "./chunk-VGMACSEV.js";
 
 // src/lib/retrieval-health.ts
+import os from "os";
 async function getRetrievalHealth() {
   let embedDaemon = "unavailable";
   try {
-    const { isDaemonAlive } = await import("./mcp-health-HNVSWKFA.js");
+    const { isDaemonAlive } = await import("./mcp-health-B5EKRCZG.js");
     const { alive } = isDaemonAlive();
     if (alive) {
       try {
@@ -39,6 +40,7 @@ async function getRetrievalHealth() {
   } catch {
     embedDaemon = "unavailable";
   }
+  const lowMemoryHost = os.totalmem() <= 16 * 1024 ** 3;
   let configuredSearchMode = "hybrid";
   let selfQueryRouterEnabled = true;
   try {
@@ -54,7 +56,7 @@ async function getRetrievalHealth() {
   } else if (embedDaemon === "running") {
     actualSearchMode = "hybrid (vector+fts+graph)";
   } else if (embedDaemon === "disabled") {
-    actualSearchMode = "fts+graph (embeddings disabled by choice)";
+    actualSearchMode = lowMemoryHost ? "fts+graph (local embeddings unavailable: host RAM <= 16 GB)" : "fts+graph (embeddings disabled by choice)";
   } else {
     actualSearchMode = "fts+graph (degraded from hybrid)";
   }
@@ -80,7 +82,7 @@ async function getRetrievalHealth() {
     totalMemories = Number(totalRes.rows[0]?.cnt ?? 0);
     memoriesWithVectors = Number(vectorRes.rows[0]?.cnt ?? 0);
     try {
-      const { getGraphStats } = await import("./graph-query-AP5R6ZHO.js");
+      const { getGraphStats } = await import("./graph-query-ZEDO4BDF.js");
       const stats = await getGraphStats(client);
       entities = stats.entities;
       relationships = stats.relationships;
@@ -98,7 +100,7 @@ async function getRetrievalHealth() {
   }
   let dbIntegrity = NO_INTEGRITY_EVENTS;
   try {
-    const { getDbIntegrityHealth } = await import("./db-integrity-events-2DTFO37N.js");
+    const { getDbIntegrityHealth } = await import("./db-integrity-events-GYGANKZV.js");
     dbIntegrity = getDbIntegrityHealth();
   } catch {
   }
@@ -108,6 +110,7 @@ async function getRetrievalHealth() {
       configured: configuredSearchMode,
       actual: actualSearchMode
     },
+    lowMemoryHost,
     queryRouter,
     vectorBackfill: {
       totalMemories,
@@ -132,7 +135,16 @@ function computeDegradations(h) {
   const out = [];
   const isEmbeddingsDisabledByChoice = h.embedDaemon === "disabled" || h.searchMode.actual.includes("disabled by choice");
   const isRuntimeDowngrade = h.searchMode.actual.includes("degraded");
-  if (isEmbeddingsDisabledByChoice) {
+  const noVectorRetrieval = h.embedDaemon === "disabled" || h.searchMode.configured === "fts";
+  const isRamForcedOff = (h.lowMemoryHost ?? false) && noVectorRetrieval && !isRuntimeDowngrade;
+  if (isRamForcedOff) {
+    out.push({
+      code: "fts_only_low_memory_default",
+      severity: "info",
+      message: h.searchMode.configured === "fts" ? "Retrieval is FTS+Graph-only; this machine's RAM is at or below the 16 GB threshold for local embeddings, so vector retrieval is unavailable here regardless of configuration." : `Retrieval is FTS+Graph-only despite searchMode="${h.searchMode.configured}" \u2014 this machine's RAM is at or below the 16 GB threshold, so the daemon never starts local embeddings.`,
+      remediation: 'No action needed: keyword + graph retrieval is fully functional. This host cannot run local embeddings regardless of searchMode because of its RAM ceiling \u2014 switching searchMode to "hybrid" will not enable vector retrieval here.'
+    });
+  } else if (isEmbeddingsDisabledByChoice) {
     out.push({
       code: "embeddings_disabled_by_choice",
       severity: "info",
@@ -196,6 +208,16 @@ function computeDegradations(h) {
       remediation: "Do NOT trust recent backups. Run `exe-os doctor` to confirm, and restore from the newest backup that carries a `backup-verified` ledger entry."
     });
   }
+  if (gi.lowDiskSkips > 0 && gi.lastLowDiskSkip) {
+    const provenForLowDisk = gi.lastProvenBackupOnDisk;
+    const covered = provenForLowDisk !== null && provenForLowDisk.at > gi.lastLowDiskSkip.at;
+    out.push({
+      code: "backup_skipped_low_disk",
+      severity: covered ? "warn" : "critical",
+      message: `Backup declined due to low disk space (${gi.lowDiskSkips} skip(s) on record, most recent ${gi.lastLowDiskSkip.at})` + (provenForLowDisk ? ` \u2014 last PROVEN backup still on disk: ${provenForLowDisk.backup ?? "unknown"} at ${provenForLowDisk.at}` + (covered ? " (newer than the most recent skip, so recovery is not gated on it)" : "") : " \u2014 NO backup that is still on disk has been proven readable"),
+      remediation: "Free disk space on the backup volume (or its filesystem) immediately \u2014 no new backups can be taken until resolved. Check `~/.exe-os/missed-backups.jsonl` for the full history of misses."
+    });
+  }
   const unresolved = gi.unresolvedUnverifiedBackups;
   const proven = gi.lastProvenBackupOnDisk;
   if (unresolved > 0) {

package/dist/{chunk-VYQ7B7DI.js → chunk-OWVX52XF.js}

@@ -1,21 +1,21 @@
 import {
   cleanupCardsForMemories,
   cleanupGraphLinksForMemories
-} from "./chunk-ULIBLJ6W.js";
+} from "./chunk-YYC553FO.js";
 import {
   resolveAnthropicAuth
 } from "./chunk-VGMACSEV.js";
 import {
   buildSystemStateExclusionFilter,
   vectorToBlob
-} from "./chunk-MXPNVSXI.js";
+} from "./chunk-CIEVY5TD.js";
 import {
   extractKeywords,
   keywordsToString
 } from "./chunk-CHCA3ZM2.js";
 import {
   isCoordinatorName
-} from "./chunk-TAMDAOCU.js";
+} from "./chunk-66CGXQUA.js";
 
 // src/lib/consolidation.ts
 import { randomUUID } from "crypto";
@@ -344,7 +344,7 @@ async function runConsolidation(client, options) {
   let memoriesConsolidated = 0;
   let clustersFailed = 0;
   let attemptedSynthesis = 0;
-  const { runBudgetedSweep } = await import("./sweep-budget-KMPJ7O5Z.js");
+  const { runBudgetedSweep } = await import("./sweep-budget-YGLCNXZZ.js");
   await runBudgetedSweep(clusters, async (cluster) => {
     if (clustersProcessed >= options.maxCalls) return false;
     if (cluster.memories.length < 3) return;

package/dist/{chunk-AETLDRZB.js → chunk-PEAAX6UA.js}

@@ -1,7 +1,7 @@
 import {
   completeReminder,
   formatAmbiguousReminder
-} from "./chunk-636LKCKE.js";
+} from "./chunk-Q6ZLQMP2.js";
 
 // src/mcp/tools/complete-reminder.ts
 import { z } from "zod";

package/dist/{chunk-UM3N6VND.js → chunk-PFAVHC5N.js}

@@ -1,16 +1,16 @@
 import {
   buildSystemStateMemoryTypeExclusion
-} from "./chunk-MXPNVSXI.js";
+} from "./chunk-CIEVY5TD.js";
 import {
   sessionScopeFilter
-} from "./chunk-AKLQSC6W.js";
+} from "./chunk-KI7O64XV.js";
 import {
   getClient,
   getIdentity
-} from "./chunk-TAMDAOCU.js";
+} from "./chunk-66CGXQUA.js";
 import {
   getEmotionalBaseline
-} from "./chunk-NJFJWQNN.js";
+} from "./chunk-L5CGXEZC.js";
 
 // src/lib/dreaming.ts
 var DreamingEngine = class {
@@ -646,7 +646,7 @@ var DreamingEngine = class {
     }
     let overdueProspective = [];
     try {
-      const { getOverdueProspective, completeProspective } = await import("./prospective-memory-KR3P4T6N.js");
+      const { getOverdueProspective, completeProspective } = await import("./prospective-memory-GEO6E3UL.js");
       const overdue = await getOverdueProspective(agentId);
       overdueProspective = overdue.map((o) => ({
         id: o.id,

package/dist/chunk-PMVVUIHH.js

@@ -0,0 +1,85 @@
+// src/lib/daemon-drift.ts
+import { existsSync, readFileSync } from "fs";
+import { execFileSync } from "child_process";
+import path from "path";
+var DAEMON_DRIFT_FAIL_THRESHOLD = 10;
+var DRIFT_GIT_TIMEOUT_MS = 3e3;
+var defaultGitRunner = (args, cwd) => execFileSync("git", args, { cwd, encoding: "utf-8", timeout: DRIFT_GIT_TIMEOUT_MS }).trim();
+function resolveRunningDaemonScript(pidFile) {
+  try {
+    const pid = parseInt(readFileSync(pidFile, "utf8").trim(), 10);
+    if (!Number.isFinite(pid) || pid <= 0) return null;
+    const cmdline = execFileSync("ps", ["-p", String(pid), "-o", "command="], {
+      encoding: "utf-8",
+      timeout: 2e3
+    });
+    const token = cmdline.trim().split(/\s+/).find((t) => t.endsWith("exe-daemon.js"));
+    return token ?? null;
+  } catch {
+    return null;
+  }
+}
+function checkoutRootFromScript(script) {
+  const suffix = path.join("dist", "lib", "exe-daemon.js");
+  if (script.endsWith(suffix)) {
+    return path.resolve(path.dirname(script), "..", "..");
+  }
+  let dir = path.dirname(path.resolve(script));
+  const { root } = path.parse(dir);
+  while (dir !== root) {
+    if (existsSync(path.join(dir, "package.json"))) return dir;
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+function measureDaemonDrift(opts) {
+  const { daemonScript, referenceRoot } = opts;
+  const threshold = opts.threshold ?? DAEMON_DRIFT_FAIL_THRESHOLD;
+  const run = opts.run ?? defaultGitRunner;
+  if (!daemonScript) {
+    return { status: "unknown", reason: "no daemon script path resolved (daemon not running and no local dist fallback)" };
+  }
+  const daemonRoot = checkoutRootFromScript(daemonScript);
+  if (!daemonRoot) {
+    return { status: "unknown", reason: `cannot find checkout root above ${daemonScript}` };
+  }
+  let head;
+  try {
+    head = run(["rev-parse", "HEAD"], daemonRoot);
+  } catch (err) {
+    return {
+      status: "unknown",
+      reason: `cannot read daemon checkout HEAD at ${daemonRoot} (${err instanceof Error ? err.message.split("\n")[0] : String(err)})`
+    };
+  }
+  try {
+    const base = run(["rev-parse", "origin/main"], referenceRoot);
+    const behind = parseInt(run(["rev-list", "--count", `${head}..origin/main`], referenceRoot), 10);
+    const ahead = parseInt(run(["rev-list", "--count", `origin/main..${head}`], referenceRoot), 10);
+    if (Number.isFinite(behind) && Number.isFinite(ahead)) {
+      return { status: behind > threshold ? "stale" : "ok", behind, ahead, head, base, measuredVia: "reference-repo" };
+    }
+  } catch {
+  }
+  try {
+    const base = run(["rev-parse", "origin/main"], daemonRoot);
+    const behind = parseInt(run(["rev-list", "--count", `HEAD..origin/main`], daemonRoot), 10);
+    const ahead = parseInt(run(["rev-list", "--count", `origin/main..HEAD`], daemonRoot), 10);
+    if (Number.isFinite(behind) && Number.isFinite(ahead)) {
+      return { status: behind > threshold ? "stale" : "ok", behind, ahead, head, base, measuredVia: "daemon-repo" };
+    }
+  } catch {
+  }
+  return {
+    status: "unknown",
+    reason: `could not count ${head.slice(0, 8)}..origin/main in either ${referenceRoot} or the daemon checkout (not a git checkout, missing refs, or unrelated history)`
+  };
+}
+
+export {
+  DAEMON_DRIFT_FAIL_THRESHOLD,
+  DRIFT_GIT_TIMEOUT_MS,
+  defaultGitRunner,
+  resolveRunningDaemonScript,
+  measureDaemonDrift
+};