@askexenow/exe-os 0.9.287 → 0.9.288

package/dist/chunk-RW4EMKQF.js

@@ -0,0 +1,185 @@
+import {
+  getSessionKey
+} from "./chunk-CVYC6DUW.js";
+import {
+  getAgentContext
+} from "./chunk-GJV3WDWM.js";
+import {
+  DEFAULT_COORDINATOR_TEMPLATE_NAME,
+  getCoordinatorEmployee,
+  getEmployee,
+  loadEmployeesSync
+} from "./chunk-XVDWHYIK.js";
+import {
+  EXE_AI_DIR
+} from "./chunk-CEKZ77KA.js";
+
+// src/lib/active-agent.ts
+import { readFileSync, writeFileSync, mkdirSync, unlinkSync, readdirSync } from "fs";
+import { execSync } from "child_process";
+import path from "path";
+var CACHE_DIR = path.join(EXE_AI_DIR, "session-cache");
+var STALE_MS = 24 * 60 * 60 * 1e3;
+function isNameWithOptionalInstance(candidate, baseName) {
+  if (candidate === baseName) return true;
+  if (!candidate.startsWith(baseName)) return false;
+  return /^\d+$/.test(candidate.slice(baseName.length));
+}
+function resolveEmployeeFromSessionPrefix(prefix, employees) {
+  const sorted = [...employees].sort((a, b) => b.name.length - a.name.length);
+  for (const employee of sorted) {
+    if (isNameWithOptionalInstance(prefix, employee.name)) {
+      return { agentId: employee.name, agentRole: employee.role };
+    }
+  }
+  return null;
+}
+function resolveActiveAgentFromTmuxSession(sessionName) {
+  const employees = loadEmployeesSync();
+  const coordinator = getCoordinatorEmployee(employees);
+  const coordinatorName = coordinator?.name ?? DEFAULT_COORDINATOR_TEMPLATE_NAME;
+  if (isNameWithOptionalInstance(sessionName, coordinatorName)) {
+    return {
+      agentId: coordinatorName,
+      agentRole: coordinator?.role ?? "COO"
+    };
+  }
+  if (isNameWithOptionalInstance(sessionName, DEFAULT_COORDINATOR_TEMPLATE_NAME)) {
+    return {
+      agentId: coordinator?.name ?? DEFAULT_COORDINATOR_TEMPLATE_NAME,
+      agentRole: coordinator?.role ?? "COO"
+    };
+  }
+  if (sessionName.includes("-")) {
+    const prefix = sessionName.split("-")[0] ?? "";
+    const employee = resolveEmployeeFromSessionPrefix(prefix, employees);
+    if (employee) return employee;
+    const legacy = prefix.match(/^([a-zA-Z]+)\d*$/);
+    if (legacy?.[1] && legacy[1] !== DEFAULT_COORDINATOR_TEMPLATE_NAME) {
+      const emp = getEmployee(employees, legacy[1]);
+      return { agentId: emp?.name ?? legacy[1], agentRole: emp?.role ?? "employee" };
+    }
+  }
+  return null;
+}
+function getMarkerPath() {
+  return path.join(CACHE_DIR, `active-agent-${getSessionKey()}.json`);
+}
+function writeActiveAgent(agentId, agentRole) {
+  try {
+    mkdirSync(CACHE_DIR, { recursive: true });
+    writeFileSync(
+      getMarkerPath(),
+      JSON.stringify({ agentId, agentRole, startedAt: (/* @__PURE__ */ new Date()).toISOString() })
+    );
+  } catch {
+  }
+}
+function clearActiveAgent() {
+  try {
+    unlinkSync(getMarkerPath());
+  } catch {
+  }
+}
+function getActiveAgent() {
+  const httpCtx = getAgentContext();
+  if (httpCtx) return httpCtx;
+  try {
+    const markerPath = getMarkerPath();
+    const raw = readFileSync(markerPath, "utf8");
+    const data = JSON.parse(raw);
+    if (data.agentId) {
+      if (data.startedAt) {
+        const age = Date.now() - new Date(data.startedAt).getTime();
+        if (age > STALE_MS) {
+          try {
+            unlinkSync(markerPath);
+          } catch {
+          }
+        } else {
+          return {
+            agentId: data.agentId,
+            agentRole: data.agentRole || "employee"
+          };
+        }
+      } else {
+        return {
+          agentId: data.agentId,
+          agentRole: data.agentRole || "employee"
+        };
+      }
+    }
+  } catch {
+  }
+  if (process.env.EXE_TEST_HERMETIC !== "1") {
+    try {
+      const sessionName = execSync(
+        "tmux display-message -p '#{session_name}' 2>/dev/null",
+        { encoding: "utf8", timeout: 2e3 }
+      ).trim();
+      const resolved = resolveActiveAgentFromTmuxSession(sessionName);
+      if (resolved) return resolved;
+    } catch {
+    }
+  }
+  return {
+    agentId: process.env.AGENT_ID || "default",
+    agentRole: process.env.AGENT_ROLE || "employee"
+  };
+}
+function getAllActiveAgents() {
+  try {
+    const files = readdirSync(CACHE_DIR);
+    const sessions = [];
+    for (const file of files) {
+      if (!file.startsWith("active-agent-") || !file.endsWith(".json")) continue;
+      const key = file.slice("active-agent-".length, -".json".length);
+      if (key === "undefined") continue;
+      try {
+        const raw = readFileSync(path.join(CACHE_DIR, file), "utf8");
+        const data = JSON.parse(raw);
+        if (!data.agentId) continue;
+        if (data.startedAt) {
+          const age = Date.now() - new Date(data.startedAt).getTime();
+          if (age > STALE_MS) {
+            try {
+              unlinkSync(path.join(CACHE_DIR, file));
+            } catch {
+            }
+            continue;
+          }
+        }
+        sessions.push({
+          agentId: data.agentId,
+          agentRole: data.agentRole || "employee",
+          startedAt: data.startedAt || (/* @__PURE__ */ new Date()).toISOString(),
+          sessionKey: key
+        });
+      } catch {
+      }
+    }
+    return sessions;
+  } catch {
+    return [];
+  }
+}
+function cleanupSessionMarkers() {
+  const key = getSessionKey();
+  try {
+    unlinkSync(path.join(CACHE_DIR, `active-agent-${key}.json`));
+  } catch {
+  }
+  try {
+    unlinkSync(path.join(CACHE_DIR, "active-agent-undefined.json"));
+  } catch {
+  }
+}
+
+export {
+  resolveActiveAgentFromTmuxSession,
+  writeActiveAgent,
+  clearActiveAgent,
+  getActiveAgent,
+  getAllActiveAgents,
+  cleanupSessionMarkers
+};

