@askexenow/exe-os 0.9.374 → 0.9.376

package/dist/{chunk-KI5PFRG6.js → chunk-ZKGWHT56.js}

@@ -63,7 +63,17 @@ async function runBudgetedSweep(items, processItem, options = {}) {
 `
       );
       recordTimerPauseMs(rescheduleDelayMs);
-      await sleep(rescheduleDelayMs);
+      const pauseTimer = _timerPauseContext.getStore();
+      const pauseStartWallMs = Date.now();
+      if (pauseTimer) beginTimerPause(pauseTimer, pauseStartWallMs);
+      try {
+        await sleep(rescheduleDelayMs);
+      } finally {
+        if (pauseTimer) {
+          endTimerPause(pauseTimer);
+          recordTimerPauseInterval(pauseTimer, pauseStartWallMs, Date.now());
+        }
+      }
     }
   }
   return result;
@@ -86,6 +96,51 @@ function sweepPauseTotalMs(timer) {
   if (timer) return _pauseMsByTimer.get(timer) ?? 0;
   return _totalPauseMs;
 }
+var MAX_TRACKED_INTERVALS_PER_TIMER = 32;
+var _pauseIntervalsByTimer = /* @__PURE__ */ new Map();
+var _pausedNowByTimer = /* @__PURE__ */ new Map();
+var _activePauseStartsByTimer = /* @__PURE__ */ new Map();
+function beginTimerPause(timer, startMs) {
+  _pausedNowByTimer.set(timer, (_pausedNowByTimer.get(timer) ?? 0) + 1);
+  const stack = _activePauseStartsByTimer.get(timer);
+  if (stack) stack.push(startMs);
+  else _activePauseStartsByTimer.set(timer, [startMs]);
+}
+function endTimerPause(timer) {
+  const n = (_pausedNowByTimer.get(timer) ?? 1) - 1;
+  if (n <= 0) _pausedNowByTimer.delete(timer);
+  else _pausedNowByTimer.set(timer, n);
+  const stack = _activePauseStartsByTimer.get(timer);
+  if (stack) {
+    stack.pop();
+    if (stack.length === 0) _activePauseStartsByTimer.delete(timer);
+  }
+}
+function isTimerPausedNow(timer) {
+  return (_pausedNowByTimer.get(timer) ?? 0) > 0;
+}
+function currentPauseStartMs(timer) {
+  const stack = _activePauseStartsByTimer.get(timer);
+  if (!stack || stack.length === 0) return null;
+  return stack[0] ?? null;
+}
+function recordTimerPauseInterval(timer, startMs, endMs) {
+  if (!Number.isFinite(startMs) || !Number.isFinite(endMs) || endMs < startMs) return;
+  let list = _pauseIntervalsByTimer.get(timer);
+  if (!list) {
+    list = [];
+    _pauseIntervalsByTimer.set(timer, list);
+  }
+  list.push({ startMs, endMs });
+  if (list.length > MAX_TRACKED_INTERVALS_PER_TIMER) {
+    list.splice(0, list.length - MAX_TRACKED_INTERVALS_PER_TIMER);
+  }
+}
+function timerPauseIntervalsSince(timer, sinceMs) {
+  const list = _pauseIntervalsByTimer.get(timer);
+  if (!list) return [];
+  return list.filter((iv) => iv.startMs >= sinceMs);
+}
 
 export {
   DEFAULT_SWEEP_BUDGET_MS,
@@ -95,5 +150,8 @@ export {
   runBudgetedSweep,
   runWithTimerPauseAccounting,
   recordTimerPauseMs,
-  sweepPauseTotalMs
+  sweepPauseTotalMs,
+  isTimerPausedNow,
+  currentPauseStartMs,
+  timerPauseIntervalsSince
 };

package/dist/{chunk-NUK7EEN5.js → chunk-ZKJ5S23O.js}

@@ -1,17 +1,21 @@
+import {
+  ensureDaemonToken,
+  readDaemonToken
+} from "./chunk-GPUOUUHA.js";
 import {
   SUPERVISED_ENV
 } from "./chunk-ZG62LIK3.js";
 import {
-  ensureDaemonToken,
-  readDaemonToken
-} from "./chunk-EKYYMIVT.js";
+  sanitizeDaemonKeyCustodyEnv
+} from "./chunk-IMYGYIAI.js";
 import {
   computeDaemonHeapCapMb
 } from "./chunk-NLEW62VC.js";
 import {
   killIfSameProcess,
-  processStartedAt
-} from "./chunk-SLLLOOEI.js";
+  processStartedAt,
+  sameProcessIdentity
+} from "./chunk-GPJIBLP4.js";
 import {
   KILL_INTENT_LOOKBACK_MS,
   findRecentKillIntent,
@@ -197,11 +201,15 @@ function isDaemonTooYoung() {
 var RESTART_INTENT_WINDOW_MS = 3e4;
 var RESTART_INTENT_REASON_MAX_AGE_MS = 6e4;
 var RESTART_INTENT_MAX_AGE_MS = 5 * 6e4;
-function formatRestartIntentMarker(reason, nowMs = Date.now()) {
+function formatRestartIntentMarker(reason, nowMs = Date.now(), target) {
   const marker = {
     reason,
     nonce: randomUUID(),
-    createdAt: new Date(nowMs).toISOString()
+    createdAt: new Date(nowMs).toISOString(),
+    ...target ? {
+      targetPid: target.pid,
+      ...target.startedAt !== void 0 ? { targetStartedAt: target.startedAt } : {}
+    } : {}
   };
   return JSON.stringify(marker);
 }
@@ -227,9 +235,11 @@ function parseRestartIntentMarker(raw, nowMs = Date.now(), maxAgeMs = RESTART_IN
   const intent = isRestartIntentTimestampFresh(isNaN(last) ? null : last, nowMs);
   return { intent, reason: intent ? "legacy-timestamp-marker" : null, stale: false };
 }
-function writeRestartIntent(reason) {
+function writeRestartIntent(reason, targetPid = readDaemonPid()) {
   try {
-    writeFileSync(restartMarkerPath(), formatRestartIntentMarker(reason));
+    const startedAt = targetPid === null ? null : processStartedAt(targetPid);
+    const target = targetPid === null ? void 0 : { pid: targetPid, ...startedAt !== null ? { startedAt } : {} };
+    writeFileSync(restartMarkerPath(), formatRestartIntentMarker(reason, Date.now(), target));
   } catch {
   }
 }
@@ -243,15 +253,24 @@ function isRestartIntentTimestampFresh(markerTimestampMs, nowMs = Date.now()) {
   if (markerTimestampMs === null || !Number.isFinite(markerTimestampMs)) return false;
   return nowMs - markerTimestampMs < RESTART_INTENT_WINDOW_MS;
 }
-function consumeRestartIntentDetail() {
+function consumeRestartIntentDetail(preserveFor) {
   try {
     if (!existsSync(restartMarkerPath())) return { intent: false, reason: null };
     const raw = readFileSync(restartMarkerPath(), "utf8");
+    const parsed = parseRestartIntentMarker(raw);
+    if (parsed.intent && preserveFor) {
+      try {
+        const marker = JSON.parse(raw);
+        if (marker.targetPid === preserveFor.pid && (typeof marker.targetStartedAt === "number" ? typeof preserveFor.startedAt === "number" && sameProcessIdentity(marker.targetStartedAt, preserveFor.startedAt) : typeof marker.createdAt === "string" && typeof preserveFor.startedAt === "number" && Date.parse(marker.createdAt) >= preserveFor.startedAt)) {
+          return { intent: false, reason: null };
+        }
+      } catch {
+      }
+    }
     try {
       unlinkSync(restartMarkerPath());
     } catch {
     }
-    const parsed = parseRestartIntentMarker(raw);
     if (parsed.stale) {
       logRestart({
         event: "restart_intent_stale",
@@ -409,7 +428,7 @@ function requestRestart(reason, opts) {
       return { ok: false, skipped: msg };
     }
     try {
-      writeRestartIntent(reason);
+      writeRestartIntent(reason, pid);
     } catch {
     }
     noteRestartAttempt();
@@ -531,7 +550,7 @@ async function requestDeployRestart(reason, opts) {
       return { ok: false, skipped: msg };
     }
     try {
-      writeRestartIntent(deployReason);
+      writeRestartIntent(deployReason, pid);
     } catch {
     }
     noteRestartAttempt();
@@ -737,6 +756,7 @@ function findPackageRoot() {
 var HEAP_FLAG_RE = /^(--max-old-space-size=|--max_old_space_size=)/;
 function sanitizeInheritedDaemonEnv(env) {
   delete env.EXE_EMBEDDINGS;
+  sanitizeDaemonKeyCustodyEnv(env);
   delete env[SUPERVISED_ENV];
   if (env.NODE_OPTIONS) {
     const cleaned = env.NODE_OPTIONS.split(/\s+/).filter((tok) => tok && !HEAP_FLAG_RE.test(tok)).join(" ");

package/dist/chunk-ZLPS3GR7.js

@@ -0,0 +1,146 @@
+// src/lib/daemon-starvation.ts
+function isHostCpuStarved(load1m, cpuCount, ratio) {
+  if (!Number.isFinite(ratio) || ratio <= 0) return false;
+  if (!Number.isFinite(load1m) || load1m <= 0) return false;
+  const cores = Number.isFinite(cpuCount) && cpuCount > 0 ? cpuCount : 1;
+  return load1m > cores * ratio;
+}
+function pruneLoadSamples(samples, keepSinceMs) {
+  return samples.filter((sample) => Number.isFinite(sample.ts) && sample.ts >= keepSinceMs);
+}
+function maxLoadOverWindow(samples, windowStartMs, currentLoad1m) {
+  const candidates = [currentLoad1m];
+  for (const sample of samples) {
+    if (sample.ts >= windowStartMs && Number.isFinite(sample.load1m)) {
+      candidates.push(sample.load1m);
+    }
+  }
+  const finite = candidates.filter((load) => Number.isFinite(load));
+  return finite.length > 0 ? Math.max(...finite) : currentLoad1m;
+}
+function updateLoadWindow(samples, nowMs, load1m, wallElapsedMs, keepMs) {
+  const blockStartMs = nowMs - wallElapsedMs - 2500;
+  const next = pruneLoadSamples(
+    [...samples, { ts: nowMs, load1m }],
+    Math.min(nowMs - keepMs, blockStartMs)
+  );
+  return {
+    samples: next,
+    maxLoad1mOverWindow: maxLoadOverWindow(next, blockStartMs, load1m),
+    blockStartMs
+  };
+}
+function decideDaemonSelfHeal(s) {
+  const alive = s.processAlive ?? true;
+  if (!alive) {
+    return { restart: true, reason: "process_dead", consecutiveSevereAfter: 0, selfInflictedWindowAfter: [], selfInflictedStreakAfter: 0, selfInflictedSuppressedMsAfter: 0 };
+  }
+  if (typeof s.rssBytes === "number" && Number.isFinite(s.rssBytes) && typeof s.rssCapBytes === "number" && Number.isFinite(s.rssCapBytes) && s.rssCapBytes > 0 && s.rssBytes > s.rssCapBytes) {
+    return { restart: true, reason: "rss_over_cap", consecutiveSevereAfter: 0, selfInflictedWindowAfter: [], selfInflictedStreakAfter: 0, selfInflictedSuppressedMsAfter: 0 };
+  }
+  const now = typeof s.nowMs === "number" && Number.isFinite(s.nowMs) ? s.nowMs : 0;
+  const windowMs = typeof s.selfInflictedRollingWindowMs === "number" && s.selfInflictedRollingWindowMs > 0 ? s.selfInflictedRollingWindowMs : 3e5;
+  const prunedWindow = (s.selfInflictedWindow ?? []).filter((e) => now - e.ts < windowMs);
+  const sumOf = (w) => w.reduce((a, e) => a + e.lagMs, 0);
+  const carry = {
+    selfInflictedWindowAfter: prunedWindow,
+    selfInflictedStreakAfter: prunedWindow.length,
+    selfInflictedSuppressedMsAfter: sumOf(prunedWindow)
+  };
+  const cleared = { selfInflictedWindowAfter: [], selfInflictedStreakAfter: 0, selfInflictedSuppressedMsAfter: 0 };
+  const loadCandidates = [s.load1m, s.maxLoad1mOverWindow].filter(
+    (load) => typeof load === "number" && Number.isFinite(load) && load > 0
+  );
+  const effectiveLoad1m = loadCandidates.length > 0 ? Math.max(...loadCandidates) : s.load1m;
+  if (isHostCpuStarved(effectiveLoad1m, s.cpuCount, s.starvationRatio)) {
+    return { restart: false, reason: "starved_backoff", consecutiveSevereAfter: 0, ...carry };
+  }
+  if (s.catchUpActive) {
+    return { restart: false, reason: "catchup_backoff", consecutiveSevereAfter: 0, ...carry };
+  }
+  const selfCpuRatio = Number.isFinite(s.selfCpuBusyRatio) ? s.selfCpuBusyRatio : 0.5;
+  if (s.lagMs > s.severeThresholdMs && typeof s.selfCpuBusyFraction === "number" && Number.isFinite(s.selfCpuBusyFraction) && s.selfCpuBusyFraction >= selfCpuRatio) {
+    const countLimit = typeof s.selfInflictedLimit === "number" && s.selfInflictedLimit > 0 ? s.selfInflictedLimit : 5;
+    const suppressCapMs = typeof s.selfInflictedSuppressCapMs === "number" && s.selfInflictedSuppressCapMs > 0 ? s.selfInflictedSuppressCapMs : 15e4;
+    const windowAfter = [...prunedWindow, { ts: now, lagMs: s.lagMs }];
+    const sumInWindow = sumOf(windowAfter);
+    if (sumInWindow > suppressCapMs || windowAfter.length >= countLimit) {
+      return { restart: true, reason: "single_block", consecutiveSevereAfter: 0, ...cleared };
+    }
+    return {
+      restart: false,
+      reason: "self_inflicted_backoff",
+      consecutiveSevereAfter: 0,
+      selfInflictedWindowAfter: windowAfter,
+      selfInflictedStreakAfter: windowAfter.length,
+      selfInflictedSuppressedMsAfter: sumInWindow
+    };
+  }
+  if (s.lagMs > s.singleBlockMs) {
+    return { restart: true, reason: "single_block", consecutiveSevereAfter: 0, ...cleared };
+  }
+  if (s.lagMs > s.severeThresholdMs) {
+    const next = s.consecutiveSevere + 1;
+    if (next >= s.consecutiveLimit) {
+      return { restart: true, reason: "consecutive_blocks", consecutiveSevereAfter: next, ...cleared };
+    }
+    return { restart: false, reason: "counting", consecutiveSevereAfter: next, ...carry };
+  }
+  return { restart: false, reason: "not_critical", consecutiveSevereAfter: 0, ...carry };
+}
+function decideStarvationDrainGuard(s) {
+  const drainWindowMs = typeof s.drainWindowMs === "number" && s.drainWindowMs > 0 ? s.drainWindowMs : 6e5;
+  const graceWindowMs = typeof s.graceWindowMs === "number" && s.graceWindowMs > 0 ? s.graceWindowMs : 18e5;
+  const minGraceMs = typeof s.minGraceMs === "number" && s.minGraceMs > 0 ? s.minGraceMs : 18e4;
+  if (s.lastSuppressedAgoMs === null || !Number.isFinite(s.lastSuppressedAgoMs)) {
+    return { deferKill: false, minSigtermGraceMs: 0, reason: "never_starved" };
+  }
+  const agoMs = Math.max(0, s.lastSuppressedAgoMs);
+  if (agoMs < drainWindowMs) {
+    return { deferKill: true, minSigtermGraceMs: minGraceMs, reason: "drain_window" };
+  }
+  if (agoMs < graceWindowMs) {
+    return { deferKill: false, minSigtermGraceMs: minGraceMs, reason: "grace_window" };
+  }
+  return { deferKill: false, minSigtermGraceMs: 0, reason: "no_recent_starvation" };
+}
+function decideOrchestrationTickSkip(s) {
+  if (isHostCpuStarved(s.load1m, s.cpuCount, s.starvationRatio)) {
+    return { skip: true, reason: "starved_skip" };
+  }
+  return { skip: false, reason: "run" };
+}
+function decideBootBackoff(s) {
+  if (!isHostCpuStarved(s.load1m, s.cpuCount, s.starvationRatio)) {
+    return { wait: false, delayMs: 0, reason: "not_starved" };
+  }
+  const clientsWaiting = s.clientsWaiting === true;
+  const baseDelayMs = clientsWaiting ? s.baseDelayMs / 2 : s.baseDelayMs;
+  const maxDelayMs = clientsWaiting ? s.maxDelayMs / 2 : s.maxDelayMs;
+  const maxAttempts = clientsWaiting ? Math.min(s.maxAttempts, 2) : s.maxAttempts;
+  if (s.attempt >= maxAttempts) {
+    return { wait: false, delayMs: 0, reason: "max_attempts_proceed" };
+  }
+  const base = Number.isFinite(baseDelayMs) && baseDelayMs > 0 ? baseDelayMs : 0;
+  const cap = Number.isFinite(maxDelayMs) && maxDelayMs > 0 ? maxDelayMs : base;
+  const exp = base * Math.pow(2, Math.max(0, s.attempt));
+  const delayMs = Math.min(cap, exp);
+  return { wait: true, delayMs, reason: "backoff" };
+}
+function computeBootRetryAfterSeconds(nowMs, readyEtaMs, opts = {}) {
+  const defaultS = opts.defaultS ?? 3;
+  if (readyEtaMs === null) return defaultS;
+  const minS = opts.minS ?? 1;
+  const maxS = opts.maxS ?? 60;
+  return Math.min(maxS, Math.max(minS, Math.ceil((readyEtaMs - nowMs) / 1e3)));
+}
+
+export {
+  isHostCpuStarved,
+  updateLoadWindow,
+  decideDaemonSelfHeal,
+  decideStarvationDrainGuard,
+  decideOrchestrationTickSkip,
+  decideBootBackoff,
+  computeBootRetryAfterSeconds
+};

package/dist/{chunk-XH7YL7JM.js → chunk-ZMX22HSS.js}

@@ -1,6 +1,6 @@
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-W75GTHR3.js";
+} from "./chunk-3SRZNJKD.js";
 import {
   atomicWriteJsonSync
 } from "./chunk-HSGBZSCA.js";
@@ -262,10 +262,12 @@ function cleanupDeadSessions(liveTmuxOverride) {
     for (const s of sessions) {
       const tmuxAlive = liveTmux.has(s.windowName);
       let pidAlive = false;
-      try {
-        process.kill(s.pid, 0);
-        pidAlive = true;
-      } catch {
+      if (s.pid != null && s.pid > 0) {
+        try {
+          process.kill(s.pid, 0);
+          pidAlive = true;
+        } catch {
+        }
       }
       if (tmuxAlive || pidAlive) {
         alive.push(s);
@@ -344,6 +346,46 @@ function reapOrphanedCoordinatorSessions(deps) {
   }
   return result;
 }
+function reconcileCoordinatorRegistration(callerSession, deps) {
+  const raw = String(callerSession ?? "").trim();
+  if (!raw) return { reconciled: false, entry: null, reason: "no_caller_session" };
+  const coordName = raw.includes("-") ? raw.slice(raw.indexOf("-") + 1) : raw;
+  if (!coordName) return { reconciled: false, entry: null, reason: "no_coord_name" };
+  const live = (deps.liveTmux ?? []).filter(Boolean);
+  if (live.length === 0) return { reconciled: false, entry: null, reason: "no_live_tmux" };
+  if (!isCoordinatorRootName(coordName)) return { reconciled: false, entry: null, reason: "not_coordinator_root" };
+  if (!new Set(live).has(coordName)) return { reconciled: false, entry: null, reason: "coord_not_live" };
+  const existing = readSessionsUncached().find((s) => s.windowName === coordName) ?? null;
+  if (existing?.projectDir && existsSync(existing.projectDir)) {
+    return { reconciled: false, entry: existing, reason: "already_registered" };
+  }
+  const cwd = String(deps.paneCwdOf(coordName) ?? "").trim();
+  if (!cwd || !existsSync(cwd)) return { reconciled: false, entry: null, reason: "no_live_cwd" };
+  const panePid = deps.panePidOf?.(coordName);
+  const pid = panePid != null ? panePid : existing?.pid ?? null;
+  const coordinatorAgentId = getCoordinatorNameCached();
+  const entry = {
+    windowName: coordName,
+    // Registry identity is the configured roster identity; only windowName
+    // carries the numbered coordinator instance. Consumers match agentId to the
+    // authenticated roster identity when recovering an MCP session.
+    agentId: coordinatorAgentId,
+    projectDir: cwd,
+    parentExe: null,
+    pid,
+    registeredAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  registerSession(entry);
+  recordOrchestrationEventBestEffort({
+    eventType: "registry.coordinator_reconciled",
+    source: "session-registry.reconcileCoordinatorRegistration",
+    severity: "warn",
+    agentId: coordinatorAgentId,
+    tmuxSession: coordName,
+    payload: { projectDir: cwd, drifted: Boolean(existing) }
+  });
+  return { reconciled: true, entry, reason: existing ? "drift_repaired" : "registered_missing" };
+}
 function looksLikeExeOsSession(sessionName) {
   const coordName = getCoordinatorNameCached();
   const escaped = coordName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -373,5 +415,7 @@ export {
   checkSessionRegistryConsistency,
   deregisterSession,
   cleanupDeadSessions,
-  reapOrphanedCoordinatorSessions
+  reapOrphanedCoordinatorSessions,
+  reconcileCoordinatorRegistration,
+  getCoordinatorNameCached
 };

package/dist/{chunk-JY5GAZYC.js → chunk-ZQEJ4IX2.js}

@@ -11,6 +11,9 @@ function daemonReadyPath() {
 function eventLoopBlockedMarkerPath() {
   return join(exeDir(), "session-cache", "event-loop-blocked.marker");
 }
+function starvationSuppressedMarkerPath() {
+  return join(exeDir(), "session-cache", "starvation-suppressed.marker");
+}
 function eventLoopHeartbeatPath() {
   return join(exeDir(), "session-cache", "event-loop-heartbeat");
 }
@@ -63,6 +66,7 @@ export {
   exeDir,
   daemonReadyPath,
   eventLoopBlockedMarkerPath,
+  starvationSuppressedMarkerPath,
   eventLoopHeartbeatPath,
   setDaemonReadyGeneration,
   writeDaemonReady,

package/dist/{chunk-R4CBHKZ2.js → chunk-ZS5JO6QV.js}

@@ -1,6 +1,6 @@
 import {
   getGlobalProceduresBlock
-} from "./chunk-EXTZSNWL.js";
+} from "./chunk-EPHSISMT.js";
 
 // src/lib/employee-templates.ts
 var BASE_OPERATING_PROCEDURES = `
@@ -111,12 +111,13 @@ DELEGATING WORK \u2014 the dispatch ladder (stop at the lowest rung that fits):
    throwaway exploration. Cap 2-3 concurrent. MANDATORY: persist the subagent's
    results and lessons into the task record + memory BEFORE you finish \u2014 subagent
    output must never die in a context window.
-3. create_task -> tmux employee \u2014 LEGACY. Reserved for work that must outlive your
-   session or cross sessions/projects. Gets no new investment.
+3. create_task(execution_mode='durable_tmux') -> tmux employee \u2014 LEGACY. Reserved
+   for work that must outlive your session or cross sessions/projects. Omitted or
+   default mode is checklist-only and never launches compute.
 
 WHEN RUNG 3 IS RIGHT (mandatory \u2014 never bypass):
-create_task is the ONLY tmux dispatch path. It auto-spawns the session; the task IS
-the spawn trigger.
+Explicit execution_mode='durable_tmux' is the ONLY tmux dispatch path. It
+auto-spawns the session; default checklist creation has no execution side effects.
 NEVER manually launch sessions with tmux send-keys or claude -p \u2014 this is still
 absolutely forbidden. Choosing rung 2 does not license manual spawns.
 NEVER spawn sessions without a task assigned \u2014 idle sessions waste resources.
@@ -124,7 +125,7 @@ NEVER refuse a dispatched task claiming "not in scope" \u2014 if it's assigned t
 
 CREATING TASKS FOR OTHER EMPLOYEES:
 When rung 3 applies and you assign work to another employee (e.g., CTO to an engineer):
-- ALWAYS use create_task MCP tool. NEVER write .md files directly to exe/{name}/.
+- ALWAYS use create_task with execution_mode='durable_tmux'. NEVER write .md files directly to exe/{name}/.
 - Direct .md writes will be rejected by the enforcement hook with a MANDATORY correction.
 - create_task creates both the .md file AND the DB row atomically.
 - Include: title, assignedTo, priority, context, projectName.

package/dist/{cleanup-graph-garbage-DPJGO52H.js → cleanup-graph-garbage-LAPIZGFX.js}

@@ -1,31 +1,31 @@
 #!/usr/bin/env node
-import "./chunk-LGS2V2XD.js";
+import "./chunk-FUKVP54K.js";
 import {
   isGarbageEntity
-} from "./chunk-ULIBLJ6W.js";
-import "./chunk-GUMRIUI5.js";
+} from "./chunk-YYC553FO.js";
 import "./chunk-Z6BZQHP5.js";
