@askexenow/exe-os 0.9.159 → 0.9.161

package/dist/{chunk-IKDK7NXN.js → chunk-BZYHF63H.js}

@@ -1,9 +1,9 @@
 import {
   recordSessionKill
-} from "./chunk-COUXA2IQ.js";
+} from "./chunk-FRH7EY2Z.js";
 import {
   updateTask
-} from "./chunk-F6LDN5XB.js";
+} from "./chunk-MPCICOVG.js";
 import {
   ensureEmployee,
   extractRootExe,
@@ -14,7 +14,7 @@ import {
   sessionScopeFilter,
   strictSessionScopeFilter,
   writeNotification
-} from "./chunk-SNTCGJAE.js";
+} from "./chunk-7X7HKWH7.js";
 import {
   queueIntercom
 } from "./chunk-TXSJ2L5O.js";
@@ -35,7 +35,7 @@ import {
   baseAgentName,
   isCoordinatorName,
   shouldAutoInstance
-} from "./chunk-JTS3IDOY.js";
+} from "./chunk-JYETM4KT.js";
 import {
   loadConfigSync
 } from "./chunk-4GXRETYL.js";
@@ -152,7 +152,7 @@ function classifyTtlKillReason(ageHours, contextPct) {
 function shouldKillIdleSession(input) {
   if (!input.enabled) return false;
   if (isExeSession(input.sessionName)) return false;
-  if (input.state !== "idle") return false;
+  if (input.state !== "idle" && input.state !== "no_claude") return false;
   if (input.signals.hasOpenTasks) return false;
   if (input.signals.hasNeedsReview) return false;
   if (input.signals.hasUnreadInbox) return false;
@@ -282,7 +282,7 @@ async function pollIdleKill(deps, idleTickCounts, opts) {
       continue;
     }
     const state = deps.getSessionState(entry.windowName);
-    if (state !== "idle") {
+    if (state !== "idle" && state !== "no_claude") {
       idleTickCounts.delete(entry.windowName);
       continue;
     }
@@ -611,7 +611,7 @@ async function pollOrphanedTasks(deps, nowMs = Date.now()) {
 `
       );
       try {
-        const { writeNotification: writeNotification2 } = await import("./notifications-WNSNHFH6.js");
+        const { writeNotification: writeNotification2 } = await import("./notifications-CSVHULU2.js");
         await writeNotification2({
           agentId,
           agentRole: "employee",
@@ -628,16 +628,27 @@ async function pollOrphanedTasks(deps, nowMs = Date.now()) {
     const retries = _autoWakeTaskRetries.get(topTask.taskId) ?? 0;
     if (retries >= AUTO_WAKE_MAX_RETRIES) {
       try {
-        await deps.markTaskBlocked(
+        await deps.markTaskNeedsReview(
           topTask.taskId,
-          `Auto-wake failed ${AUTO_WAKE_MAX_RETRIES} times \u2014 marking blocked for manual intervention`
+          `Auto-wake failed ${AUTO_WAKE_MAX_RETRIES} times \u2014 auto-closed: session ended without explicit completion. Needs manual review.`
         );
         process.stderr.write(
-          `[auto-wake] ${agentId} task ${topTask.taskId} exceeded ${AUTO_WAKE_MAX_RETRIES} retries \u2014 marked blocked
+          `[auto-wake] ${agentId} task ${topTask.taskId} exceeded ${AUTO_WAKE_MAX_RETRIES} retries \u2014 marked needs_review
 `
         );
       } catch (e) {
-        process.stderr.write("[daemon-orch] mark task blocked after retries: " + (e instanceof Error ? e.message : String(e)) + "\n");
+        process.stderr.write("[daemon-orch] mark task needs_review after retries: " + (e instanceof Error ? e.message : String(e)) + "\n");
+      }
+      try {
+        await writeNotification({
+          agentId,
+          agentRole: "employee",
+          event: "orphan_task",
+          project: String(topTask.sessionScope ?? ""),
+          summary: `\u26A0\uFE0F Task ${topTask.taskId} for ${agentId} needs review \u2014 auto-wake failed ${AUTO_WAKE_MAX_RETRIES} times. Session could not be recovered.`,
+          sessionScope
+        });
+      } catch {
       }
       continue;
     }
@@ -702,16 +713,16 @@ async function releaseStuckTasks(deps, nowMs = Date.now()) {
     const ageMinutes = Math.round((nowMs - updatedMs) / 6e4);
     if (!liveAgents.has(t.agentId)) {
       if (nowMs - updatedMs < STUCK_TASK_GRACE_MS) continue;
-      const reason = `[auto-release] Agent "${t.agentId}" session is dead and task has been in_progress for ${ageMinutes}m with no update. Marked blocked for triage.`;
+      const reason = `Auto-closed: agent "${t.agentId}" session ended without explicit completion (in_progress for ${ageMinutes}m, no live session). Needs manual review.`;
       try {
-        await deps.markTaskBlocked(t.taskId, reason);
+        await deps.markTaskNeedsReview(t.taskId, reason);
         released.push(t.taskId);
         process.stderr.write(
-          `[stuck-release] Task ${t.taskId} (${t.agentId}) \u2014 in_progress for ${ageMinutes}m, agent dead \u2192 blocked
+          `[stuck-release] Task ${t.taskId} (${t.agentId}) \u2014 in_progress for ${ageMinutes}m, agent dead \u2192 needs_review
 `
         );
       } catch (err) {
-        process.stderr.write(`[stuck-release] Failed to block task ${t.taskId}: ${err instanceof Error ? err.message : String(err)}
+        process.stderr.write(`[stuck-release] Failed to mark task ${t.taskId} needs_review: ${err instanceof Error ? err.message : String(err)}
 `);
       }
       if (deps.notifyOrphan) {
@@ -761,13 +772,13 @@ function createStuckTaskRealDeps(getClient) {
         updatedAt: String(r.updated_at)
       }));
     },
-    markTaskBlocked: async (taskId, reason) => {
+    markTaskNeedsReview: async (taskId, reason) => {
       try {
-        await updateTask({ taskId, status: "blocked", result: reason });
+        await updateTask({ taskId, status: "needs_review", result: reason });
       } catch {
         const client = getClient();
         await client.execute({
-          sql: `UPDATE tasks SET status = 'blocked', result = ?, updated_at = ? WHERE id = ?`,
+          sql: `UPDATE tasks SET status = 'needs_review', result = ?, updated_at = ? WHERE id = ?`,
           args: [reason, (/* @__PURE__ */ new Date()).toISOString(), taskId]
         });
       }
@@ -783,7 +794,7 @@ function createStuckTaskRealDeps(getClient) {
         agentRole: "employee",
         event: "orphan_task",
         project: "",
-        summary: `Agent "${agentId}" session died \u2014 task ${taskId.slice(0, 8)} auto-released to blocked for triage`
+        summary: `Agent "${agentId}" session died \u2014 task ${taskId.slice(0, 8)} needs review (auto-closed: session ended without completion)`
       });
     }
   };
@@ -902,13 +913,13 @@ function createAutoWakeRealDeps(getClient, projectDir) {
     ensureEmployee: (agentName, scope) => {
       return ensureEmployee(agentName, scope, projectDir, shouldAutoInstance(agentName));
     },
-    markTaskBlocked: async (taskId, reason) => {
+    markTaskNeedsReview: async (taskId, reason) => {
       try {
-        await updateTask({ taskId, status: "blocked", result: reason });
+        await updateTask({ taskId, status: "needs_review", result: reason });
       } catch {
         const client = getClient();
         await client.execute({
-          sql: `UPDATE tasks SET status = 'blocked', result = ?, updated_at = ? WHERE id = ?`,
+          sql: `UPDATE tasks SET status = 'needs_review', result = ?, updated_at = ? WHERE id = ?`,
           args: [reason, (/* @__PURE__ */ new Date()).toISOString(), taskId]
         });
       }
@@ -1075,37 +1086,207 @@ ${paneContent.slice(0, 500)}` : ""
   };
 }
 var ORPHAN_SIGKILL_DELAY_MS = 5e3;
+var ORPHAN_MAX_AGE_SECS = 120;
 var ORPHAN_PATTERNS = [
   "exe-os/dist/mcp/server.js",
   "exe-mem/dist/mcp/server.js",
   "exe-os/dist/hooks/ingest-worker.js",
   "exe-mem/dist/hooks/ingest-worker.js",
-  // Hook processes that become orphaned (PPID=1) and never get reaped.
-  // These accumulate at ~45MB each and caused 1.2GB+ memory waste (2026-05-29).
+  // Hook processes that become orphaned and never get reaped.
+  // These accumulate at ~70MB each and caused 1GB+ memory waste.
+  "codex-stop-task-finalizer.js",
+  "scan-tasks.js",
+  "exe-pending-reviews.js",
+  "exe-pending-messages.js",
+  "exe-pending-notifications.js"
+];
+var HOOK_PROCESS_PATTERNS = [
   "codex-stop-task-finalizer.js",
   "scan-tasks.js",
   "exe-pending-reviews.js",
   "exe-pending-messages.js",
   "exe-pending-notifications.js"
 ];
+var ZOMBIE_AGENT_MAX_AGE_SECS = 300;
+function reapZombieAgentProcesses(deps) {
+  let liveSessions;
+  try {
+    liveSessions = new Set(deps.listTmuxSessions());
+  } catch {
+    return [];
+  }
+  const lines = deps.listProcesses();
+  const reaped = [];
+  const procMap = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    const match = line.trim().match(/^(\d+)\s+(\d+)\s+(\S+)\s+(.+)$/);
+    if (!match) continue;
+    procMap.set(parseInt(match[1], 10), {
+      ppid: parseInt(match[2], 10),
+      etime: match[3],
+      args: match[4]
+    });
+  }
+  const AGENT_PATTERNS = [
+    /\bclaude\b/,
+    // Claude Code CLI
+    /\bcodex\b/,
+    // OpenAI Codex CLI
+    /\bopencode\b/
+    // OpenCode CLI
+  ];
+  for (const [pid, info] of procMap) {
+    if (pid === deps.selfPid) continue;
+    const isAgent = AGENT_PATTERNS.some((pat) => pat.test(info.args));
+    if (!isAgent) continue;
+    const ageSecs = parseEtime(info.etime);
+    if (ageSecs < ZOMBIE_AGENT_MAX_AGE_SECS) continue;
+    let hasLiveSession = false;
+    let cur = info.ppid;
+    for (let depth = 0; depth < 5; depth++) {
+      const parent = procMap.get(cur);
+      if (!parent) break;
+      cur = parent.ppid;
+    }
+    const wrapperPid = info.ppid;
+    for (const session of liveSessions) {
+      try {
+        const panePids = execSync(
+          `tmux list-panes -t ${JSON.stringify(session)} -F '#{pane_pid}' 2>/dev/null`,
+          { encoding: "utf8", timeout: 3e3 }
+        ).trim().split("\n").map(Number);
+        if (panePids.includes(wrapperPid)) {
+          hasLiveSession = true;
+          break;
+        }
+        let ancestor = wrapperPid;
+        for (let i = 0; i < 3; i++) {
+          const p = procMap.get(ancestor);
+          if (!p) break;
+          if (panePids.includes(p.ppid)) {
+            hasLiveSession = true;
+            break;
+          }
+          ancestor = p.ppid;
+        }
+        if (hasLiveSession) break;
+      } catch {
+      }
+    }
+    if (hasLiveSession) continue;
+    const rssKb = getRssKb(pid);
+    const rssMb = rssKb ? Math.round(rssKb / 1024) : "?";
+    const desc = `PID ${pid} (age=${ageSecs}s, RSS=${rssMb}MB, ${info.args.slice(0, 80)})`;
+    try {
+      deps.killProcess(pid, "SIGTERM");
+    } catch {
+      continue;
+    }
+    reaped.push(desc);
+    process.stderr.write(`[zombie-agent-reaper] Killed ${desc}
+`);
+    if (wrapperPid > 1 && procMap.has(wrapperPid)) {
+      try {
+        deps.killProcess(wrapperPid, "SIGTERM");
+        process.stderr.write(`[zombie-agent-reaper] Killed wrapper PID ${wrapperPid}
+`);
+      } catch {
+      }
+    }
+    deps.scheduleKill(pid, ORPHAN_SIGKILL_DELAY_MS, () => {
+      try {
+        deps.killProcess(pid, "SIGKILL");
+      } catch {
+      }
+    });
+    if (wrapperPid > 1) {
+      deps.scheduleKill(wrapperPid, ORPHAN_SIGKILL_DELAY_MS, () => {
+        try {
+          deps.killProcess(wrapperPid, "SIGKILL");
+        } catch {
+        }
+      });
+    }
+  }
+  return reaped;
+}
+function getRssKb(pid) {
+  try {
+    const out = execSync(`ps -o rss= -p ${pid} 2>/dev/null`, { encoding: "utf8", timeout: 2e3 });
+    const val = parseInt(out.trim(), 10);
+    return isNaN(val) ? null : val;
+  } catch {
+    return null;
+  }
+}
+function createZombieAgentReaperRealDeps() {
+  return {
+    listProcesses: () => {
+      const output = execSync("ps -eo pid,ppid,etime,args", {
+        encoding: "utf8",
+        timeout: 5e3
+      });
+      return output.split("\n");
+    },
+    listTmuxSessions: () => {
+      const output = execSync("tmux list-sessions -F '#{session_name}' 2>/dev/null", {
+        encoding: "utf8",
+        timeout: 3e3
+      });
+      return output.trim().split("\n").filter(Boolean);
+    },
+    killProcess: (pid, signal) => {
+      process.kill(pid, signal);
+    },
+    scheduleKill: (_pid, delayMs, cb) => {
+      setTimeout(() => {
+        try {
+          cb();
+        } catch {
+        }
+      }, delayMs).unref();
+    },
+    selfPid: process.pid
+  };
+}
+function parseEtime(etime) {
+  const trimmed = etime.trim();
+  const dayMatch = trimmed.match(/^(\d+)-(\d+):(\d+):(\d+)$/);
+  if (dayMatch) {
+    return parseInt(dayMatch[1], 10) * 86400 + parseInt(dayMatch[2], 10) * 3600 + parseInt(dayMatch[3], 10) * 60 + parseInt(dayMatch[4], 10);
+  }
+  const parts = trimmed.split(":").map((p) => parseInt(p, 10));
+  if (parts.length === 3) return parts[0] * 3600 + parts[1] * 60 + parts[2];
+  if (parts.length === 2) return parts[0] * 60 + parts[1];
+  if (parts.length === 1) return parts[0];
+  return 0;
+}
 function reapOrphanedMcpProcesses(deps) {
   const lines = deps.listProcesses();
   const reaped = [];
   for (const line of lines) {
     const trimmed = line.trim();
-    const match = trimmed.match(/^(\d+)\s+1\s+(.+)$/);
+    const match = trimmed.match(/^(\d+)\s+(\d+)\s+(\S+)\s+(.+)$/);
     if (!match) continue;
     const pid = parseInt(match[1], 10);
-    const args = match[2];
+    const ppid = parseInt(match[2], 10);
+    const etime = match[3];
+    const args = match[4];
     if (pid === deps.selfPid) continue;
-    if (!ORPHAN_PATTERNS.some((pat) => args.includes(pat))) continue;
+    const isPpid1Orphan = ppid === 1 && ORPHAN_PATTERNS.some((pat) => args.includes(pat));
+    const ageSecs = parseEtime(etime);
+    const isAgedHookOrphan = ageSecs > ORPHAN_MAX_AGE_SECS && HOOK_PROCESS_PATTERNS.some((pat) => args.includes(pat));
+    if (!isPpid1Orphan && !isAgedHookOrphan) continue;
     try {
       deps.killProcess(pid, "SIGTERM");
     } catch {
       continue;
     }
-    const desc = `PID ${pid} (${args.slice(0, 100)})`;
+    const reason = isPpid1Orphan ? "ppid=1" : `age=${ageSecs}s`;
+    const desc = `PID ${pid} (${reason}, ${args.slice(0, 100)})`;
     reaped.push(desc);
+    process.stderr.write(`[orphan-reaper] Killed ${desc}
+`);
     deps.scheduleKill(pid, ORPHAN_SIGKILL_DELAY_MS, () => {
       try {
         deps.killProcess(pid, "SIGKILL");
@@ -1118,7 +1299,7 @@ function reapOrphanedMcpProcesses(deps) {
 function createOrphanReaperRealDeps() {
   return {
     listProcesses: () => {
-      const output = execSync("ps -eo pid,ppid,args", {
+      const output = execSync("ps -eo pid,ppid,etime,args", {
         encoding: "utf8",
         timeout: 5e3
       });
@@ -1138,6 +1319,165 @@ function createOrphanReaperRealDeps() {
     selfPid: process.pid
   };
 }
+var WORKTREE_REAPER_INTERVAL_MS = 30 * 60 * 1e3;
+var WORKTREE_MIN_AGE_MS = 60 * 60 * 1e3;
+var WORKTREE_MAX_PRUNES_PER_TICK = 5;
+async function reapOrphanedWorktrees(deps, nowMs = Date.now()) {
+  const result = { pruned: [], skipped: [] };
+  let sessions;
+  try {
+    sessions = deps.listTmuxSessions();
+  } catch {
+    return result;
+  }
+  const liveAgents = /* @__PURE__ */ new Set();
+  for (const s of sessions) {
+    if (!s.includes("-")) continue;
+    const agentPart = s.split("-")[0];
+    liveAgents.add(baseAgentName(agentPart));
+  }
+  const repoRoots = /* @__PURE__ */ new Set();
+  for (const s of sessions) {
+    const cwd = deps.getPaneCwd(s);
+    if (!cwd) continue;
+    const root = deps.getGitRoot(cwd);
+    if (root) repoRoots.add(root);
+  }
+  for (const repoRoot of repoRoots) {
+    if (result.pruned.length >= WORKTREE_MAX_PRUNES_PER_TICK) break;
+    let worktrees;
+    try {
+      worktrees = deps.listWorktrees(repoRoot);
+    } catch {
+      continue;
+    }
+    for (const wt of worktrees) {
+      if (result.pruned.length >= WORKTREE_MAX_PRUNES_PER_TICK) break;
+      if (!wt.path.includes("/.worktrees/")) continue;
+      const agentName = deps.parseAgentFromWorktreePath(wt.path);
+      if (!agentName) {
+        result.skipped.push({ path: wt.path, reason: "could not parse agent name" });
+        continue;
+      }
+      if (liveAgents.has(agentName)) continue;
+      const mtimeMs = deps.getDirMtimeMs(wt.path);
+      if (mtimeMs === null) continue;
+      const ageMs = nowMs - mtimeMs;
+      if (ageMs < WORKTREE_MIN_AGE_MS) {
+        result.skipped.push({ path: wt.path, reason: `too young (${Math.round(ageMs / 6e4)}m < 60m)` });
+        continue;
+      }
+      if (deps.isWorktreeDirty(wt.path)) {
+        const ageH2 = Math.round(ageMs / 36e5);
+        process.stderr.write(
+          `[worktree-reaper] WARNING: Orphan worktree has uncommitted changes, skipping: ${wt.path} (agent: ${agentName}, age: ${ageH2}h)
+`
+        );
+        result.skipped.push({ path: wt.path, reason: "uncommitted changes" });
+        continue;
+      }
+      const ageH = Math.round(ageMs / 36e5);
+      const removed = deps.removeWorktree(repoRoot, wt.path);
+      if (removed) {
+        deps.deleteBranch(repoRoot, wt.branch);
+        deps.deleteRemoteBranch(repoRoot, wt.branch);
+        process.stderr.write(
+          `[worktree-reaper] Pruned orphan worktree: ${wt.path} (agent: ${agentName}, age: ${ageH}h)
+`
+        );
+        result.pruned.push(wt.path);
+      } else {
+        result.skipped.push({ path: wt.path, reason: "git worktree remove failed" });
+      }
+    }
+  }
+  return result;
+}
+async function createWorktreeReaperRealDeps() {
+  const { getPaneCwd } = await import("./lib/tmux-status.js");
+  const { getGitRoot, isWorktreeDirty: isDirty } = await import("./worktree-OMPQEJH7.js");
+  const { statSync } = await import("fs");
+  const { basename } = await import("path");
+  return {
+    listTmuxSessions: () => listTmuxSessions(),
+    getPaneCwd: (s) => getPaneCwd(s),
+    listWorktrees: (repoRoot) => {
+      try {
+        const out = execSync("git worktree list --porcelain", {
+          cwd: repoRoot,
+          encoding: "utf-8",
+          timeout: 1e4,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        const worktrees = [];
+        let currentPath = "";
+        for (const line of out.split("\n")) {
+          if (line.startsWith("worktree ")) {
+            currentPath = line.slice("worktree ".length);
+          } else if (line.startsWith("branch ") && currentPath) {
+            const branch = line.slice("branch refs/heads/".length);
+            worktrees.push({ path: currentPath, branch });
+            currentPath = "";
+          }
+        }
+        return worktrees;
+      } catch {
+        return [];
+      }
+    },
+    isWorktreeDirty: (wtPath) => isDirty(wtPath),
+    getDirMtimeMs: (dirPath) => {
+      try {
+        return statSync(dirPath).mtimeMs;
+      } catch {
+        return null;
+      }
+    },
+    removeWorktree: (repoRoot, wtPath) => {
+      try {
+        execSync(`git worktree remove ${JSON.stringify(wtPath)} --force`, {
+          cwd: repoRoot,
+          encoding: "utf-8",
+          timeout: 1e4,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    deleteBranch: (repoRoot, branch) => {
+      try {
+        execSync(`git branch -D ${JSON.stringify(branch)}`, {
+          cwd: repoRoot,
+          encoding: "utf-8",
+          timeout: 1e4,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    deleteRemoteBranch: (repoRoot, branch) => {
+      try {
+        execSync(`git push origin --delete ${JSON.stringify(branch)} 2>/dev/null`, {
+          cwd: repoRoot,
+          encoding: "utf-8",
+          timeout: 15e3,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+      } catch {
+      }
+    },
+    parseAgentFromWorktreePath: (wtPath) => {
+      const dirName = basename(wtPath);
+      if (!dirName) return null;
+      return baseAgentName(dirName);
+    },
+    getGitRoot: (dir) => getGitRoot(dir)
+  };
+}
 
 export {
   IDLE_NUDGE_DEDUP_MS,
@@ -1178,7 +1518,14 @@ export {
   pollCoordinatorContextRestart,
   createCoordinatorRestartRealDeps,
   ORPHAN_SIGKILL_DELAY_MS,
+  ORPHAN_MAX_AGE_SECS,
   ORPHAN_PATTERNS,
+  HOOK_PROCESS_PATTERNS,
+  reapZombieAgentProcesses,
+  createZombieAgentReaperRealDeps,
   reapOrphanedMcpProcesses,
-  createOrphanReaperRealDeps
+  createOrphanReaperRealDeps,
+  WORKTREE_REAPER_INTERVAL_MS,
+  reapOrphanedWorktrees,
+  createWorktreeReaperRealDeps
 };

package/dist/{chunk-IJXYCSUR.js → chunk-CUQGNC3J.js}

@@ -1,9 +1,9 @@
 import {
   getActiveAgent
-} from "./chunk-XFA26MHB.js";
+} from "./chunk-5G7BZIY3.js";
 import {
   listTasks
-} from "./chunk-SNTCGJAE.js";
+} from "./chunk-7X7HKWH7.js";
 import {
   getProjectName
 } from "./chunk-OPU3NYOO.js";

package/dist/{chunk-GHB33FOB.js → chunk-D34YDPQA.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-GNHN5HRQ.js";
 import {
   buildClaudeHttpMcpEntry
-} from "./chunk-2TKJQR7H.js";
+} from "./chunk-U2KFQTM5.js";
 import {
   EXE_HOOKS,
   isLegacyHomeDirHookCommand,
@@ -11,7 +11,7 @@ import {
 } from "./chunk-L3TB7CC3.js";
 import {
   ensureAllAgentSymlinks
-} from "./chunk-VKCFXOWQ.js";
+} from "./chunk-2UO3QD7V.js";
 import {
   MCP_LEGACY_KEY,
   MCP_PRIMARY_KEY

package/dist/{chunk-5HVWTVZI.js → chunk-DIRYKGUR.js}

@@ -1,9 +1,9 @@
 import {
   updateTask
-} from "./chunk-F6LDN5XB.js";
+} from "./chunk-MPCICOVG.js";
 import {
   TASK_ALREADY_CLAIMED_PREFIX
-} from "./chunk-SNTCGJAE.js";
+} from "./chunk-7X7HKWH7.js";
 
 // src/mcp/tools/update-task.ts
 import { z } from "zod";
@@ -23,7 +23,7 @@ function registerUpdateTask(server) {
       const status = rawStatus;
       let callerAgentId;
       try {
-        const { getActiveAgent: getAgent } = await import("./active-agent-XAA2YRRH.js");
+        const { getActiveAgent: getAgent } = await import("./active-agent-SLC7NBGT.js");
         callerAgentId = getAgent().agentId;
       } catch {
       }

package/dist/{chunk-CCOSYMVU.js → chunk-DQMGSEAJ.js}

@@ -1,7 +1,7 @@
 import {
   clean,
   stableId
-} from "./chunk-PJI6UVFG.js";
+} from "./chunk-6IUZZMWD.js";
 
 // src/lib/reflection-checkpoints.ts
 function parsePayload(payload) {

package/dist/{chunk-PZWRXJBJ.js → chunk-E7HUZQ4W.js}

@@ -1,6 +1,6 @@
 import {
   createReminder
-} from "./chunk-SZERVMKQ.js";
+} from "./chunk-ODN7E7HJ.js";
 
 // src/mcp/tools/create-reminder.ts
 import { z } from "zod";

package/dist/{chunk-TLTQGQCX.js → chunk-FEP36D2I.js}

@@ -1,6 +1,6 @@
 import {
   listReminders
-} from "./chunk-SZERVMKQ.js";
+} from "./chunk-ODN7E7HJ.js";
 
 // src/mcp/tools/list-reminders.ts
 import { z } from "zod";

package/dist/{chunk-BOAP6EJD.js → chunk-FPBEJ2JV.js}

@@ -3,10 +3,10 @@ import {
   buildRawVisibilityFilter,
   buildWikiScopeFilter,
   searchMemories
-} from "./chunk-CSTCUDVM.js";
+} from "./chunk-H3KFLVPW.js";
 import {
   getClient
-} from "./chunk-JTS3IDOY.js";
+} from "./chunk-JYETM4KT.js";
 
 // src/lib/hybrid-search.ts
 var RRF_K = 60;
@@ -205,7 +205,7 @@ async function hybridSearch(queryText, agentId, options) {
     queryVector ? searchMemories(queryVector, agentId, fetchOptions) : Promise.resolve([]),
     includeStructuredCards ? (async () => {
       try {
-        const { searchMemoryCards } = await import("./memory-cards-B6I5ZGXM.js");
+        const { searchMemoryCards } = await import("./memory-cards-MRF3JHTD.js");
         return await searchMemoryCards(effectiveQuery, agentId, fetchOptions);
       } catch {
         return [];
@@ -214,7 +214,7 @@ async function hybridSearch(queryText, agentId, options) {
     // Reflection insights: patterns, contradictions, summaries across sessions
     includeStructuredCards ? (async () => {
       try {
-        const { searchReflections } = await import("./memory-reflection-B75N4BRO.js");
+        const { searchReflections } = await import("./memory-reflection-6QCSB2MQ.js");
         const insights = await searchReflections(effectiveQuery, agentId, 5);
         return insights.map((ins) => ({
           id: ins.id,
@@ -268,7 +268,7 @@ async function hybridSearch(queryText, agentId, options) {
   let entityBoostRan = false;
   if (merged.length > 0) {
     try {
-      const { applyEntityBoost } = await import("./entity-boost-B7IGG24X.js");
+      const { applyEntityBoost } = await import("./entity-boost-GHFPE6A2.js");
       const boosted = await applyEntityBoost(merged, effectiveQuery, getClient());
       merged = boosted.results;
       graphContextMap = boosted.graphContext;
@@ -608,7 +608,7 @@ async function lightweightSearch(queryText, agentId, options) {
   }
   if (options?.includeStructuredCards !== true) return results;
   try {
-    const { searchMemoryCards } = await import("./memory-cards-B6I5ZGXM.js");
+    const { searchMemoryCards } = await import("./memory-cards-MRF3JHTD.js");
     const cardResults = await searchMemoryCards(queryText, agentId, options);
     if (cardResults.length > 0) {
       return rrfMergeMulti([results, cardResults], limit, RRF_K, [1, 0.85]);

package/dist/{chunk-COUXA2IQ.js → chunk-FRH7EY2Z.js}

@@ -1,6 +1,6 @@
 import {
   getClient
-} from "./chunk-JTS3IDOY.js";
+} from "./chunk-JYETM4KT.js";
 
 // src/lib/session-kill-telemetry.ts
 import crypto from "crypto";