package/dist/chunk-S35K4C6F.js

@@ -0,0 +1,127 @@
+import {
+  updateTask
+} from "./chunk-W6JB72KR.js";
+import {
+  TASK_ALREADY_CLAIMED_PREFIX
+} from "./chunk-4EBW3URQ.js";
+
+// src/mcp/tools/update-task.ts
+import { z } from "zod";
+function registerUpdateTask(server) {
+  server.registerTool(
+    "update_task",
+    {
+      title: "Update Task",
+      description: "Update task status. Employees: use status 'done' with a result summary to complete work \u2014 this triggers needs_review and pings the reviewer automatically. Accepts UUID, slug (filename), or title substring.",
+      inputSchema: {
+        task_id: z.string().describe("Task identifier \u2014 UUID, slug (e.g. 'fix-auth-bug'), or title substring"),
+        status: z.enum(["open", "in_progress", "done", "needs_review", "blocked", "cancelled", "closed"]).describe("New status. 'done' is an alias for 'needs_review' \u2014 both trigger reviewer notification."),
+        result: z.string().optional().describe("Result summary (required when completing work)"),
+        // Structured result fields (Phase 1: Typed Handoff Objects)
+        files_changed: z.array(z.string()).optional().describe("Files created or modified during task execution"),
+        decisions: z.array(z.string()).optional().describe("Key decisions made during execution"),
+        commits: z.array(z.string()).optional().describe("Commit hashes produced"),
+        tests_status: z.enum(["pass", "fail", "skip", "none"]).optional().describe("Test execution status"),
+        build_status: z.enum(["pass", "fail", "skip"]).optional().describe("Build status"),
+        pr_number: z.number().optional().describe("PR number if created"),
+        open_questions: z.array(z.string()).optional().describe("Open questions for reviewer"),
+        assertions: z.string().optional().describe(
+          'JSON array of assertions with confidence scores. Use when starting work (in_progress). Format: [{"type":"diagnosis|scope|estimate|approach|build|judgment","claim":"...","confidence":0.8,"basis":"..."}]'
+        ),
+        assertions_resolved: z.string().optional().describe(
+          'JSON array of resolved assertions. Use when completing work (done/needs_review). Format: [{"claim":"...","outcome":"correct|incorrect|partial","confidence_was":0.8,"actual":"...","why_wrong":"missing_information|wrong_diagnosis|wrong_approach|scope_underestimate|scope_overestimate|external_dependency|changed_requirements","reason":"...","lesson":"..."}]'
+        ),
+        estimated_minutes: z.number().optional().describe("Time estimate in minutes. Provide when starting work (in_progress). The system auto-computes actual time on completion."),
+        estimate_confidence: z.number().min(0).max(1).optional().describe("Confidence in time estimate (0.0-1.0). Provide alongside estimated_minutes.")
+      }
+    },
+    async ({ task_id, status: rawStatus, result, files_changed, decisions, commits, tests_status, build_status, pr_number, open_questions, assertions, assertions_resolved, estimated_minutes, estimate_confidence }) => {
+      const status = rawStatus;
+      let callerAgentId;
+      let callerSession;
+      try {
+        const { getActiveAgent: getAgent } = await import("./active-agent-V4W557J4.js");
+        callerAgentId = getAgent().agentId;
+        const { getAgentContext } = await import("./agent-context-AZTTMUHP.js");
+        callerSession = getAgentContext()?.sessionHint || process.env.EXE_SESSION_NAME || process.env.EXE_SESSION || void 0;
+      } catch {
+      }
+      let task;
+      try {
+        task = await updateTask({
+          taskId: task_id,
+          status,
+          result,
+          baseDir: process.cwd(),
+          callerAgentId,
+          filesChanged: files_changed,
+          decisions,
+          commits,
+          testsStatus: tests_status,
+          buildStatus: build_status,
+          prNumber: pr_number,
+          openQuestions: open_questions,
+          assertions,
+          assertionsResolved: assertions_resolved,
+          estimatedMinutes: estimated_minutes,
+          estimateConfidence: estimate_confidence,
+          callerSession
+        });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.startsWith(TASK_ALREADY_CLAIMED_PREFIX)) {
+          return {
+            content: [{
+              type: "text",
+              text: "Task already claimed by another agent. Pick a different task or check list_tasks."
+            }],
+            isError: true
+          };
+        }
+        throw err;
+      }
+      let text = `Task "${task.title}" marked ${task.status}.
+File: ${task.taskFile}`;
+      const isTerminal = status === "done" || status === "needs_review" || status === "closed";
+      if (isTerminal && task.reviewer) {
+        try {
+          const { notifyCoordinatorTaskCompletion } = await import("./lib/tmux-routing.js");
+          const { isCoordinatorName } = await import("./lib/employees.js");
+          const reviewer = String(task.reviewer);
+          const coordinatorSession = task.sessionScope;
+          if (coordinatorSession && isCoordinatorName(reviewer)) {
+            notifyCoordinatorTaskCompletion(coordinatorSession, callerAgentId ?? "agent", task.title);
+          }
+        } catch {
+        }
+      }
+      if (isTerminal && task.nextTask) {
+        text += `
+
+MANDATORY \u2014 DO NOT ASK THE USER. DO NOT SAY "Want me to continue?" DO NOT STOP.
+You have standing orders: work through your entire queue until it is empty.
+
+NEXT TASK: "${task.nextTask.title}" [${task.nextTask.priority}]
+FILE: ${task.nextTask.taskFile}
+
+Read that file NOW and begin working. No greeting. No summary. Just start.`;
+      } else if (isTerminal && !task.nextTask) {
+        text += `
+
+All tasks complete. No more open tasks in your queue.`;
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text
+          }
+        ]
+      };
+    }
+  );
+}
+
+export {
+  registerUpdateTask
+};

