@rubytech/create-maxy-code 0.1.475 → 0.1.477

package/payload/server/{chunk-Y6V45R6M.js → chunk-JECAP3Z2.js}

@@ -2657,10 +2657,231 @@ var serve = (options, listeningListener) => {
   return server;
 };
 
+// server/loop-registry.ts
+import { readFileSync } from "fs";
+var TAG = "[loop-registry]";
+var STALL_INTERVALS = 3;
+var entries = /* @__PURE__ */ new Map();
+var defaultCpuIo = {
+  ownCpuUs: () => {
+    const u = process.cpuUsage();
+    return u.user + u.system;
+  },
+  childCpuUs: (pid) => readPidCpuUs(pid)
+};
+var cpuIo = defaultCpuIo;
+function parsePidStatCpuUs(raw2) {
+  const close = raw2.lastIndexOf(")");
+  if (close === -1) return null;
+  const after = raw2.slice(close + 2).split(" ");
+  const utime = Number(after[11]);
+  const stime = Number(after[12]);
+  if (!Number.isFinite(utime) || !Number.isFinite(stime)) return null;
+  return (utime + stime) / 100 * 1e6;
+}
+function readPidCpuUs(pid) {
+  if (process.platform !== "linux") return null;
+  try {
+    return parsePidStatCpuUs(readFileSync(`/proc/${pid}/stat`, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function sampleCpu(nowMs = Date.now()) {
+  for (const e of entries.values()) {
+    if (!e.cpuAttributable) {
+      e.cpuPct = null;
+      continue;
+    }
+    let childUs = 0;
+    for (const pid of [...e.children]) {
+      const us = cpuIo.childCpuUs(pid);
+      if (us === null) {
+        e.children.delete(pid);
+        continue;
+      }
+      childUs += us;
+    }
+    e.lastChildCpuUs = Math.max(e.lastChildCpuUs, childUs);
+    const totalUs = e.cumulativeCpuUs + e.lastChildCpuUs;
+    const p = e.prior;
+    if (p) {
+      const wallUs = (nowMs - p.atMs) * 1e3;
+      e.cpuPct = wallUs > 0 && totalUs >= p.cpuUs ? (totalUs - p.cpuUs) / wallUs * 100 : null;
+    } else {
+      e.cpuPct = null;
+    }
+    e.prior = { cpuUs: totalUs, atMs: nowMs };
+  }
+}
+var processPrior = null;
+function sampleProcessCpu(nowMs = Date.now()) {
+  const cpuUs = cpuIo.ownCpuUs();
+  let processPct = null;
+  if (processPrior) {
+    const wallUs = (nowMs - processPrior.atMs) * 1e3;
+    if (wallUs > 0) processPct = (cpuUs - processPrior.cpuUs) / wallUs * 100;
+  }
+  processPrior = { cpuUs, atMs: nowMs };
+  const rows = [...entries.values()];
+  const measured = rows.filter((e) => e.cpuPct !== null);
+  const attributedPct = measured.length === 0 ? null : measured.reduce((sum, e) => sum + (e.cpuPct ?? 0), 0);
+  const unattributedPct = processPct === null || attributedPct === null ? null : Math.max(0, processPct - attributedPct);
+  return { processPct, attributedPct, unattributedPct };
+}
+function messageOf(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function finish(e, startedAt, cpuStart, cpuAttributable, note, err) {
+  const cpu = process.cpuUsage(cpuStart);
+  e.running = false;
+  e.lastDurationMs = Date.now() - startedAt;
+  e.lastCpuMs = cpuAttributable ? (cpu.user + cpu.system) / 1e3 : null;
+  if (err !== null) {
+    e.lastOutcome = "error";
+    e.lastError = messageOf(err);
+    e.lastNote = null;
+    e.consecutiveFailures += 1;
+    console.error(
+      `${TAG} op=run name=${e.spec.name} outcome=error streak=${e.consecutiveFailures} ms=${e.lastDurationMs} err="${e.lastError}"`
+    );
+    return;
+  }
+  e.lastOutcome = "ok";
+  e.lastError = null;
+  e.lastNote = typeof note === "string" && note.length > 0 ? note : null;
+  e.successCount += 1;
+  e.consecutiveFailures = 0;
+}
+function invoke(e) {
+  if (e.running) {
+    console.warn(`${TAG} op=skip name=${e.spec.name} reason=still-running`);
+    return;
+  }
+  e.running = true;
+  e.runCount += 1;
+  e.lastStartMs = Date.now();
+  const startedAt = e.lastStartMs;
+  const cpuStart = process.cpuUsage();
+  const ownStartUs = cpuIo.ownCpuUs();
+  const ctx = {
+    child: (pid) => {
+      if (typeof pid === "number" && Number.isFinite(pid)) e.children.add(pid);
+    }
+  };
+  let result;
+  try {
+    result = e.spec.run(ctx);
+  } catch (err) {
+    e.cumulativeCpuUs += Math.max(0, cpuIo.ownCpuUs() - ownStartUs);
+    finish(e, startedAt, cpuStart, true, null, err);
+    return;
+  }
+  if (result instanceof Promise) {
+    e.cpuAttributable = false;
+    result.then(
+      (note) => finish(e, startedAt, cpuStart, false, note, null),
+      (err) => finish(e, startedAt, cpuStart, false, null, err)
+    );
+    return;
+  }
+  e.cumulativeCpuUs += Math.max(0, cpuIo.ownCpuUs() - ownStartUs);
+  finish(e, startedAt, cpuStart, true, result, null);
+}
+function registerLoop(spec) {
+  if (entries.has(spec.name)) {
+    throw new Error(`${TAG} loop "${spec.name}" is already registered`);
+  }
+  const e = {
+    spec,
+    armedAtMs: Date.now(),
+    lastStartMs: null,
+    lastDurationMs: null,
+    lastCpuMs: null,
+    lastOutcome: null,
+    lastError: null,
+    lastNote: null,
+    runCount: 0,
+    successCount: 0,
+    consecutiveFailures: 0,
+    running: false,
+    timers: [],
+    cumulativeCpuUs: 0,
+    cpuAttributable: true,
+    children: /* @__PURE__ */ new Set(),
+    lastChildCpuUs: 0,
+    prior: null,
+    cpuPct: null
+  };
+  entries.set(spec.name, e);
+  const interval = setInterval(() => invoke(e), spec.intervalMs);
+  if (typeof interval.unref === "function") interval.unref();
+  e.timers.push(interval);
+  console.log(
+    `${TAG} op=arm name=${spec.name} intervalMs=${spec.intervalMs} firstRunMs=${spec.firstRunDelayMs ?? "interval"} detached=${spec.detached === true} armed=${entries.size}`
+  );
+  if (spec.firstRunDelayMs === 0) {
+    invoke(e);
+  } else if (spec.firstRunDelayMs !== void 0) {
+    const first = setTimeout(() => invoke(e), spec.firstRunDelayMs);
+    if (typeof first.unref === "function") first.unref();
+    e.timers.push(first);
+  }
+  let stopped = false;
+  return () => {
+    if (stopped) return;
+    stopped = true;
+    for (const t of e.timers) clearInterval(t);
+    if (entries.get(spec.name) === e) entries.delete(spec.name);
+    console.log(`${TAG} op=disarm name=${spec.name} armed=${entries.size}`);
+  };
+}
+function stateOf(e, nowMs) {
+  if (e.lastStartMs === null) {
+    return nowMs - e.armedAtMs < e.spec.intervalMs ? "waiting" : "never-run";
+  }
+  const overdue = nowMs - e.lastStartMs > e.spec.intervalMs * STALL_INTERVALS;
+  if (overdue) return "stalled";
+  if (e.running) return "running";
+  if (e.successCount === 0) return "never-succeeded";
+  if (e.consecutiveFailures > 0) return "failing";
+  return "ok";
+}
+function nextDueOf(e, nowMs) {
+  const elapsed = Math.max(0, nowMs - e.armedAtMs);
+  const ticks = Math.floor(elapsed / e.spec.intervalMs) + 1;
+  return e.armedAtMs + ticks * e.spec.intervalMs;
+}
+function listLoops(nowMs = Date.now()) {
+  return [...entries.values()].map((e) => ({
+    name: e.spec.name,
+    intervalMs: e.spec.intervalMs,
+    detached: e.spec.detached === true,
+    armedAtMs: e.armedAtMs,
+    lastStartMs: e.lastStartMs,
+    lastDurationMs: e.lastDurationMs,
+    lastCpuMs: e.lastCpuMs,
+    cpuPct: e.cpuPct,
+    cpuAttributable: e.cpuAttributable,
+    lastOutcome: e.lastOutcome,
+    lastError: e.lastError,
+    lastNote: e.lastNote,
+    runCount: e.runCount,
+    successCount: e.successCount,
+    consecutiveFailures: e.consecutiveFailures,
+    running: e.running,
+    state: stateOf(e, nowMs),
+    nextDueMs: nextDueOf(e, nowMs)
+  }));
+}
+function armedCount() {
+  return entries.size;
+}
+
 // app/lib/paths.ts
 import { homedir } from "os";
 import { resolve, join } from "path";
-import { existsSync, readFileSync } from "fs";
+import { existsSync, readFileSync as readFileSync2 } from "fs";
 var configDirName = ".maxy";
 var commercialMode = false;
 var bundleMode = "none";
@@ -2676,7 +2897,7 @@ if (platformRoot) {
   if (existsSync(brandPath)) {
     let brand;
     try {
-      brand = JSON.parse(readFileSync(brandPath, "utf-8"));
+      brand = JSON.parse(readFileSync2(brandPath, "utf-8"));
     } catch (err) {
       const detail = (err instanceof Error ? err.message : String(err)).slice(0, 160);
       console.error(`[paths] error reason=brand-config-missing path=${brandPath} detail="parse failed: ${detail.replace(/"/g, "'")}"`);
@@ -2792,7 +3013,7 @@ function websockifyLog(event, fields = {}) {
 
 // ../lib/admin-access-password/src/index.ts
 import { scrypt, randomBytes, timingSafeEqual } from "crypto";
-import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync, renameSync, unlinkSync, appendFileSync as appendFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync3, writeFileSync, renameSync, unlinkSync, appendFileSync as appendFileSync2, mkdirSync as mkdirSync2 } from "fs";
 import { dirname } from "path";
 var SCRYPT_N = 16384;
 var SCRYPT_R = 8;
@@ -2848,7 +3069,7 @@ async function matchesHash(password, stored) {
 }
 function readUsers(usersFile) {
   if (!existsSync2(usersFile)) return [];
-  const raw2 = readFileSync2(usersFile, "utf-8").trim();
+  const raw2 = readFileSync3(usersFile, "utf-8").trim();
   if (!raw2) return [];
   const parsed = JSON.parse(raw2);
   if (!Array.isArray(parsed)) throw new Error("users.json is not an array");
@@ -2920,7 +3141,7 @@ function accessStoreUnreadable(usersFile) {
 }
 function migrateLegacyRemotePassword(usersFile, legacyFile, ownerUserId, audit) {
   if (!existsSync2(legacyFile)) return "noop-no-legacy";
-  const legacy = readFileSync2(legacyFile, "utf-8").trim();
+  const legacy = readFileSync3(legacyFile, "utf-8").trim();
   const users = readUsers(usersFile);
   const idx = users.findIndex((u) => u.userId === ownerUserId);
   if (idx === -1) return "noop-no-owner";
@@ -2942,7 +3163,7 @@ function migrateLegacyRemotePassword(usersFile, legacyFile, ownerUserId, audit)
 }
 function readLegacyRemoteHash(legacyFile) {
   if (!existsSync2(legacyFile)) return null;
-  const raw2 = readFileSync2(legacyFile, "utf-8").trim();
+  const raw2 = readFileSync3(legacyFile, "utf-8").trim();
   return raw2.includes(":") ? raw2 : null;
 }
 
@@ -2961,7 +3182,7 @@ function isPasswordValid(password) {
 
 // app/lib/remote-auth.ts
 import { scrypt as scrypt2, randomBytes as randomBytes2, timingSafeEqual as timingSafeEqual2, createHmac } from "crypto";
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3 } from "fs";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3 } from "fs";
 import { dirname as dirname2 } from "path";
 var SCRYPT_N2 = 16384;
 var SCRYPT_R2 = 8;
@@ -3007,7 +3228,7 @@ var cachedSecret = null;
 function getSecret() {
   if (cachedSecret) return cachedSecret;
   try {
-    const hex2 = readFileSync3(REMOTE_SESSION_SECRET_FILE, "utf-8").trim();
+    const hex2 = readFileSync4(REMOTE_SESSION_SECRET_FILE, "utf-8").trim();
     if (hex2.length === SECRET_BYTES * 2) {
       cachedSecret = Buffer.from(hex2, "hex");
       return cachedSecret;
@@ -3020,7 +3241,7 @@ function getSecret() {
     writeFileSync2(REMOTE_SESSION_SECRET_FILE, fresh, { mode: 384, flag: "wx" });
   } catch {
   }
-  const hex = readFileSync3(REMOTE_SESSION_SECRET_FILE, "utf-8").trim();
+  const hex = readFileSync4(REMOTE_SESSION_SECRET_FILE, "utf-8").trim();
   cachedSecret = Buffer.from(hex, "hex");
   return cachedSecret;
 }
@@ -3151,14 +3372,21 @@ function recordFailedAttempt(client) {
 function clearRateLimit(client) {
   rateLimitMap.delete(bucketKey(client));
 }
-setInterval(() => {
-  const now = Date.now();
-  for (const [key, rec] of rateLimitMap) {
-    if (rec.lockedUntil > 0 && rec.lockedUntil <= now) {
-      rateLimitMap.delete(key);
+registerLoop({
+  name: "rate-limit-cleanup",
+  intervalMs: 15 * 60 * 1e3,
+  run: () => {
+    const now = Date.now();
+    let purged = 0;
+    for (const [key, rec] of rateLimitMap) {
+      if (rec.lockedUntil > 0 && rec.lockedUntil <= now) {
+        rateLimitMap.delete(key);
+        purged += 1;
+      }
     }
+    return `purged ${purged}, ${rateLimitMap.size} tracked`;
   }
-}, 15 * 60 * 1e3).unref();
+});
 function renderLoginPage(opts) {
   const error = opts?.error ?? "";
   const lockout = opts?.lockoutSeconds ?? 0;
@@ -3678,13 +3906,13 @@ function classifyHost(host, operatorDomains2, isPublicHost) {
 import { watchFile } from "fs";
 
 // app/lib/operator-domains.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
 import { dirname as dirname3, resolve as resolve3 } from "path";
 var OPERATOR_DOMAINS_PATH = resolve3(MAXY_DIR, "operator-domains.json");
 function loadOperatorDomains() {
   if (!existsSync3(OPERATOR_DOMAINS_PATH)) return /* @__PURE__ */ new Set();
   try {
-    const parsed = JSON.parse(readFileSync4(OPERATOR_DOMAINS_PATH, "utf-8"));
+    const parsed = JSON.parse(readFileSync5(OPERATOR_DOMAINS_PATH, "utf-8"));
     if (!Array.isArray(parsed)) return /* @__PURE__ */ new Set();
     return new Set(parsed.filter((h) => typeof h === "string"));
   } catch {
@@ -3711,11 +3939,11 @@ function getOperatorDomains() {
 
 // app/lib/claude-agent/account.ts
 import { resolve as resolve4 } from "path";
-import { readFileSync as readFileSync6, readdirSync, existsSync as existsSync5, statSync } from "fs";
+import { readFileSync as readFileSync7, readdirSync, existsSync as existsSync5, statSync } from "fs";
 
 // ../lib/brand-templating/src/index.ts
 import { join as join2 } from "path";
-import { existsSync as existsSync4, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync6 } from "fs";
 var PLACEHOLDER = "{{productName}}";
 var cachedProductName = null;
 function brandJsonPath() {
@@ -3735,7 +3963,7 @@ function getBrandProductName() {
   }
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync5(path, "utf-8"));
+    parsed = JSON.parse(readFileSync6(path, "utf-8"));
   } catch (err) {
     throw new Error(
       `[skill-loader] brand.json unreadable at ${path}: ${err instanceof Error ? err.message : String(err)}`
@@ -3782,8 +4010,8 @@ var _stubDirsLoggedThisBoot = /* @__PURE__ */ new Set();
 function listValidAccounts() {
   if (!existsSync5(ACCOUNTS_DIR)) return [];
   const out = [];
-  const entries = readdirSync(ACCOUNTS_DIR, { withFileTypes: true });
-  for (const entry of entries) {
+  const entries2 = readdirSync(ACCOUNTS_DIR, { withFileTypes: true });
+  for (const entry of entries2) {
     if (!entry.isDirectory()) continue;
     if (entry.name.startsWith(".")) continue;
     const accountDir = resolve4(ACCOUNTS_DIR, entry.name);
@@ -3799,7 +4027,7 @@ function listValidAccounts() {
     }
     let config;
     try {
-      config = JSON.parse(readFileSync6(configPath, "utf-8"));
+      config = JSON.parse(readFileSync7(configPath, "utf-8"));
     } catch {
       console.error(
         `[platform] accounts-state CORRUPT-JSON id=${entry.name} \u2014 account.json failed to parse; treating as stub`
@@ -3818,7 +4046,7 @@ function resolveAccount() {
   let usersJsonUserId = null;
   if (existsSync5(USERS_FILE)) {
     try {
-      const raw2 = readFileSync6(USERS_FILE, "utf-8").trim();
+      const raw2 = readFileSync7(USERS_FILE, "utf-8").trim();
       if (raw2) {
         const users = JSON.parse(raw2);
         if (users.length > 0) {
@@ -3828,13 +4056,13 @@ function resolveAccount() {
     } catch {
     }
   }
-  const entries = readdirSync(ACCOUNTS_DIR, { withFileTypes: true });
+  const entries2 = readdirSync(ACCOUNTS_DIR, { withFileTypes: true });
   let fallback = null;
-  for (const entry of entries) {
+  for (const entry of entries2) {
     if (!entry.isDirectory()) continue;
     const configPath = resolve4(ACCOUNTS_DIR, entry.name, "account.json");
     if (!existsSync5(configPath)) continue;
-    const raw2 = readFileSync6(configPath, "utf-8");
+    const raw2 = readFileSync7(configPath, "utf-8");
     let config;
     try {
       config = JSON.parse(raw2);
@@ -3869,7 +4097,7 @@ function resolveAccount() {
 function readAgentFile(accountDir, agentName, filename) {
   const filePath = resolve4(accountDir, "agents", agentName, filename);
   if (!existsSync5(filePath)) return null;
-  const raw2 = readFileSync6(filePath, "utf-8");
+  const raw2 = readFileSync7(filePath, "utf-8");
   if (filename.endsWith(".md")) {
     return substituteBrandPlaceholders(raw2, filePath);
   }
@@ -3898,7 +4126,7 @@ function resolveDefaultAgentSlug(accountDir) {
   }
   let config;
   try {
-    config = JSON.parse(readFileSync6(configPath, "utf-8"));
+    config = JSON.parse(readFileSync7(configPath, "utf-8"));
   } catch (err) {
     console.error("[agent-resolve] failed to read account.json:", err);
     return null;
@@ -3973,14 +4201,14 @@ function resolveAgentConfig(accountDir, agentName) {
     const knowledgeMtime = statSync(knowledgePath).mtimeMs;
     const summaryMtime = statSync(summaryPath).mtimeMs;
     if (summaryMtime >= knowledgeMtime) {
-      knowledge = readFileSync6(summaryPath, "utf-8");
+      knowledge = readFileSync7(summaryPath, "utf-8");
     } else {
       console.warn(`[agent-config] ${agentName}: KNOWLEDGE-SUMMARY.md is stale (KNOWLEDGE.md is newer) \u2014 using full knowledge`);
-      knowledge = readFileSync6(knowledgePath, "utf-8");
+      knowledge = readFileSync7(knowledgePath, "utf-8");
     }
     knowledgeBaked = true;
   } else if (hasKnowledge) {
-    knowledge = readFileSync6(knowledgePath, "utf-8");
+    knowledge = readFileSync7(knowledgePath, "utf-8");
     knowledgeBaked = true;
   }
   let budget = null;
@@ -4074,7 +4302,7 @@ function getSessionKeyBySessionId(_sessionId) {
 // app/lib/claude-agent/plugin-manifest.ts
 import { resolve as resolve5, join as join3 } from "path";
 import {
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync8,
   writeFileSync as writeFileSync4,
   readdirSync as readdirSync2,
   existsSync as existsSync6,
@@ -4096,7 +4324,7 @@ function readBundleSubPlugins(bundlePath) {
   if (!existsSync6(bundlePath)) return [];
   let raw2;
   try {
-    raw2 = readFileSync7(bundlePath, "utf-8");
+    raw2 = readFileSync8(bundlePath, "utf-8");
   } catch {
     return [];
   }
@@ -4118,14 +4346,14 @@ function readBundleSubPlugins(bundlePath) {
   return subs;
 }
 function walkPremiumBundles() {
-  const TAG = "[premium-auto-deliver]";
+  const TAG2 = "[premium-auto-deliver]";
   if (BUNDLE_MODE === "none") {
-    console.log(`${TAG} gate brand=${BRAND_NAME} mode=none bundles=[]`);
+    console.log(`${TAG2} gate brand=${BRAND_NAME} mode=none bundles=[]`);
     return [];
   }
   const onDisk = walkPremiumBundlesOnDisk();
   if (BUNDLE_MODE === "all") {
-    console.log(`${TAG} gate brand=${BRAND_NAME} mode=all bundles=[${onDisk.map((b) => b.bundle).join(",")}]`);
+    console.log(`${TAG2} gate brand=${BRAND_NAME} mode=all bundles=[${onDisk.map((b) => b.bundle).join(",")}]`);
     return onDisk;
   }
   const allow = new Set(BUNDLE_ALLOWLIST);
@@ -4133,21 +4361,21 @@ function walkPremiumBundles() {
   const onDiskNames = new Set(onDisk.map((b) => b.bundle));
   const missing = BUNDLE_ALLOWLIST.filter((name) => !onDiskNames.has(name));
   console.log(
-    `${TAG} gate brand=${BRAND_NAME} mode=allowlist bundles=[${kept.map((b) => b.bundle).join(",")}]` + (missing.length > 0 ? ` missing=[${missing.join(",")}]` : "")
+    `${TAG2} gate brand=${BRAND_NAME} mode=allowlist bundles=[${kept.map((b) => b.bundle).join(",")}]` + (missing.length > 0 ? ` missing=[${missing.join(",")}]` : "")
   );
   return kept;
 }
 function walkPremiumBundlesOnDisk() {
   const stagingRoot = resolve5(PLATFORM_ROOT2, "../premium-plugins");
   if (!existsSync6(stagingRoot)) return [];
-  let entries;
+  let entries2;
   try {
-    entries = readdirSync2(stagingRoot);
+    entries2 = readdirSync2(stagingRoot);
   } catch {
     return [];
   }
   const result = [];
-  for (const bundle of entries) {
+  for (const bundle of entries2) {
     if (bundle.startsWith(".")) continue;
     const bundleDir = resolve5(stagingRoot, bundle);
     try {
@@ -4161,7 +4389,7 @@ function walkPremiumBundlesOnDisk() {
   return result;
 }
 function reapDuplicateFlatPremiumSubs(bundles, stagingRoot, pluginsDir) {
-  const TAG = "[premium-auto-deliver]";
+  const TAG2 = "[premium-auto-deliver]";
   for (const { bundle, subs } of bundles) {
     const isBundle = existsSync6(join3(stagingRoot, bundle, "BUNDLE.md"));
     for (const sub of subs) {
@@ -4169,25 +4397,25 @@ function reapDuplicateFlatPremiumSubs(bundles, stagingRoot, pluginsDir) {
       const flatDir = resolve5(pluginsDir, sub);
       const flatManifest = resolve5(flatDir, "PLUGIN.md");
       if (!existsSync6(premiumManifest) || !existsSync6(flatManifest)) continue;
-      const premiumSha = createHash2("sha256").update(readFileSync7(premiumManifest)).digest("hex");
-      const flatSha = createHash2("sha256").update(readFileSync7(flatManifest)).digest("hex");
+      const premiumSha = createHash2("sha256").update(readFileSync8(premiumManifest)).digest("hex");
+      const flatSha = createHash2("sha256").update(readFileSync8(flatManifest)).digest("hex");
       if (isBundle) {
         if (premiumSha === flatSha) {
           try {
             rmSync(flatDir, { recursive: true });
-            console.log(`${TAG} reaped sub=${sub} reason=duplicate-of-premium-tree`);
+            console.log(`${TAG2} reaped sub=${sub} reason=duplicate-of-premium-tree`);
           } catch (err) {
-            console.log(`${TAG} reap-failed sub=${sub} err=${err instanceof Error ? err.message : String(err)}`);
+            console.log(`${TAG2} reap-failed sub=${sub} err=${err instanceof Error ? err.message : String(err)}`);
           }
         } else {
-          console.log(`${TAG} flat-copy-divergent sub=${sub} action=skip-keep`);
+          console.log(`${TAG2} flat-copy-divergent sub=${sub} action=skip-keep`);
         }
       } else {
         try {
           rmSync(flatDir, { recursive: true });
-          console.log(`${TAG} reaped standalone=${sub} matches-source=${flatSha === premiumSha}`);
+          console.log(`${TAG2} reaped standalone=${sub} matches-source=${flatSha === premiumSha}`);
         } catch (err) {
-          console.log(`${TAG} reap-failed standalone=${sub} err=${err instanceof Error ? err.message : String(err)}`);
+          console.log(`${TAG2} reap-failed standalone=${sub} err=${err instanceof Error ? err.message : String(err)}`);
         }
       }
     }
@@ -4201,7 +4429,7 @@ function autoDeliverPremiumPlugins() {
   reapDuplicateFlatPremiumSubs(bundles, stagingRoot, pluginsDir);
 }
 function reconcileEnabledPlugins(accountDir, config, accountId) {
-  const TAG = "[premium-auto-deliver]";
+  const TAG2 = "[premium-auto-deliver]";
   if (!accountDir || !config) return;
   const bundles = walkPremiumBundles();
   const stagingRoot = resolve5(PLATFORM_ROOT2, "../premium-plugins");
@@ -4226,19 +4454,19 @@ function reconcileEnabledPlugins(accountDir, config, accountId) {
     added.push(sub);
   }
   console.log(
-    `${TAG} stamp accountId=${accountId ?? "unknown"} brand=${BRAND_NAME} mode=${BUNDLE_MODE} bundles=[${bundleNames.join(",")}] added=[${added.join(",")}]`
+    `${TAG2} stamp accountId=${accountId ?? "unknown"} brand=${BRAND_NAME} mode=${BUNDLE_MODE} bundles=[${bundleNames.join(",")}] added=[${added.join(",")}]`
   );
   if (added.length === 0) return;
   const merged = [...currentSet];
   const configPath = resolve5(accountDir, "account.json");
   try {
-    const raw2 = readFileSync7(configPath, "utf-8");
+    const raw2 = readFileSync8(configPath, "utf-8");
     const parsed = JSON.parse(raw2);
     parsed.enabledPlugins = merged;
     writeFileSync4(configPath, JSON.stringify(parsed, null, 2) + "\n");
     config.enabledPlugins = merged;
   } catch (err) {
-    console.error(`${TAG} enabled-stamp write failed: ${err instanceof Error ? err.message : String(err)}`);
+    console.error(`${TAG2} enabled-stamp write failed: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
 function reconcileEnabledPluginsForAccounts(accounts) {
@@ -4247,7 +4475,7 @@ function reconcileEnabledPluginsForAccounts(accounts) {
   }
 }
 function cleanupLeakedPremiumSubs(accountDir, config, accountId) {
-  const TAG = "[premium-auto-deliver]";
+  const TAG2 = "[premium-auto-deliver]";
   if (!accountDir || !config) return;
   if (BUNDLE_MODE === "all") return;
   const current = Array.isArray(config.enabledPlugins) ? config.enabledPlugins : [];
@@ -4268,14 +4496,14 @@ function cleanupLeakedPremiumSubs(accountDir, config, accountId) {
   if (removed.length === 0) return;
   const configPath = resolve5(accountDir, "account.json");
   try {
-    const raw2 = readFileSync7(configPath, "utf-8");
+    const raw2 = readFileSync8(configPath, "utf-8");
     const parsed = JSON.parse(raw2);
     parsed.enabledPlugins = kept;
     writeFileSync4(configPath, JSON.stringify(parsed, null, 2) + "\n");
     config.enabledPlugins = kept;
-    console.log(`${TAG} cleanup accountId=${accountId ?? "unknown"} removed=[${removed.join(",")}]`);
+    console.log(`${TAG2} cleanup accountId=${accountId ?? "unknown"} removed=[${removed.join(",")}]`);
   } catch (err) {
-    console.error(`${TAG} cleanup write failed accountId=${accountId ?? "unknown"}: ${err instanceof Error ? err.message : String(err)}`);
+    console.error(`${TAG2} cleanup write failed accountId=${accountId ?? "unknown"}: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
 
@@ -4319,7 +4547,7 @@ function requirePortEnv(envName, options = {}) {
 // app/lib/neo4j-store.ts
 import neo4j from "neo4j-driver";
 import { randomUUID } from "crypto";
-import { readFileSync as readFileSync8, readdirSync as readdirSync3, existsSync as existsSync7, openSync, readSync, closeSync, statSync as statSync3 } from "fs";
+import { readFileSync as readFileSync9, readdirSync as readdirSync3, existsSync as existsSync7, openSync, readSync, closeSync, statSync as statSync3 } from "fs";
 import { resolve as resolve6 } from "path";
 var PLATFORM_ROOT3 = process.env.MAXY_PLATFORM_ROOT ?? resolve6(process.cwd(), "..");
 var driver = null;
@@ -4327,7 +4555,7 @@ function readPassword() {
   if (process.env.NEO4J_PASSWORD) return process.env.NEO4J_PASSWORD;
   const passwordFile = resolve6(PLATFORM_ROOT3, "config/.neo4j-password");
   try {
-    return readFileSync8(passwordFile, "utf-8").trim();
+    return readFileSync9(passwordFile, "utf-8").trim();
   } catch {
     throw new Error(
       `Neo4j password not found. Expected at ${passwordFile} or in NEO4J_PASSWORD env var.`
@@ -5444,7 +5672,7 @@ function loadEnabledPluginProfileKeys(accountId) {
   if (!existsSync7(accountFile)) return {};
   let enabled;
   try {
-    const raw2 = readFileSync8(accountFile, "utf-8");
+    const raw2 = readFileSync9(accountFile, "utf-8");
     const parsed = JSON.parse(raw2);
     enabled = Array.isArray(parsed.enabledPlugins) ? parsed.enabledPlugins.filter((p) => typeof p === "string") : [];
   } catch (err) {
@@ -5459,7 +5687,7 @@ function loadEnabledPluginProfileKeys(accountId) {
     if (!existsSync7(manifestPath)) continue;
     let manifest;
     try {
-      manifest = readFileSync8(manifestPath, "utf-8");
+      manifest = readFileSync9(manifestPath, "utf-8");
     } catch {
       continue;
     }
@@ -5717,11 +5945,11 @@ async function projectAgent(accountId, accountDir, slug) {
       );
       return;
     }
-    config = JSON.parse(readFileSync8(configPath, "utf-8"));
+    config = JSON.parse(readFileSync9(configPath, "utf-8"));
     for (const { filename, role } of AGENT_FILE_ROLES) {
       const filePath = resolve6(agentDir, filename);
       if (!existsSync7(filePath)) continue;
-      const body = readFileSync8(filePath, "utf-8");
+      const body = readFileSync9(filePath, "utf-8");
       presentRoles.push({ role, body, edge: ROLE_TO_EDGE[role] });
     }
   } catch (err) {
@@ -5971,6 +6199,11 @@ export {
   Hono2 as Hono,
   getRequestListener,
   serve,
+  sampleCpu,
+  sampleProcessCpu,
+  registerLoop,
+  listLoops,
+  armedCount,
   MAXY_DIR,
   BRAND_NAME,
   COMMERCIAL_MODE,

package/payload/server/maxy-edge.js

@@ -16,7 +16,7 @@ import {
   sanitizeClientCorrId,
   vncLog,
   websockifyLog
-} from "./chunk-Y6V45R6M.js";
+} from "./chunk-JECAP3Z2.js";
 import "./chunk-PFF6I7KP.js";
 
 // server/edge.ts