+import "./chunk-GUMRIUI5.js";
 import "./chunk-VGMACSEV.js";
-import "./chunk-VZAFWPAY.js";
+import "./chunk-IK4344V5.js";
 import "./chunk-CHCA3ZM2.js";
-import "./chunk-DN4YVV4Z.js";
+import "./chunk-RSABKW6B.js";
 import {
   fastDbInit
-} from "./chunk-M4IRPXSZ.js";
+} from "./chunk-IZA7XW2Q.js";
 import "./chunk-5MOYSU5A.js";
-import "./chunk-4QCFFW2H.js";
+import "./chunk-5QCIWWFA.js";
 import "./chunk-76CJBM36.js";
 import {
   getClient
-} from "./chunk-TAMDAOCU.js";
+} from "./chunk-66CGXQUA.js";
 import "./chunk-BBMTVAE3.js";
 import "./chunk-TKDITWDN.js";
 import "./chunk-5YEUPUV4.js";
-import "./chunk-DSJI76XL.js";
+import "./chunk-AHNVFBVB.js";
 import "./chunk-YYB5PMTK.js";
-import "./chunk-NJFJWQNN.js";
-import "./chunk-V3W3SATA.js";
-import "./chunk-JY5GAZYC.js";
+import "./chunk-L5CGXEZC.js";
+import "./chunk-CL4J4757.js";
+import "./chunk-ZQEJ4IX2.js";
 import "./chunk-FXU7JOXK.js";
 import "./chunk-ZIG7VPJV.js";
 import "./chunk-HSGBZSCA.js";