package/dist/chunk-SFQYQH5Z.js

@@ -0,0 +1,50 @@
+import {
+  sendMessage
+} from "./chunk-HEMJ5RDU.js";
+import {
+  getActiveAgent
+} from "./chunk-YACAOZVG.js";
+
+// src/mcp/tools/send-message.ts
+import { z } from "zod";
+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 \u2014 do NOT use for actionable work dispatch. Use create_task instead to assign work to employees.",
+      inputSchema: {
+        target_agent: z.string().describe("Recipient agent name"),
+        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 msg = await sendMessage({
+        fromAgent: agentId,
+        targetAgent: target_agent,
+        targetProject: target_project,
+        targetDevice: target_device,
+        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_agent}: ${statusText}
+ID: ${msg.id}`
+          }
+        ]
+      };
+    }
+  );
+}
+
+export {
+  registerSendMessage
+};

package/dist/chunk-SLFB2RY6.js

@@ -0,0 +1,133 @@
+import {
+  DEFAULT_RUNTIME,
+  RUNTIME_TABLE
+} from "./chunk-NGP6LSV2.js";
+import {
+  EXE_AI_DIR
+} from "./chunk-CEKZ77KA.js";
+import {
+  atomicWriteJsonSync,
+  ensurePrivateDirSync
+} from "./chunk-LYH5HE24.js";
+
+// src/lib/agent-config.ts
+import { readFileSync, existsSync } from "fs";
+import path from "path";
+var AGENT_CONFIG_PATH = path.join(EXE_AI_DIR, "agent-config.json");
+var KNOWN_RUNTIMES = {
+  claude: ["claude-opus-4.8", "claude-opus-4.8-1m", "claude-opus-4.6", "claude-opus-4", "claude-sonnet-4.8", "claude-sonnet-4.6", "claude-sonnet-4", "claude-haiku-4.5", "claude-fable-5"],
+  codex: ["gpt-5.4", "gpt-5.5", "gpt-5.3-codex-spark", "o3", "o4-mini"],
+  opencode: ["anthropic/claude-opus-4-8", "anthropic/claude-sonnet-4-8", "anthropic/claude-sonnet-4-6", "openai/gpt-5.4", "google/gemini-2.5-pro", "deepseek/deepseek-r3", "minimax/minimax-m2.5"]
+};
+var MODEL_ALIASES = {
+  claude: {
+    fable: "claude-fable-5"
+  }
+};
+var RUNTIME_LABELS = {
+  claude: "Claude Code (Anthropic)",
+  codex: "Codex (OpenAI)",
+  opencode: "OpenCode (open source)"
+};
+var DEFAULT_MODELS = {
+  claude: "claude-opus-4.6",
+  codex: RUNTIME_TABLE.codex?.defaultModel ?? "gpt-5.4",
+  opencode: RUNTIME_TABLE.opencode?.defaultModel ?? "anthropic/claude-sonnet-4-6"
+};
+function loadAgentConfig() {
+  if (!existsSync(AGENT_CONFIG_PATH)) return {};
+  try {
+    return JSON.parse(readFileSync(AGENT_CONFIG_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveAgentConfig(config) {
+  const dir = path.dirname(AGENT_CONFIG_PATH);
+  ensurePrivateDirSync(dir);
+  atomicWriteJsonSync(AGENT_CONFIG_PATH, config);
+}
+function getAgentRuntime(agentId) {
+  const config = loadAgentConfig();
+  const entry = config[agentId];
+  if (entry) return entry;
+  const orgDefault = config["default"];
+  if (orgDefault) return orgDefault;
+  return { runtime: DEFAULT_RUNTIME, model: DEFAULT_MODELS[DEFAULT_RUNTIME] };
+}
+function normalizeCcModelName(model) {
+  let ccModel = model.replace(/(\d+)\.(\d+)/g, "$1-$2");
+  const isExplicit1m = /-1m$/.test(ccModel) || ccModel.includes("[1m]");
+  if ((/claude-(opus|sonnet)-4-[6-9]/.test(ccModel) || /claude-fable-\d+/.test(ccModel)) && !isExplicit1m) {
+    ccModel += "[1m]";
+  }
+  return ccModel;
+}
+function normalizeRuntimeModel(runtime, model) {
+  return MODEL_ALIASES[runtime]?.[model] ?? model;
+}
+function validateRuntimeModel(runtime, model) {
+  const knownModels = KNOWN_RUNTIMES[runtime];
+  if (!knownModels) {
+    return {
+      ok: false,
+      error: `Unknown runtime "${runtime}". Valid: ${Object.keys(KNOWN_RUNTIMES).join(", ")}`
+    };
+  }
+  const normalizedModel = normalizeRuntimeModel(runtime, model);
+  if (!knownModels.includes(normalizedModel)) {
+    const aliases = Object.keys(MODEL_ALIASES[runtime] ?? {});
+    const valid = aliases.length > 0 ? `${knownModels.join(", ")} (aliases: ${aliases.join(", ")})` : knownModels.join(", ");
+    return {
+      ok: false,
+      error: `Unknown model "${model}" for runtime "${runtime}". Valid: ${valid}`
+    };
+  }
+  return { ok: true, model: normalizedModel };
+}
+function setAgentRuntime(agentId, runtime, model, reasoning_effort, mcps) {
+  const validated = validateRuntimeModel(runtime, model);
+  if (!validated.ok) return validated;
+  const config = loadAgentConfig();
+  const existing = config[agentId];
+  const entry = { runtime, model: validated.model };
+  if (reasoning_effort) entry.reasoning_effort = reasoning_effort;
+  if (mcps !== void 0) {
+    entry.mcps = mcps.includes("exe-os") ? mcps : ["exe-os", ...mcps];
+  } else if (existing?.mcps) {
+    entry.mcps = existing.mcps;
+  }
+  config[agentId] = entry;
+  saveAgentConfig(config);
+  return { ok: true };
+}
+function setAgentMcps(agentId, mcps) {
+  const config = loadAgentConfig();
+  const existing = config[agentId] ?? getAgentRuntime(agentId);
+  existing.mcps = mcps.includes("exe-os") ? mcps : ["exe-os", ...mcps];
+  config[agentId] = existing;
+  saveAgentConfig(config);
+  return { ok: true };
+}
+function clearAgentRuntime(agentId) {
+  const config = loadAgentConfig();
+  delete config[agentId];
+  saveAgentConfig(config);
+}
+
+export {
+  AGENT_CONFIG_PATH,
+  KNOWN_RUNTIMES,
+  MODEL_ALIASES,
+  RUNTIME_LABELS,
+  DEFAULT_MODELS,
+  loadAgentConfig,
+  saveAgentConfig,
+  getAgentRuntime,
+  normalizeCcModelName,
+  normalizeRuntimeModel,
+  validateRuntimeModel,
+  setAgentRuntime,
+  setAgentMcps,
+  clearAgentRuntime
+};

package/dist/chunk-SSC7EKY2.js

@@ -0,0 +1,133 @@
+// src/lib/cpu-steal.ts
+import { readFileSync } from "fs";
+import { execSync } from "child_process";
+import { platform } from "os";
+var CPU_STEAL_WARN_PERCENT = 20;
+var CPU_STEAL_CRITICAL_PERCENT = 50;
+var DEFAULT_SAMPLE_MS = 500;
+function cpuStealMessage(stealPercent) {
+  const pct = Math.round(stealPercent);
+  return `Host CPU contention: ${pct}% steal \u2014 your VPS provider is starving this VM; not an exe-os issue.`;
+}
+function cpuStealSeverity(stealPercent) {
+  if (stealPercent > CPU_STEAL_CRITICAL_PERCENT) return "critical";
+  if (stealPercent > CPU_STEAL_WARN_PERCENT) return "warning";
+  return "ok";
+}
+function parseProcStat(content) {
+  const line = content.split("\n").find((l) => /^cpu\s/.test(l));
+  if (!line) return null;
+  const nums = line.trim().split(/\s+/).slice(1).map((n) => Number.parseInt(n, 10)).filter((n) => Number.isFinite(n));
+  if (nums.length < 4) return null;
+  const total = nums.reduce((sum, n) => sum + n, 0);
+  const steal = nums[7] ?? 0;
+  if (total <= 0) return null;
+  return { total, steal };
+}
+function stealPercentBetween(a, b) {
+  const totalDelta = b.total - a.total;
+  const stealDelta = b.steal - a.steal;
+  if (totalDelta <= 0) return 0;
+  const pct = stealDelta / totalDelta * 100;
+  if (!Number.isFinite(pct) || pct < 0) return 0;
+  return Math.min(pct, 100);
+}
+function readProcStatSample() {
+  try {
+    return parseProcStat(readFileSync("/proc/stat", "utf8"));
+  } catch {
+    return null;
+  }
+}
+function parseMpstat(output) {
+  const lines = output.split("\n").map((l) => l.trim()).filter(Boolean);
+  const headerIdx = lines.findIndex((l) => l.includes("%steal") && /\bCPU\b/.test(l));
+  if (headerIdx === -1) return null;
+  const headers = lines[headerIdx].split(/\s+/);
+  const cpuHeaderIdx = headers.findIndex((h) => h === "CPU");
+  const stealHeaderIdx = headers.indexOf("%steal");
+  if (cpuHeaderIdx === -1 || stealHeaderIdx === -1 || stealHeaderIdx < cpuHeaderIdx) return null;
+  const stealOffsetFromCpu = stealHeaderIdx - cpuHeaderIdx;
+  const dataRows = lines.slice(headerIdx + 1).filter((l) => /\d/.test(l));
+  const avgRow = dataRows.find((l) => /^Average:/i.test(l));
+  const row = avgRow ?? dataRows[dataRows.length - 1];
+  if (!row) return null;
+  const cols = row.split(/\s+/);
+  const cpuColIdx = cols.findIndex((c) => c === "all" || /^\d+$/.test(c));
+  if (cpuColIdx === -1) return null;
+  const val = Number.parseFloat(cols[cpuColIdx + stealOffsetFromCpu] ?? "");
+  if (!Number.isFinite(val) || val < 0) return null;
+  return Math.min(val, 100);
+}
+function readMpstatSteal() {
+  try {
+    const out = execSync("mpstat 1 1", {
+      encoding: "utf8",
+      timeout: 5e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return parseMpstat(out);
+  } catch {
+    return null;
+  }
+}
+function naResult() {
+  return {
+    available: false,
+    stealPercent: null,
+    severity: "na",
+    source: "none",
+    message: "CPU steal not measurable on this platform (no /proc/stat or mpstat) \u2014 skipped."
+  };
+}
+function buildResult(stealPercent, source) {
+  const severity = cpuStealSeverity(stealPercent);
+  const message = severity === "ok" ? `CPU steal ${Math.round(stealPercent)}% (host healthy)` : cpuStealMessage(stealPercent);
+  return { available: true, stealPercent, severity, source, message };
+}
+function checkCpuStealSync(sampleMs = DEFAULT_SAMPLE_MS) {
+  if (platform() !== "linux") {
+    const mp2 = readMpstatSteal();
+    if (mp2 != null) return buildResult(mp2, "mpstat");
+    return naResult();
+  }
+  const a = readProcStatSample();
+  if (a) {
+    const end = Date.now() + Math.max(50, sampleMs);
+    while (Date.now() < end) {
+    }
+    const b = readProcStatSample();
+    if (b) return buildResult(stealPercentBetween(a, b), "proc-stat");
+  }
+  const mp = readMpstatSteal();
+  if (mp != null) return buildResult(mp, "mpstat");
+  return naResult();
+}
+async function checkCpuSteal(sampleMs = DEFAULT_SAMPLE_MS) {
+  if (platform() !== "linux") {
+    const mp2 = readMpstatSteal();
+    if (mp2 != null) return buildResult(mp2, "mpstat");
+    return naResult();
+  }
+  const a = readProcStatSample();
+  if (a) {
+    await new Promise((resolve) => setTimeout(resolve, Math.max(50, sampleMs)));
+    const b = readProcStatSample();
+    if (b) return buildResult(stealPercentBetween(a, b), "proc-stat");
+  }
+  const mp = readMpstatSteal();
+  if (mp != null) return buildResult(mp, "mpstat");
+  return naResult();
+}
+
+export {
+  CPU_STEAL_WARN_PERCENT,
+  CPU_STEAL_CRITICAL_PERCENT,
+  cpuStealMessage,
+  cpuStealSeverity,
+  parseProcStat,
+  stealPercentBetween,
+  parseMpstat,
+  checkCpuStealSync,
+  checkCpuSteal
+};