@askexenow/exe-os 0.9.384 → 0.9.389

package/dist/{chunk-OAFENIHN.js → chunk-RJ67XAJU.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-MMS2HBRT.js";
 
 // src/lib/worker-gate.ts
-import { readdirSync, writeFileSync, unlinkSync, mkdirSync, existsSync, readFileSync } from "fs";
+import { readdirSync, writeFileSync, unlinkSync, mkdirSync, readFileSync } from "fs";
 import path from "path";
 import { totalmem, cpus } from "os";
 var WORKER_PID_DIR = path.join(EXE_AI_DIR, "worker-pids");
@@ -15,11 +15,31 @@ function computeMaxWorkers() {
   return Math.max(2, Math.min(8, Math.min(byRam, byCpu)));
 }
 var MAX_CONCURRENT_WORKERS = process.env.EXE_MAX_WORKERS ? Math.max(1, parseInt(process.env.EXE_MAX_WORKERS, 10) || 3) : computeMaxWorkers();
+function errnoOf(err) {
+  return err?.code;
+}
+function describe(err) {
+  const code = errnoOf(err);
+  const msg = err instanceof Error ? err.message : String(err);
+  return code ? `${code}: ${msg}` : msg;
+}
+function pidLiveness(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    const code = errnoOf(err);
+    if (code === "ESRCH") return false;
+    if (code === "EPERM") return true;
+    return null;
+  }
+}
 function tryAcquireWorkerSlot() {
+  let reservationPath = null;
   try {
     mkdirSync(WORKER_PID_DIR, { recursive: true });
     const reservationId = `res-${process.pid}-${Date.now()}`;
-    const reservationPath = path.join(WORKER_PID_DIR, `${reservationId}.pid`);
+    reservationPath = path.join(WORKER_PID_DIR, `${reservationId}.pid`);
     writeFileSync(reservationPath, String(process.pid));
     const files = readdirSync(WORKER_PID_DIR);
     let alive = 0;
@@ -29,14 +49,13 @@ function tryAcquireWorkerSlot() {
         const resParts = f.replace(".pid", "").split("-");
         const resPid = parseInt(resParts[1] ?? "", 10);
         if (!isNaN(resPid) && resPid > 0) {
-          try {
-            process.kill(resPid, 0);
-            alive++;
-          } catch {
+          if (pidLiveness(resPid) === false) {
             try {
               unlinkSync(path.join(WORKER_PID_DIR, f));
             } catch {
             }
+          } else {
+            alive++;
           }
         } else {
           alive++;
@@ -46,14 +65,13 @@ function tryAcquireWorkerSlot() {
       const dashIdx = f.lastIndexOf("-");
       const pid = parseInt(f.slice(dashIdx + 1).replace(".pid", ""), 10);
       if (isNaN(pid)) continue;
-      try {
-        process.kill(pid, 0);
-        alive++;
-      } catch {
+      if (pidLiveness(pid) === false) {
         try {
           unlinkSync(path.join(WORKER_PID_DIR, f));
         } catch {
         }
+      } else {
+        alive++;
       }
     }
     if (alive >= MAX_CONCURRENT_WORKERS) {
@@ -68,15 +86,27 @@ function tryAcquireWorkerSlot() {
     } catch {
     }
     return true;
-  } catch {
-    return true;
+  } catch (err) {
+    if (reservationPath) {
+      try {
+        unlinkSync(reservationPath);
+      } catch {
+      }
+    }
+    console.error(
+      `[worker-gate] Cannot count worker slots in ${WORKER_PID_DIR} (${describe(err)}) - refusing this spawn rather than bypassing MAX_CONCURRENT_WORKERS.`
+    );
+    return false;
   }
 }
 function registerWorkerPid(pid) {
   try {
     mkdirSync(WORKER_PID_DIR, { recursive: true });
     writeFileSync(path.join(WORKER_PID_DIR, `worker-${pid}.pid`), String(pid));
-  } catch {
+  } catch (err) {
+    console.error(
+      `[worker-gate] Failed to record worker pid ${pid} in ${WORKER_PID_DIR} (${describe(err)}) \u2014 it will not count toward MAX_CONCURRENT_WORKERS.`
+    );
   }
 }
 function cleanupWorkerPid() {
@@ -89,26 +119,44 @@ var BACKFILL_LOCK = path.join(WORKER_PID_DIR, "backfill.lock");
 function tryAcquireBackfillLock() {
   try {
     mkdirSync(WORKER_PID_DIR, { recursive: true });
-    if (existsSync(BACKFILL_LOCK)) {
-      try {
-        const pid = parseInt(
-          readFileSync(BACKFILL_LOCK, "utf8").trim(),
-          10
+    let raw;
+    try {
+      raw = readFileSync(BACKFILL_LOCK, "utf8");
+    } catch (err) {
+      const code = errnoOf(err);
+      if (code === "ENOENT" || code === "ENOTDIR") {
+        raw = null;
+      } else {
+        console.error(
+          `[worker-gate] Backfill lock ${BACKFILL_LOCK} exists but could not be read (${describe(err)}) - refusing to start a second backfill.`
         );
-        if (!isNaN(pid) && pid > 0) {
-          try {
-            process.kill(pid, 0);
-            return false;
-          } catch {
-          }
-        }
-      } catch {
+        return false;
+      }
+    }
+    if (raw !== null) {
+      const pid = parseInt(raw.trim(), 10);
+      if (isNaN(pid) || pid <= 0) {
+        console.error(
+          `[worker-gate] Backfill lock ${BACKFILL_LOCK} holds no readable pid - refusing to start a second backfill. Delete that file if no backfill is running.`
+        );
+        return false;
+      }
+      const live = pidLiveness(pid);
+      if (live === true) return false;
+      if (live === null) {
+        console.error(
+          `[worker-gate] Could not determine whether backfill pid ${pid} is alive - refusing to start a second backfill.`
+        );
+        return false;
       }
     }
     writeFileSync(BACKFILL_LOCK, String(process.pid));
     return true;
-  } catch {
-    return true;
+  } catch (err) {
+    console.error(
+      `[worker-gate] Cannot evaluate the backfill lock in ${WORKER_PID_DIR} (${describe(err)}) - refusing to start a backfill.`
+    );
+    return false;
   }
 }
 function releaseBackfillLock() {

package/dist/{chunk-LFUBEHFW.js → chunk-RT57D7C4.js}

@@ -126,8 +126,32 @@ function declaredArtifactsFromManifest(manifest, options) {
   }
   return out;
 }
+var OBSERVATION_MAX_AGE_HOURS = 24;
+function creditObservation(obs, nowMs, maxAgeHours = OBSERVATION_MAX_AGE_HOURS) {
+  if (!obs || typeof obs !== "object") {
+    return { credited: false, why: "no observation was supplied" };
+  }
+  const source = typeof obs.source === "string" && obs.source.trim() !== "" ? obs.source : "<unnamed source>";
+  if (obs.ok !== true) {
+    return { credited: false, why: `${source} did not report success` };
+  }
+  const atMs = typeof obs.at === "string" ? Date.parse(obs.at) : Number.NaN;
+  if (!Number.isFinite(atMs)) {
+    return { credited: false, why: `${source} reported success at an unreadable time (${String(obs.at)})` };
+  }
+  const ageH = (nowMs - atMs) / 36e5;
+  if (!(ageH <= maxAgeHours)) {
+    return {
+      credited: false,
+      why: `${source} last succeeded ${ageH.toFixed(1)}h ago, older than the ${maxAgeHours}h window`
+    };
+  }
+  return { credited: true, why: `${source} succeeded ${Math.max(0, ageH).toFixed(1)}h ago` };
+}
 function evaluateDeliveryChannels(input) {
   const { detected, registry, npmFiles } = input;
+  const observations = input.observations ?? {};
+  const nowMs = input.now ?? Date.now();
   const normalizedFiles = npmFiles.map((f) => f.replace(/^\.\//, "").replace(/\/+$/, ""));
   const covered = (p) => {
     const path = p.replace(/^\.\//, "").replace(/\/+$/, "");
@@ -180,13 +204,25 @@ function evaluateDeliveryChannels(input) {
       });
       continue;
     }
+    const credit = creditObservation(observations[d.path], nowMs);
+    if (credit.credited) {
+      out.push({
+        path: d.path,
+        channel,
+        verdict: "channel-declared",
+        evidence: "observation",
+        observed: true,
+        detail: `${d.path} declares the ${channel} channel, passes the checks that declaration implies, and a deployment WAS observed: ${credit.why}.`
+      });
+      continue;
+    }
     out.push({
       path: d.path,
       channel,
       verdict: "channel-declared",
       evidence: "declaration",
       observed: false,
-      detail: `${d.path} declares the ${channel} channel and passes the checks that declaration implies. No deployment was observed \u2014 this says where a change WOULD go, not that it went.`
+      detail: `${d.path} declares the ${channel} channel and passes the checks that declaration implies. No deployment was observed (${credit.why}) \u2014 this says where a change WOULD go, not that it went.`
     });
   }
   return out;
@@ -305,6 +341,8 @@ export {
   repositoryKey,
   compareLiveArtifacts,
   declaredArtifactsFromManifest,
+  OBSERVATION_MAX_AGE_HOURS,
+  creditObservation,
   evaluateDeliveryChannels,
   extractGateCookieNames,
   evaluateAnonymousGate,

package/dist/{chunk-MKM6D7JM.js → chunk-RWG7DLOG.js}

@@ -2,10 +2,10 @@ import {
   BUSY_PATTERN,
   sendIntercom,
   updateTaskStatus
-} from "./chunk-7UHZBVP3.js";
+} from "./chunk-QDVLVLXP.js";
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-LSNBTGW4.js";
+} from "./chunk-DPYZW42H.js";
 import {
   hasPassed
 } from "./chunk-YRUZK2QA.js";
@@ -13,7 +13,7 @@ import {
   baseAgentName,
   getCoordinatorName,
   isCoordinatorName
-} from "./chunk-GL47M7NY.js";
+} from "./chunk-3UD3OF3X.js";
 import {
   isAutonomousTmuxSpawnEnabled
 } from "./chunk-MMS2HBRT.js";
@@ -338,7 +338,7 @@ async function surfaceStaleDispatchPendingSignals(scopeList, now, thresholdMs =
     const sessionScope = signalScope ?? (scopeList.length === 1 ? scopeList[0] : null);
     if (allowedScopes.size > 0 && sessionScope && !allowedScopes.has(sessionScope)) continue;
     try {
-      const { writeNotification } = await import("./notifications-JE3PX55X.js");
+      const { writeNotification } = await import("./notifications-3R6HNHDR.js");
       await writeNotification({
         agentId: getCoordinatorName(),
         agentRole: "COO",
@@ -475,8 +475,32 @@ async function runTaskEnforcementTick(deps) {
     source: "task-enforcement.runTaskEnforcementTick",
     payload: { sessionCount: sessions.length }
   });
+  if (deps.scopeFilter.failClosed) {
+    const why = deps.scopeFilter.reason ?? "session scope could not be resolved";
+    writeAuditEntry({
+      timestamp: new Date(now).toISOString(),
+      session: "-",
+      agent: "-",
+      role: "daemon",
+      action: "scope_unresolved",
+      reason: `enforcement REFUSED this tick \u2014 ${why}; no session was evaluated and no conclusion about open tasks was reached`
+    });
+    process.stderr.write(
+      `[exed] Task enforcement REFUSED this tick: ${why}. No session was evaluated \u2014 this is NOT a finding that agents have no open tasks. Resolve the coordinator scope (EXE_SESSION_SCOPE) or run one daemon per coordinator.
+`
+    );
+    recordOrchestrationEventBestEffort({
+      eventType: "daemon.tick.refused",
+      source: "task-enforcement.runTaskEnforcementTick",
+      severity: "warn",
+      result: "refused",
+      payload: { reason: why }
+    });
+    return;
+  }
   const hasScopeRestriction = deps.scopeFilter.sql.length > 0;
   const allowedScope = hasScopeRestriction && deps.scopeFilter.args.length > 0 ? String(deps.scopeFilter.args[deps.scopeFilter.args.length - 1]) : null;
+  const scopeSkipped = [];
   for (const session of sessions) {
     if (!session.includes("-")) continue;
     const rawAgent = session.split("-")[0];
@@ -484,7 +508,10 @@ async function runTaskEnforcementTick(deps) {
     if (!agentName) continue;
     if (allowedScope) {
       const sessionSuffix = session.slice(session.indexOf("-") + 1);
-      if (sessionSuffix !== allowedScope) continue;
+      if (sessionSuffix !== allowedScope) {
+        scopeSkipped.push(session);
+        continue;
+      }
     }
     if ("isAlive" in transport && typeof transport.isAlive === "function") {
       if (!transport.isAlive(session)) continue;
@@ -656,6 +683,16 @@ async function runTaskEnforcementTick(deps) {
     } catch {
     }
   }
+  if (scopeSkipped.length > 0) {
+    writeAuditEntry({
+      timestamp: new Date(now).toISOString(),
+      session: scopeSkipped.join(","),
+      agent: "-",
+      role: "daemon",
+      action: "scope_skipped",
+      reason: `${scopeSkipped.length} live session(s) not evaluated \u2014 outside this daemon's coordinator scope "${allowedScope}"`
+    });
+  }
   if (processedAnyEmployee) {
     try {
       const scopeList = allowedScope ? [...processedScopes].filter((s) => s === allowedScope) : [...processedScopes];

package/dist/{chunk-P3UX5EH4.js → chunk-RWKAHHIX.js}

@@ -1,13 +1,13 @@
 import {
   isExeSession
-} from "./chunk-7UHZBVP3.js";
+} from "./chunk-QDVLVLXP.js";
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-LSNBTGW4.js";
+} from "./chunk-DPYZW42H.js";
 import {
   getClient,
   isCoordinatorName
-} from "./chunk-GL47M7NY.js";
+} from "./chunk-3UD3OF3X.js";
 import {
   isDaemonAlive
 } from "./chunk-QH5ZQ5SJ.js";

package/dist/{chunk-XEBKIWI7.js → chunk-RYNT3HB7.js}

@@ -1,23 +1,23 @@
 import {
   MultiAgentOrchestrator
-} from "./chunk-W3KPQE7H.js";
+} from "./chunk-3GL3E4TD.js";
 import {
   createTokenBudgetMiddleware
-} from "./chunk-SDYWZRPN.js";
+} from "./chunk-TLSFGXXE.js";
 import {
   createQuietRenderer,
   createTerminalRenderer,
   renderAgentEvents
 } from "./chunk-YZFZDJWZ.js";
-import {
-  checkDangerousPatterns,
-  hasCriticalPattern
-} from "./chunk-CMCYL2JC.js";
 import {
   checkPathSafety,
   checkReadPathSafety,
   containsPathTraversal
 } from "./chunk-NGVOA6ZQ.js";
+import {
+  checkDangerousPatterns,
+  hasCriticalPattern
+} from "./chunk-CMCYL2JC.js";
 import {
   ContextManager,
   agentLoop,
@@ -30,7 +30,7 @@ import {
   recordDenial,
   recordSuccess,
   shouldFallbackToAsk
-} from "./chunk-TKS5GMYA.js";
+} from "./chunk-U44Y7RC7.js";
 import {
   composeHooks,
   createDefaultHooks
@@ -212,7 +212,7 @@ function createExeOSHooks(config) {
         );
       }
       try {
-        const { listBehaviors } = await import("./behaviors-SCCZP7RZ.js");
+        const { listBehaviors } = await import("./behaviors-RMLDPLOF.js");
         const behaviors = await listBehaviors(config.agentId, config.projectName, 12);
         if (behaviors.length > 0) {
           process.stderr.write(
@@ -250,7 +250,7 @@ function createExeOSHooks(config) {
       const ALLOWED_RE = /^(Bash|Edit|Write|Read|Glob|Grep|Agent|mcp__.*)$/;
       if (!ALLOWED_RE.test(toolName)) return;
       try {
-        const { extractSemanticText } = await import("./content-extractor-ZLXC6GNR.js");
+        const { extractSemanticText } = await import("./content-extractor-OGXETBOX.js");
         const { writeMemory } = await import("./lib/store.js");
         const toolInput = block.input ?? {};
         const toolResponse = result.isError ? { error: result.content } : { output: result.content };
@@ -333,7 +333,7 @@ function createExeOSHooks(config) {
     async onSubagentStop(_reason) {
       try {
         const { getClient } = await import("./lib/database.js");
-        const { sessionScopeFilter } = await import("./task-scope-NHXB4ZRN.js");
+        const { sessionScopeFilter } = await import("./task-scope-32HQEV6W.js");
         const client = getClient();
         const ehScope = sessionScopeFilter();
         const tasks = await client.execute({
@@ -373,7 +373,7 @@ function createExeOSHooks(config) {
         setAt: (/* @__PURE__ */ new Date()).toISOString()
       });
       try {
-        const { writeNotification } = await import("./notifications-JE3PX55X.js");
+        const { writeNotification } = await import("./notifications-3R6HNHDR.js");
         await writeNotification({
           agentId: config.agentId,
           agentRole: "employee",
@@ -444,7 +444,7 @@ function createExeOSHooks(config) {
         try {
           const { writeMemory, flushBatch } = await import("./lib/store.js");
           const { getClient } = await import("./lib/database.js");
-          const { sessionScopeFilter: cpScopeFilter } = await import("./task-scope-NHXB4ZRN.js");
+          const { sessionScopeFilter: cpScopeFilter } = await import("./task-scope-32HQEV6W.js");
           const client = getClient();
           const cpScope = cpScopeFilter();
           const tasks = await client.execute({

package/dist/{chunk-EUGEFBGV.js → chunk-S2V272KJ.js}

@@ -1,6 +1,6 @@
 import {
   extractSemanticText
-} from "./chunk-HA63SH5W.js";
+} from "./chunk-IWY2OGQG.js";
 import {
   detectError
 } from "./chunk-G2M7WQ2M.js";
@@ -9,10 +9,10 @@ import {
 } from "./chunk-5MOYSU5A.js";
 import {
   redactSecrets
-} from "./chunk-ELEGH4DX.js";
+} from "./chunk-ZUGQPYUY.js";
 import {
   getProjectName
-} from "./chunk-UX2EO653.js";
+} from "./chunk-ZZWFZ46U.js";
 
 // src/lib/post-tool-memory.ts
 var NON_INGESTIBLE_TOOLS = /* @__PURE__ */ new Set([

package/dist/{chunk-W6BZ4UGA.js → chunk-SGYEM2PD.js}

@@ -132,7 +132,7 @@ async function verifyOrBlock(hookPath) {
     process.stderr.write(`[SECURITY] Hook tamper detected: ${filename} \u2014 ${result.reason}
 `);
     try {
-      const { pushNotifyAsync } = await import("./push-notifications-M7YU63FY.js");
+      const { pushNotifyAsync } = await import("./push-notifications-XC6EQEXF.js");
       pushNotifyAsync({
         event: "security_alert",
         title: "Hook tamper detected",

package/dist/{chunk-VROK4X2L.js → chunk-SJP57MQM.js}

@@ -2,7 +2,7 @@ import {
   decryptSyncBlob,
   encryptSyncBlob,
   isSyncCryptoInitialized
-} from "./chunk-ZPP63JSQ.js";
+} from "./chunk-CL3AB7Z2.js";
 
 // src/lib/crdt-sync.ts
 import * as Y from "yjs";

package/dist/{chunk-5MVKTNZP.js → chunk-SL4JWAMQ.js}

@@ -38,6 +38,21 @@ var TOOL_GATES = {
    * person is actually talking to.
    */
   "org-member": [],
+  /**
+   * DECLARED unrestricted, not accidentally unrestricted.
+   *
+   * `isToolAllowed` now refuses a tool with no category (see below), so every
+   * registered tool must name one. These are the tools that were reachable by
+   * every role because they were simply MISSING from the map — the baseline
+   * `tests/tool-category-coverage.test.ts` used to carry. Declaring them here
+   * preserves exactly the access they have today while removing the fail-open
+   * default that made that access invisible.
+   *
+   * This is a holding category, not a verdict: each entry still deserves a real
+   * one. Moving an entry out of here is a deliberate, reviewable change to who
+   * can reach it — which is the whole point of it being written down.
+   */
+  unrestricted: [],
   admin: ["COO"],
   // deploy, backup, daemon health, auto-wake, worker gate, memory audit, consolidation, cloud sync, agent config, list employees, agent spend, sessions, session kills
   licensing: ["COO"],
@@ -66,6 +81,13 @@ var TOOL_CATEGORIES = {
   // The member's own consent, refusal and exit. See the "org-member" gate.
   registerOrgPartner: "org-member",
   registerOrgMemoryConsent: "org-member",
+  // LEAVING IS A MEMBER ACTION, NOT AN ADMIN ONE. org_self is how a person
+  // reads their own roster row and WALKS OUT. Admin-gating it would mean an
+  // employee's own agent could not end their own membership — the exit would
+  // belong to the employer, which inverts the thing the org design exists to
+  // protect. `[]` here is the same deliberate choice as the other org-member
+  // surfaces, not a default that happened to land in the right place.
+  registerOrgSelf: "org-member",
   // org_owner is the OWNER's half of delegation: assign work into a member's
   // install, read what members report, poll the org's own inbox. `admin`, and
   // deliberately NOT "org-member" — that category is `[]` (every role) on
@@ -210,7 +232,24 @@ var TOOL_CATEGORIES = {
   registerGlobalProcedure: "orchestration",
   registerStoreGlobalProcedure: "orchestration",
   registerListGlobalProcedures: "orchestration",
-  registerDeactivateGlobalProcedure: "orchestration"
+  registerDeactivateGlobalProcedure: "orchestration",
+  // ── declared unrestricted (see the "unrestricted" gate) ──────────────────
+  // Previously absent from this map, and therefore reachable by every role via
+  // the fail-open default. Listed so the access is stated rather than implied.
+  registerCreateFeatureRequest: "unrestricted",
+  registerDependencyTree: "unrestricted",
+  registerDreaming: "unrestricted",
+  registerGetFeatureRequest: "unrestricted",
+  registerImportConversations: "unrestricted",
+  registerListFeatureRequests: "unrestricted",
+  registerPipeline: "unrestricted",
+  registerReactivateBehavior: "unrestricted",
+  registerResonance: "unrestricted",
+  registerSteward: "unrestricted",
+  registerTriageFeatureRequest: "unrestricted",
+  registerUpdateBugReport: "unrestricted",
+  registerUpdateFeatureRequest: "unrestricted",
+  registerWikiDocSeal: "unrestricted"
 };
 var PLAN_TIERS = {
   free: 0,
@@ -234,14 +273,24 @@ var PLAN_GATES = {
   documents: "pro",
   gateway: "pro",
   admin: "pro",
-  orchestration: "pro"
+  orchestration: "pro",
+  unrestricted: "free"
+  // exactly the plan tier these had while unmapped
 };
 function isToolAllowedForPlan(registerFnName, plan) {
   const category = TOOL_CATEGORIES[registerFnName];
-  if (!category) return true;
+  if (!category) return false;
   const requiredPlan = PLAN_GATES[category] ?? "free";
   return PLAN_TIERS[plan] >= PLAN_TIERS[requiredPlan];
 }
+function resolveToolCategory(toolName) {
+  if (!toolName) return void 0;
+  const direct = TOOL_CATEGORIES[toolName];
+  if (direct) return direct;
+  const pascal = toolName.split(/[_\-.]+/).filter((part) => part.length > 0).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+  if (!pascal) return void 0;
+  return TOOL_CATEGORIES[`register${pascal}`];
+}
 var CHIEF_OF_STAFF_READ_TOOLS = /* @__PURE__ */ new Set([
   "registerRecallMyMemory",
   "registerAskTeamMemory",
@@ -270,7 +319,7 @@ function isToolAllowed(registerFnName) {
     return CHIEF_OF_STAFF_READ_TOOLS.has(registerFnName);
   }
   const category = TOOL_CATEGORIES[registerFnName];
-  if (!category) return true;
+  if (!category) return false;
   const allowedRoles = TOOL_GATES[category];
   if (!allowedRoles || allowedRoles.length === 0) return true;
   return allowedRoles.includes(role);
@@ -280,5 +329,6 @@ export {
   TOOL_GATES,
   TOOL_CATEGORIES,
   isToolAllowedForPlan,
+  resolveToolCategory,
   isToolAllowed
 };

package/dist/{chunk-MOANZQXF.js → chunk-SLMKLEU6.js}

@@ -1,6 +1,6 @@
 import {
   canonicalizeStackManifest
-} from "./chunk-ZBPZDADW.js";
+} from "./chunk-UWVXQEQQ.js";
 
 // src/lib/stack-manifest-write.ts
 import { readFileSync, statSync, writeFileSync } from "fs";

package/dist/{chunk-RZN2LEAK.js → chunk-SQA7XCYI.js}

@@ -1,6 +1,6 @@
 import {
   getClient
-} from "./chunk-GL47M7NY.js";
+} from "./chunk-3UD3OF3X.js";
 
 // src/lib/pipeline-router.ts
 import crypto from "crypto";
@@ -140,8 +140,8 @@ Agent response: ${agentResponse}` : ""
 }
 async function sinkEntityExtraction(msg, agentResponse, agentName) {
   try {
-    const { extractFromConversation } = await import("./conversation-entity-extractor-7FRKLLBD.js");
-    const { storeExtraction } = await import("./graph-rag-BKAD2XQA.js");
+    const { extractFromConversation } = await import("./conversation-entity-extractor-FQCOAH4F.js");
+    const { storeExtraction } = await import("./graph-rag-H24CMFP2.js");
     if ((msg.text?.length ?? 0) < 20) return false;
     if (msg.isHistorical) return false;
     const extraction = await extractFromConversation(msg, agentResponse, agentName);