package/dist/{cloud-sync-command-JPNTT4OQ.js → cloud-sync-command-QAZ2NWRA.js}

@@ -23,7 +23,7 @@ async function runCloudSyncCli() {
   const { getMasterKey } = await import("./lib/keychain.js");
   const { initSyncCrypto } = await import("./lib/crypto.js");
   const { assertCloudSyncReachable, withTimeout } = await import("./bin/exe-cloud.js");
-  const { runCloudSyncShutdown } = await import("./cloud-sync-shutdown-BNALPWGX.js");
+  const { runCloudSyncShutdown } = await import("./cloud-sync-shutdown-DAEPCFVK.js");
   const { disconnectClient } = await import("./lib/exe-daemon-client.js");
   let shuttingDown = false;
   const handleShutdown = (signal) => {
@@ -48,7 +48,7 @@ async function runCloudSyncCli() {
         const { initPostgresOnlyDatabase } = await import("./lib/database.js");
         await initPostgresOnlyDatabase();
       } else {
-        const { initCloudSyncDatabase } = await import("./cloud-sync-db-init-V2LWIUQU.js");
+        const { initCloudSyncDatabase } = await import("./cloud-sync-db-init-HAGVF32Y.js");
         await initCloudSyncDatabase();
       }
       const masterKey = await getMasterKey();
@@ -71,12 +71,21 @@ async function runCloudSyncCli() {
       console.log(`  Documents:      ${result.documents.pushed} total  (\u2193 ${result.documents.pulled} pulled)`);
       console.log(`  GraphRAG:       ${result.graphrag.pushed} entities`);
       const elapsedDisplay = result.elapsedMs != null ? `${(result.elapsedMs / 1e3).toFixed(1)}s` : "n/a";
+      const memoryPushFailed = (result.memoryPushErrors ?? 0) > 0;
+      const pendingMemories = result.pendingMemories ?? 0;
       if (result.deferred) {
         console.log(
           `
 \x1B[33mSync paused after a bounded memory slice \u2014 memories are still queued.\x1B[0m (${elapsedDisplay})
 Run it again (or let the background sync continue) until it reports complete.`
         );
+      } else if (memoryPushFailed) {
+        console.log(
+          `
+\x1B[33mSync did NOT complete \u2014 ${pendingMemories.toLocaleString()} memor${pendingMemories === 1 ? "y" : "ies"} could not be pushed and remain queued locally. (${elapsedDisplay})
+The memory push failed (network error or version conflict). Run it again until it reports complete.\x1B[0m`
+        );
+        exitCode = 1;
       } else {
         console.log(`
 \x1B[32mSync complete.\x1B[0m (${elapsedDisplay})`);

package/dist/{cloud-sync-db-init-V2LWIUQU.js → cloud-sync-db-init-HAGVF32Y.js}

@@ -1,7 +1,7 @@
 import {
   fastDbInit,
   isNoopFastDbClient
-} from "./chunk-M4IRPXSZ.js";
+} from "./chunk-IZA7XW2Q.js";
 import "./chunk-MLKGABMK.js";
 
 // src/lib/cloud-sync-db-init.ts

package/dist/{cloud-sync-shutdown-BNALPWGX.js → cloud-sync-shutdown-DAEPCFVK.js}

@@ -1,14 +1,14 @@
 import {
   releaseDbLock
-} from "./chunk-TAMDAOCU.js";
+} from "./chunk-66CGXQUA.js";
 import "./chunk-BBMTVAE3.js";
 import "./chunk-TKDITWDN.js";
 import "./chunk-5YEUPUV4.js";
-import "./chunk-DSJI76XL.js";
+import "./chunk-AHNVFBVB.js";
 import "./chunk-YYB5PMTK.js";
-import "./chunk-NJFJWQNN.js";
-import "./chunk-V3W3SATA.js";
-import "./chunk-JY5GAZYC.js";
+import "./chunk-L5CGXEZC.js";
+import "./chunk-CL4J4757.js";
+import "./chunk-ZQEJ4IX2.js";
 import "./chunk-FXU7JOXK.js";
 import "./chunk-ZIG7VPJV.js";
 import "./chunk-HSGBZSCA.js";

package/dist/{co-activation-CMNSWS6B.js → co-activation-523TKQPZ.js}

@@ -1,14 +1,14 @@
 import {
   getClient
-} from "./chunk-TAMDAOCU.js";
+} from "./chunk-66CGXQUA.js";
 import "./chunk-BBMTVAE3.js";
 import "./chunk-TKDITWDN.js";
 import "./chunk-5YEUPUV4.js";
-import "./chunk-DSJI76XL.js";
+import "./chunk-AHNVFBVB.js";
 import "./chunk-YYB5PMTK.js";
-import "./chunk-NJFJWQNN.js";
-import "./chunk-V3W3SATA.js";
-import "./chunk-JY5GAZYC.js";
+import "./chunk-L5CGXEZC.js";
+import "./chunk-CL4J4757.js";
+import "./chunk-ZQEJ4IX2.js";
 import "./chunk-FXU7JOXK.js";
 import "./chunk-ZIG7VPJV.js";
 import "./chunk-HSGBZSCA.js";