@askexenow/exe-os 0.9.341 → 0.9.342

package/dist/chunk-MVYB76QG.js

@@ -0,0 +1,341 @@
+// src/lib/daemon-timer-report.ts
+import { existsSync, readFileSync, statSync, openSync, readSync, closeSync } from "fs";
+import path from "path";
+import os from "os";
+var TIMER_SLOW_THRESHOLD_MS = 500;
+var TIMER_BLOCK_THRESHOLD_MS = 1e4;
+var TIMER_SEVERE_MS = 5e3;
+var SUSPEND_CLUSTER_MIN_MS = 6e4;
+var SUSPEND_CLUSTER_WINDOW_MS = 2e3;
+var SUSPEND_CLUSTER_MIN_TIMERS = 2;
+function logDir() {
+  return path.join(os.homedir(), ".exe-os", "logs");
+}
+function logPaths(baseName) {
+  const dir = logDir();
+  return [path.join(dir, baseName), path.join(dir, `${baseName}.1`)];
+}
+function readRecords(files, maxBytes) {
+  const records = [];
+  for (const file of files) {
+    try {
+      if (!existsSync(file)) continue;
+      const size = statSync(file).size;
+      let raw;
+      if (size > maxBytes) {
+        const buf = Buffer.alloc(maxBytes);
+        const fd = openSync(file, "r");
+        try {
+          readSync(fd, buf, 0, maxBytes, size - maxBytes);
+        } finally {
+          closeSync(fd);
+        }
+        raw = buf.toString("utf8");
+        const nl = raw.indexOf("\n");
+        if (nl >= 0) raw = raw.slice(nl + 1);
+      } else {
+        raw = readFileSync(file, "utf8");
+      }
+      for (const line of raw.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+          const rec = JSON.parse(trimmed);
+          if (rec && typeof rec === "object") records.push(rec);
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  return records;
+}
+function p95(values) {
+  if (values.length === 0) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const idx = Math.min(sorted.length - 1, Math.ceil(sorted.length * 0.95) - 1);
+  return sorted[Math.max(0, idx)] ?? 0;
+}
+function median(values) {
+  if (values.length === 0) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+}
+function classify(maxMs, p95Ms, tripped) {
+  if (tripped || maxMs >= TIMER_SEVERE_MS) return "blocked";
+  if (maxMs >= TIMER_SLOW_THRESHOLD_MS || p95Ms >= TIMER_SLOW_THRESHOLD_MS) return "slow";
+  return "healthy";
+}
+function buildTimerReport(opts = {}) {
+  const maxBytes = opts.maxBytesPerFile ?? 4 * 1024 * 1024;
+  const inFlightKnown = Array.isArray(opts.inFlight);
+  const inFlightSet = new Set(opts.inFlight ?? []);
+  const healthFiles = logPaths("daemon-health.log");
+  const sources = healthFiles.filter((f) => existsSync(f));
+  const records = readRecords(healthFiles, maxBytes);
+  const samplesByTimer = /* @__PURE__ */ new Map();
+  const clockJumpsByTimer = /* @__PURE__ */ new Map();
+  const timeoutsByTimer = /* @__PURE__ */ new Map();
+  let oldestMs = null;
+  let newestMs = null;
+  const stampOf = (rec) => {
+    if (typeof rec.ts !== "string") return null;
+    const parsed = Date.parse(rec.ts);
+    if (!Number.isFinite(parsed)) return null;
+    oldestMs = oldestMs === null ? parsed : Math.min(oldestMs, parsed);
+    newestMs = newestMs === null ? parsed : Math.max(newestMs, parsed);
+    return parsed;
+  };
+  for (const rec of records) {
+    const data = rec.data;
+    if (!data) continue;
+    if (rec.event === "timer_timeout") {
+      const timer2 = typeof data.timer === "string" ? data.timer : null;
+      if (!timer2) continue;
+      const atMs2 = stampOf(rec);
+      const cur = timeoutsByTimer.get(timer2) ?? { count: 0, lastAtMs: null };
+      cur.count += 1;
+      if (atMs2 !== null && (cur.lastAtMs === null || atMs2 > cur.lastAtMs)) cur.lastAtMs = atMs2;
+      timeoutsByTimer.set(timer2, cur);
+      continue;
+    }
+    if (rec.event !== "process_stats") continue;
+    const type = data.type;
+    if (type !== "timer_duration" && type !== "timer_slow") continue;
+    const timer = typeof data.timer === "string" ? data.timer : null;
+    const durationMs = typeof data.durationMs === "number" ? data.durationMs : null;
+    if (timer === null || durationMs === null || !Number.isFinite(durationMs)) continue;
+    const atMs = stampOf(rec);
+    const sleptMs = typeof data.sleptMs === "number" ? data.sleptMs : 0;
+    if (data.clockJump === true || sleptMs > 1e3) {
+      clockJumpsByTimer.set(timer, (clockJumpsByTimer.get(timer) ?? 0) + 1);
+      continue;
+    }
+    const arr = samplesByTimer.get(timer) ?? [];
+    arr.push({ durationMs, atMs });
+    samplesByTimer.set(timer, arr);
+  }
+  const suspendArtifacts = /* @__PURE__ */ new Set();
+  const suspendCountByTimer = /* @__PURE__ */ new Map();
+  {
+    const candidates = [];
+    for (const [timer, samples] of samplesByTimer) {
+      for (const s of samples) {
+        if (s.atMs !== null && s.durationMs >= SUSPEND_CLUSTER_MIN_MS) {
+          candidates.push({ timer, sample: s });
+        }
+      }
+    }
+    candidates.sort((a, b) => a.sample.atMs - b.sample.atMs);
+    let start = 0;
+    for (let end = 0; end < candidates.length; end++) {
+      while (candidates[end].sample.atMs - candidates[start].sample.atMs > SUSPEND_CLUSTER_WINDOW_MS) {
+        start++;
+      }
+      const window = candidates.slice(start, end + 1);
+      const distinct = new Set(window.map((c) => c.timer));
+      if (distinct.size >= SUSPEND_CLUSTER_MIN_TIMERS) {
+        for (const c of window) suspendArtifacts.add(c.sample);
+      }
+    }
+    for (const [timer, samples] of samplesByTimer) {
+      const clean = samples.filter((s) => !suspendArtifacts.has(s));
+      const dropped = samples.length - clean.length;
+      if (dropped > 0) suspendCountByTimer.set(timer, dropped);
+      samplesByTimer.set(timer, clean);
+    }
+  }
+  const allTimers = /* @__PURE__ */ new Set([
+    ...samplesByTimer.keys(),
+    ...clockJumpsByTimer.keys(),
+    ...timeoutsByTimer.keys(),
+    ...inFlightSet
+  ]);
+  const timers = [...allTimers].map((timer) => {
+    const samples = samplesByTimer.get(timer) ?? [];
+    const timeouts = timeoutsByTimer.get(timer) ?? { count: 0, lastAtMs: null };
+    const durations = samples.map((s) => s.durationMs);
+    const maxMs = durations.length > 0 ? Math.max(...durations) : 0;
+    const avgMs = durations.length > 0 ? Math.round(durations.reduce((a, b) => a + b, 0) / durations.length) : 0;
+    const p95Ms = p95(durations);
+    const stamped = samples.filter((s) => s.atMs !== null).sort((a, b) => a.atMs - b.atMs);
+    const lastAtMs = stamped.length > 0 ? stamped[stamped.length - 1].atMs : null;
+    const lastMs = stamped.length > 0 ? stamped[stamped.length - 1].durationMs : samples.length > 0 ? samples[samples.length - 1].durationMs : 0;
+    let cadenceMs = null;
+    if (stamped.length >= 2) {
+      const gaps = [];
+      for (let i = 1; i < stamped.length; i++) {
+        const gap = stamped[i].atMs - stamped[i - 1].atMs;
+        if (gap > 0) gaps.push(gap);
+      }
+      if (gaps.length > 0) cadenceMs = Math.round(median(gaps));
+    }
+    const nextRunMs = lastAtMs !== null && cadenceMs !== null ? lastAtMs + cadenceMs : null;
+    const trippedBlockThreshold = timeouts.count > 0 || maxMs >= TIMER_BLOCK_THRESHOLD_MS;
+    return {
+      timer,
+      samples: samples.length,
+      clockJumpSamples: clockJumpsByTimer.get(timer) ?? 0,
+      suspendSamples: suspendCountByTimer.get(timer) ?? 0,
+      lastMs,
+      avgMs,
+      maxMs,
+      p95Ms,
+      lastAtMs,
+      cadenceMs,
+      nextRunMs,
+      timeoutCount: timeouts.count,
+      lastTimeoutAtMs: timeouts.lastAtMs,
+      trippedBlockThreshold,
+      inFlight: inFlightKnown ? inFlightSet.has(timer) : null,
+      status: classify(maxMs, p95Ms, trippedBlockThreshold)
+    };
+  });
+  const rank = { blocked: 0, slow: 1, healthy: 2 };
+  timers.sort(
+    (a, b) => rank[a.status] - rank[b.status] || b.maxMs - a.maxMs || b.timeoutCount - a.timeoutCount || a.timer.localeCompare(b.timer)
+  );
+  return {
+    logsFound: sources.length > 0,
+    sources,
+    timers,
+    inFlightKnown,
+    window: { oldestMs, newestMs }
+  };
+}
+var DAEMON_PORT = 48739;
+async function fetchInFlightTimers(timeoutMs = 1e3) {
+  try {
+    const res = await fetch(`http://127.0.0.1:${DAEMON_PORT}/health`, {
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (!res.ok) return null;
+    const body = await res.json();
+    if (!Array.isArray(body.timersInFlight)) return null;
+    return body.timersInFlight.filter((t) => typeof t === "string");
+  } catch {
+    return null;
+  }
+}
+async function buildLiveTimerReport(opts = {}) {
+  const inFlight = await fetchInFlightTimers();
+  return buildTimerReport(inFlight === null ? opts : { ...opts, inFlight });
+}
+function ms(n) {
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}s`;
+  return `${Math.round(n)}ms`;
+}
+function shortClock(epochMs) {
+  if (epochMs === null) return "\u2014";
+  return new Date(epochMs).toISOString().replace("T", " ").slice(0, 16);
+}
+function nextRunLabel(nextRunMs, now) {
+  if (nextRunMs === null) return "\u2014";
+  const delta = nextRunMs - now;
+  if (delta <= 0) return "due";
+  if (delta < 6e4) return `in ${Math.round(delta / 1e3)}s`;
+  if (delta < 36e5) return `in ${Math.round(delta / 6e4)}m`;
+  return `in ${(delta / 36e5).toFixed(1)}h`;
+}
+function statusIndicator(status) {
+  return status === "blocked" ? "\u{1F534}" : status === "slow" ? "\u{1F7E0}" : "\u{1F7E2}";
+}
+function inFlightLabel(inFlight) {
+  if (inFlight === null) return "?";
+  return inFlight ? "RUN" : "-";
+}
+function formatTimerReport(report, now = Date.now()) {
+  const lines = [];
+  lines.push("");
+  lines.push("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557");
+  lines.push("\u2551          Timer Health Dashboard         \u2551");
+  lines.push("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D");
+  lines.push("");
+  if (!report.logsFound) {
+    lines.push("\u{1F7E2} No daemon health log found.");
+    lines.push("   ~/.exe-os/logs/daemon-health.log has no timer data yet");
+    lines.push("   (fresh install, or the daemon has run no background timers).");
+    lines.push("");
+    return lines.join("\n");
+  }
+  if (report.timers.length === 0) {
+    lines.push("\u{1F7E2} No timer durations recorded yet \u2014 no background tick has ever been slow.");
+    lines.push("");
+    return lines.join("\n");
+  }
+  if (report.window.oldestMs !== null && report.window.newestMs !== null) {
+    lines.push(`Window: ${shortClock(report.window.oldestMs)} \u2192 ${shortClock(report.window.newestMs)}`);
+  }
+  lines.push(
+    report.inFlightKnown ? "Live: daemon reachable \u2014 in-flight state is current." : "Live: daemon unreachable \u2014 in-flight shown as '?' (unknown, not idle)."
+  );
+  lines.push("");
+  const head = `   ${"timer".padEnd(26)} ${"last".padStart(8)} ${"avg".padStart(8)} ${"p95".padStart(8)} ${"max".padStart(8)} ${"trips".padStart(5)} ${"run".padStart(3)}  ${"next".padEnd(8)} ${"samples".padStart(7)} ${"skew".padStart(4)}  last seen`;
+  lines.push(head);
+  lines.push("   " + "\u2500".repeat(Math.max(0, head.length - 3)));
+  for (const t of report.timers) {
+    lines.push(
+      `${statusIndicator(t.status)} ${t.timer.padEnd(26)} ${ms(t.lastMs).padStart(8)} ${ms(t.avgMs).padStart(8)} ${ms(t.p95Ms).padStart(8)} ${ms(t.maxMs).padStart(8)} ${String(t.timeoutCount).padStart(5)} ${inFlightLabel(t.inFlight).padStart(3)}  ${nextRunLabel(t.nextRunMs, now).padEnd(8)} ${String(t.samples).padStart(7)} ${String(t.clockJumpSamples + t.suspendSamples).padStart(4)}  ${shortClock(t.lastAtMs)}`
+    );
+  }
+  lines.push("");
+  const blocked = report.timers.filter((t) => t.status === "blocked");
+  const slow = report.timers.filter((t) => t.status === "slow");
+  const overall = blocked.length > 0 ? "\u{1F534}" : slow.length > 0 ? "\u{1F7E0}" : "\u{1F7E2}";
+  lines.push(
+    `${overall} ${report.timers.length} timer(s): ${blocked.length} blocked, ${slow.length} slow, ${report.timers.length - blocked.length - slow.length} healthy`
+  );
+  if (blocked.length > 0) {
+    lines.push("");
+    lines.push(
+      `\u{1F534} BLOCKING RISK \u2014 these ticks reached the event-loop danger zone (watchdog \u2265${TIMER_BLOCK_THRESHOLD_MS / 1e3}s, or a single tick \u2265${TIMER_SEVERE_MS / 1e3}s).`
+    );
+    lines.push("   A tick that blocks the loop past the budget can self-restart the daemon (exit 75)");
+    lines.push("   and drop every agent's MCP connection.");
+    for (const t of blocked) {
+      const trips = t.timeoutCount > 0 ? `${t.timeoutCount} watchdog trip(s), last ${shortClock(t.lastTimeoutAtMs)}` : "no watchdog trip (single slow tick)";
+      lines.push(`   \u2022 ${t.timer}: max ${ms(t.maxMs)}, p95 ${ms(t.p95Ms)} \u2014 ${trips}`);
+    }
+  }
+  lines.push("");
+  lines.push(
+    `\u24D8 Sampling: the daemon only logs a tick when it takes \u2265${TIMER_SLOW_THRESHOLD_MS}ms (or during boot).`
+  );
+  lines.push(
+    "   So 'samples' counts SLOW ticks, not total runs, and 'avg' is the mean of the slow"
+  );
+  lines.push(
+    "   ones (biased upward). A timer missing from this table has never been slow."
+  );
+  lines.push("   trips = times the 10s watchdog fired. run = RUN in-flight, - idle, ? unknown.");
+  lines.push(
+    "   skew = ticks discarded as host-suspend artifacts (many timers all 'finishing' at"
+  );
+  lines.push(
+    "   the same wake instant) \u2014 EXCLUDED from every duration above. A 4-hour 'tick' is a"
+  );
+  lines.push("   shut laptop lid, not an event-loop block. What remains is real.");
+  lines.push(
+    "   NOTE: duration is the ASYNC SPAN of the tick, not CPU time on the loop. A long span"
+  );
+  lines.push(
+    "   may be awaited I/O (harmless to the loop) \u2014 but it still trips the 10s watchdog and"
+  );
+  lines.push("   the overlap guard, so the next tick is SKIPPED. Both matter.");
+  lines.push("");
+  return lines.join("\n");
+}
+
+export {
+  TIMER_SLOW_THRESHOLD_MS,
+  TIMER_BLOCK_THRESHOLD_MS,
+  TIMER_SEVERE_MS,
+  SUSPEND_CLUSTER_MIN_MS,
+  SUSPEND_CLUSTER_WINDOW_MS,
+  SUSPEND_CLUSTER_MIN_TIMERS,
+  buildTimerReport,
+  fetchInFlightTimers,
+  buildLiveTimerReport,
+  formatTimerReport
+};

package/dist/{chunk-ZNE6H2JO.js → chunk-MZM6EJCU.js}

@@ -1,13 +1,13 @@
 import {
   deactivateBehavior
-} from "./chunk-OUEFW4RK.js";
+} from "./chunk-KW2SD2FL.js";
 import {
   getActiveAgent
-} from "./chunk-C445WRUX.js";
+} from "./chunk-5ERDIOV3.js";
 import {
   canCoordinate,
   getClient
-} from "./chunk-RWSLVYTE.js";
+} from "./chunk-AOHXREB7.js";
 
 // src/mcp/tools/deactivate-behavior.ts
 import { z } from "zod";
@@ -24,7 +24,7 @@ function registerDeactivateBehavior(server) {
     async ({ behavior_id }) => {
       const caller = getActiveAgent();
       try {
-        const { StewardGate } = await import("./steward-gate-4A2XHYFD.js");
+        const { StewardGate } = await import("./steward-gate-3GQ5XKMJ.js");
         const steward = new StewardGate();
         const gateDecision = await steward.checkAuthority(caller.agentId || "unknown", "deactivate_behavior", behavior_id);
         if (!gateDecision.allowed) {