@inerrata-corporation/errata 2.0.2-dev.1130 → 2.0.2-dev.1166

package/errata.mjs

@@ -22976,6 +22976,14 @@ function renderSnapshot(s) {
     );
     lines.push("");
   }
+  if (s.daemonDistress) {
+    const mins = Math.max(1, Math.round((Date.now() - s.daemonDistress.sinceTs) / 6e4));
+    lines.push("### \u{1F6A8} errata daemon distress");
+    lines.push(
+      `${s.daemonDistress.body} (ongoing ~${mins} min). TELL YOUR USER about this now \u2014 the daemon cannot fix everything itself, and this line may be its only witness. \`errata status\` has detail; a daemon restart (\`errata stop\` then \`errata start\`) is safe mid-session.`
+    );
+    lines.push("");
+  }
   if (s.needsRevisit.length > 0) {
     lines.push("### \u26A0\uFE0F Needs revisit \u2014 a fact these rested on changed");
     lines.push(
@@ -23288,6 +23296,7 @@ function assembleAgentContext(opts) {
   });
   if (opts.edgeElicitation) snapshot.edgeElicitation = opts.edgeElicitation;
   if (opts.pendingUpdate) snapshot.pendingUpdate = opts.pendingUpdate;
+  if (opts.daemonDistress) snapshot.daemonDistress = opts.daemonDistress;
   if (opts.reviewItems?.length) snapshot.reviewItems = [...opts.reviewItems];
   if (opts.statedIntent) snapshot.statedIntent = opts.statedIntent;
   if (opts.remote && opts.remote.length > 0) {
@@ -24650,6 +24659,7 @@ function defaultConfig() {
     // user opts into sync at all.
     consent: { sync: false, telemetry: false, contributePackages: true },
     notifications: true,
+    opsNotices: false,
     onboardedAt: null,
     machineId: null,
     updateChannel: "dev",
@@ -56427,7 +56437,8 @@ var TITLES = {
   "hotspot-problem": "Errata \xB7 high-impact problem",
   "index-started": "Errata \xB7 indexing\u2026",
   "index-completed": "Errata \xB7 index ready \u2713",
-  "mechanism-stalled": "Errata \xB7 a mechanism is not working"
+  "mechanism-stalled": "Errata \xB7 a mechanism is not working",
+  "daemon-distress": "Errata \xB7 daemon health \u26A0"
 };
 var lastFired = /* @__PURE__ */ new Map();
 var THROTTLE_MS = 3e4;
@@ -56443,6 +56454,14 @@ function notifyEvent(kind, body2, opts = {}) {
   } catch {
   }
 }
+function notifyOpsEvent(kind, body2, opts = {}) {
+  try {
+    if (!loadConfig().opsNotices) return;
+  } catch {
+    return;
+  }
+  notifyEvent(kind, body2, opts);
+}
 function notifyTick(delta) {
   const { problemsResolved, reviewsTriggered } = delta;
   if (problemsResolved > 0)
@@ -56532,11 +56551,30 @@ function startLoopLagMonitor(thresholdMs = 1e3) {
 }
 
 // src/watch-census.ts
-var census = { dispatched: 0, emitted: 0, logged: 0, rejected: 0, since: Date.now() };
+var census = {
+  dispatched: 0,
+  emitted: 0,
+  logged: 0,
+  rejected: 0,
+  since: Date.now(),
+  breakerRecycles: 0,
+  breakerQuarantined: [],
+  topOffender: null
+};
+var QUARANTINE_LIST_CAP = 8;
 var noteWatchDispatched = () => void census.dispatched++;
 var noteWatchEmitted = () => void census.emitted++;
 var noteWatchLogged = () => void census.logged++;
 var noteWatchRejected = () => void census.rejected++;
+var noteBreakerRecycle = (_path) => void census.breakerRecycles++;
+var noteBreakerQuarantine = (path2) => {
+  if (!census.breakerQuarantined.includes(path2) && census.breakerQuarantined.length < QUARANTINE_LIST_CAP) {
+    census.breakerQuarantined.push(path2);
+  }
+};
+var noteWindowOffender = (path2, count, windowMs) => {
+  census.topOffender = { path: path2, count, windowMs, at: Date.now() };
+};
 function watchCensus() {
   return { ...census };
 }
@@ -56544,9 +56582,14 @@ function watchCensusLine(c = watchCensus()) {
   if (c.dispatched === 0 && c.emitted === 0) return null;
   const mins = Math.max(1, Math.round((Date.now() - c.since) / 6e4));
   const perMin = Math.round(c.dispatched / mins);
-  const base = `${c.dispatched} OS event(s) \u2192 ${c.logged} logged (${perMin}/min, ${c.rejected} rejected here)`;
-  if (c.logged === 0 && c.dispatched > 500) {
-    return `${base}  \u26A0 watcher is doing work with NO output \u2014 a watch target likely contains an ignored tree`;
+  let base = `${c.dispatched} OS event(s) \u2192 ${c.logged} logged (${perMin}/min, ${c.rejected} rejected here)`;
+  if (c.breakerRecycles > 0 || c.breakerQuarantined.length > 0) {
+    const q = c.breakerQuarantined.length > 0 ? `, ${c.breakerQuarantined.length} quarantined` : "";
+    base += ` \xB7 breaker: ${c.breakerRecycles} recycled${q}`;
+  }
+  if (c.dispatched > 500 && c.dispatched / Math.max(c.logged, 1) > 1e4) {
+    const top = c.topOffender ? ` \u2014 top: ${c.topOffender.path} (${c.topOffender.count}/${Math.round(c.topOffender.windowMs / 1e3)}s)` : "";
+    return `${base}  \u26A0 watcher is doing work with NO output \u2014 a watch target likely contains an ignored tree${top}`;
   }
   return base;
 }
@@ -56588,6 +56631,11 @@ function createLivenessWatch(deps) {
           watchEmitted: watch2.emitted,
           watchLogged: watch2.logged,
           watchRejected: watch2.rejected,
+          // HZ-watch-breaker: a recycle count trending upward across hours is a
+          // handle that keeps wedging — the restart-survivable trace the 8-16
+          // phantom-rename storm never left.
+          watchBreakerRecycles: watch2.breakerRecycles,
+          watchBreakerQuarantined: watch2.breakerQuarantined.length,
           // Concurrency and the longest single holder — the two readings that
           // named the 6017s zombie pass. A pass legitimately running for hours
           // and one wedged forever look identical without a trend.
@@ -56612,8 +56660,108 @@ function createLivenessWatch(deps) {
   };
 }
 
+// src/watch-breaker.ts
+function numEnv3(key, fallback) {
+  const n = Number(process.env[key]);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+var BREAKER_WINDOW_MS = numEnv3("ERRATA_WATCH_BREAKER_WINDOW_MS", 1e4);
+var BREAKER_TRIP_SELF_EVENTS = numEnv3("ERRATA_WATCH_BREAKER_TRIP", 1e3);
+var BREAKER_MAX_RECYCLES = numEnv3("ERRATA_WATCH_BREAKER_RECYCLES", 2);
+var BREAKER_REWEDGE_TTL_MS = numEnv3("ERRATA_WATCH_BREAKER_TTL_MS", 6e5);
+var BREAKER_READD_DELAY_MS = numEnv3("ERRATA_WATCH_BREAKER_READD_MS", 250);
+var OFFENDER_FLOOR = 100;
+function normalizeWatchPath(p) {
+  let s = p.startsWith("\\\\?\\") ? p.slice(4) : p;
+  s = s.replace(/\\/g, "/");
+  if (s.length > 1 && s.endsWith("/")) s = s.slice(0, -1);
+  return process.platform === "win32" ? s.toLowerCase() : s;
+}
+function createWatchBreaker(deps) {
+  const now = deps.now ?? Date.now;
+  const say = deps.onAction ?? (() => {
+  });
+  const windows2 = /* @__PURE__ */ new Map();
+  let windowStart = now();
+  const recycleHistory = /* @__PURE__ */ new Map();
+  const quarantined = /* @__PURE__ */ new Set();
+  const pendingReadds = /* @__PURE__ */ new Set();
+  const rotate = (t) => {
+    let top = null;
+    for (const [path2, w] of windows2) {
+      if (w.dispatched >= OFFENDER_FLOOR && (!top || w.dispatched > top.count)) {
+        top = { path: path2, count: w.dispatched };
+      }
+    }
+    if (top) noteWindowOffender(top.path, top.count, BREAKER_WINDOW_MS);
+    windows2.clear();
+    windowStart = t;
+  };
+  const trip = (path2, t) => {
+    const history = (recycleHistory.get(path2) ?? []).filter(
+      (ts) => t - ts < BREAKER_REWEDGE_TTL_MS
+    );
+    if (history.length >= BREAKER_MAX_RECYCLES) {
+      quarantined.add(path2);
+      recycleHistory.delete(path2);
+      try {
+        deps.unwatch(path2);
+      } catch {
+      }
+      noteBreakerQuarantine(path2);
+      say(
+        `QUARANTINED ${path2} \u2014 re-wedged after ${history.length} recycle(s); unwatched for this session (reconcile covers its edits)`
+      );
+      return;
+    }
+    history.push(t);
+    recycleHistory.set(path2, history);
+    try {
+      deps.unwatch(path2);
+    } catch {
+    }
+    const timer = setTimeout(() => {
+      pendingReadds.delete(timer);
+      try {
+        deps.readd(path2);
+      } catch {
+      }
+    }, BREAKER_READD_DELAY_MS);
+    timer.unref?.();
+    pendingReadds.add(timer);
+    noteBreakerRecycle(path2);
+    say(
+      `recycled ${path2} \u2014 ${BREAKER_TRIP_SELF_EVENTS}+ phantom self-events in ${Math.round(BREAKER_WINDOW_MS / 1e3)}s; handle closed + re-created`
+    );
+  };
+  return {
+    onRaw(event, evPath, watchedPath) {
+      if (typeof watchedPath !== "string" || watchedPath.length === 0) return;
+      const t = now();
+      if (t - windowStart >= BREAKER_WINDOW_MS) rotate(t);
+      let w = windows2.get(watchedPath);
+      if (!w) {
+        w = { dispatched: 0, self: 0, tripped: false };
+        windows2.set(watchedPath, w);
+      }
+      w.dispatched++;
+      const self = evPath == null || evPath === "" || typeof evPath === "string" && normalizeWatchPath(evPath) === normalizeWatchPath(watchedPath);
+      if (!self) return;
+      w.self++;
+      if (!w.tripped && !quarantined.has(watchedPath) && w.self >= BREAKER_TRIP_SELF_EVENTS) {
+        w.tripped = true;
+        trip(watchedPath, t);
+      }
+    },
+    stop() {
+      for (const timer of pendingReadds) clearTimeout(timer);
+      pendingReadds.clear();
+    }
+  };
+}
+
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.2-dev.1130" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.2-dev.1166" : "2.0.0-alpha.0";
 var IGNORED_PATH = /[\\/](?:\.git|node_modules|\.errata|\.claude|\.codex|\.cursor|\.turbo|\.next|dist|coverage|test-results|playwright-report|__pycache__)(?:[\\/]|$)/;
 var IGNORED_NOISE = /castalia\.db|eventlog\.sqlite|turn-cursors/;
 var GIT_OP_MUTE_MS = 4e3;
@@ -56745,6 +56893,7 @@ function createWorkspaceEngine(opts) {
   const cloud = opts.cloud;
   const telemetry = new TelemetryRecorder(profile.id, DAEMON_VERSION);
   let watcher = null;
+  let watchBreaker = null;
   let lastActivityTs = Date.now();
   let stopGit = null;
   let flushTimer = null;
@@ -56757,7 +56906,23 @@ function createWorkspaceEngine(opts) {
       ignoreInitial: true,
       persistent: true
     });
-    watcher.on("raw", noteWatchDispatched);
+    watchBreaker = createWatchBreaker({
+      unwatch: (p) => void watcher?.unwatch(p),
+      readd: (p) => void watcher?.add(p),
+      // Toast AND log: the autostarted daemon's stdout is a discarded stream
+      // (the 8-01 unobservability finding), so console alone would make every
+      // production breaker action invisible — the exact gauge-with-no-alarm
+      // shape this mechanism exists to end.
+      onAction: (line) => {
+        console.warn(`[errata] watch-breaker: ${line}`);
+        notifyOpsEvent("daemon-distress", `watch-breaker: ${line}`, { key: `breaker:${profile.id}` });
+      }
+    });
+    watcher.on("raw", (event, evPath, opts2) => {
+      noteWatchDispatched();
+      const watchedPath = opts2 && typeof opts2 === "object" && "watchedPath" in opts2 ? opts2.watchedPath : void 0;
+      watchBreaker?.onRaw(event, evPath, watchedPath);
+    });
     const onFs = (kind) => (path2) => {
       noteWatchEmitted();
       if (IGNORED_PATH.test(path2) || IGNORED_NOISE.test(path2)) {
@@ -57052,6 +57217,7 @@ function createWorkspaceEngine(opts) {
     }) : null;
     const doneRender = prebuilt ? null : markPass(`context-render-inline:${profile.name}`);
     const pendingUpdate = opts.pendingUpdate?.() ?? null;
+    const daemonDistress = opts.daemonDistress?.() ?? null;
     const reviewItems = pickReviewItems();
     const liveIntent = intents.mostRecent(Date.now());
     maybeRefreshIntentPriors(liveIntent ?? null);
@@ -57069,6 +57235,7 @@ function createWorkspaceEngine(opts) {
       ...elicit ? { edgeElicitation: { instruction: PRIOR_TAG_INSTRUCTION } } : {},
       ...prebuilt ? { snapshot: prebuilt } : {},
       ...pendingUpdate ? { pendingUpdate } : {},
+      ...daemonDistress ? { daemonDistress } : {},
       ...reviewItems.length ? { reviewItems } : {},
       ...liveIntent ? {
         statedIntent: {
@@ -58586,6 +58753,7 @@ function createWorkspaceEngine(opts) {
     async stop() {
       if (stopGit) stopGit();
       if (passWorker) await passWorker.stop();
+      if (watchBreaker) watchBreaker.stop();
       if (watcher) await watcher.close();
       if (flushTimer) clearTimeout(flushTimer);
       for (const tmr of diagTimers.values()) clearTimeout(tmr);
@@ -59955,6 +60123,137 @@ function createRootAdopter(deps) {
   };
 }
 
+// src/health-sentinel.ts
+function numEnv4(key, fallback) {
+  const n = Number(process.env[key]);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+var SENTINEL_TICK_MS = numEnv4("ERRATA_SENTINEL_TICK_MS", 3e4);
+var SENTINEL_WINDOW_TICKS = numEnv4("ERRATA_SENTINEL_WINDOW_TICKS", 6);
+var SENTINEL_BURN_CORES = numEnv4("ERRATA_SENTINEL_BURN_CORES", 1.2);
+var SENTINEL_STORM_RATE = numEnv4("ERRATA_SENTINEL_STORM_RATE", 1e3);
+var SENTINEL_STORM_TICKS = numEnv4("ERRATA_SENTINEL_STORM_TICKS", 4);
+var SENTINEL_RENOTIFY_MS = numEnv4("ERRATA_SENTINEL_RENOTIFY_MS", 18e5);
+var SENTINEL_CALM_TICKS = numEnv4("ERRATA_SENTINEL_CALM_TICKS", 2);
+var SENTINEL_TOAST_COOLDOWN_MS = numEnv4("ERRATA_SENTINEL_TOAST_COOLDOWN_MS", 6e5);
+function createHealthSentinel(deps = {}) {
+  const now = deps.now ?? Date.now;
+  const cpuUsage = deps.cpuUsage ?? (() => process.cpuUsage());
+  const readCensus = deps.readCensus ?? (() => {
+    const c = watchCensus();
+    return {
+      dispatched: c.dispatched,
+      logged: c.logged,
+      topOffender: c.topOffender ? { path: c.topOffender.path, count: c.topOffender.count } : null
+    };
+  });
+  const activePasses = deps.activePasses ?? (() => passState().active.map((p) => p.name));
+  const rssMb = deps.rssMb ?? (() => Math.round(process.memoryUsage.rss() / 1048576));
+  const toast = deps.notify ?? ((body2, key) => notifyOpsEvent("daemon-distress", body2, { key }));
+  let prevCpu = cpuUsage();
+  let prevTs = now();
+  let prevDispatched = null;
+  let prevLogged = 0;
+  const coreSamples = [];
+  let stormTicks = 0;
+  let calmTicks = 0;
+  let distress = null;
+  let lastNotifiedAt = 0;
+  const lastToastByKind = /* @__PURE__ */ new Map();
+  const attribution = () => {
+    const parts2 = [];
+    const passes = activePasses();
+    if (passes.length > 0) parts2.push(`active pass: ${passes.join(", ")}`);
+    const c = readCensus();
+    if (c.topOffender) parts2.push(`hottest watch path: ${c.topOffender.path}`);
+    parts2.push(`rss ${rssMb()}MB`);
+    return parts2.join(" \xB7 ");
+  };
+  const maybeToast = (d, t) => {
+    if (t - (lastToastByKind.get(d.kind) ?? 0) < SENTINEL_TOAST_COOLDOWN_MS) return;
+    lastToastByKind.set(d.kind, t);
+    toast(d.headline, d.kind);
+    lastNotifiedAt = t;
+  };
+  const transition = (next) => {
+    const t = now();
+    if (next && !distress) {
+      distress = next;
+      deps.ledger?.("enter", next);
+      maybeToast(next, t);
+      deps.onChange?.(next);
+    } else if (next && distress) {
+      distress.body = next.body;
+      distress.headline = next.headline;
+      if (t - lastNotifiedAt >= SENTINEL_RENOTIFY_MS) maybeToast(distress, t);
+    } else if (!next && distress) {
+      deps.ledger?.("clear", distress);
+      distress = null;
+      deps.onChange?.(null);
+    }
+  };
+  const evaluate = () => {
+    const t = now();
+    const wallMs = Math.max(1, t - prevTs);
+    const cpu = cpuUsage();
+    const cores = (cpu.user + cpu.system - prevCpu.user - prevCpu.system) / 1e3 / wallMs;
+    prevCpu = cpu;
+    prevTs = t;
+    coreSamples.push(cores);
+    if (coreSamples.length > SENTINEL_WINDOW_TICKS) coreSamples.shift();
+    const c = readCensus();
+    const dispatchRate = prevDispatched === null ? 0 : (c.dispatched - prevDispatched) / wallMs * 1e3;
+    const survived = c.logged - prevLogged;
+    prevDispatched = c.dispatched;
+    prevLogged = c.logged;
+    stormTicks = dispatchRate > SENTINEL_STORM_RATE && survived === 0 ? stormTicks + 1 : 0;
+    let wanted = null;
+    if (stormTicks >= SENTINEL_STORM_TICKS) {
+      wanted = {
+        kind: "watch-storm",
+        headline: `errata's file watcher is stuck busy (~${Math.round(dispatchRate)} events/sec with nothing changing) \u2014 run \`errata status\` for detail`,
+        body: `filesystem watcher is processing ~${Math.round(dispatchRate)} events/sec with NOTHING surviving \u2014 a wedged or ignored-tree watch is burning CPU for no signal \xB7 ${attribution()}`,
+        sinceTs: distress?.kind === "watch-storm" ? distress.sinceTs : t
+      };
+    } else {
+      const windowFull = coreSamples.length >= SENTINEL_WINDOW_TICKS;
+      const avgCores = coreSamples.reduce((a, b) => a + b, 0) / Math.max(1, coreSamples.length);
+      if (windowFull && avgCores >= SENTINEL_BURN_CORES && cores >= SENTINEL_BURN_CORES && activePasses().length === 0) {
+        wanted = {
+          kind: "cpu-burn",
+          headline: `errata is using more CPU than expected (${avgCores.toFixed(1)} cores with no work running) \u2014 run \`errata status\` for detail`,
+          body: `sustained CPU with no pass running \u2014 avg ${avgCores.toFixed(1)} cores \xB7 ${attribution()}`,
+          sinceTs: distress?.kind === "cpu-burn" ? distress.sinceTs : t
+        };
+      }
+    }
+    if (wanted) {
+      calmTicks = 0;
+      transition(wanted);
+    } else if (distress) {
+      calmTicks++;
+      if (calmTicks >= SENTINEL_CALM_TICKS) {
+        calmTicks = 0;
+        transition(null);
+      }
+    }
+  };
+  const interval = deps.scheduleTicks === false ? null : setInterval(() => {
+    try {
+      evaluate();
+    } catch {
+    }
+  }, SENTINEL_TICK_MS);
+  interval?.unref?.();
+  return {
+    current: () => distress ? { ...distress } : null,
+    tick: evaluate,
+    stop: () => {
+      if (interval) clearInterval(interval);
+    }
+  };
+}
+
 // src/multi.ts
 var projectSymbolSalts = /* @__PURE__ */ new Map();
 async function resolveProjectSymbolSalt(client, projectId) {
@@ -60099,6 +60398,20 @@ async function startMultiDaemon(opts = {}) {
       for (const r of records) r.engine.markContextDirty();
     }
   }) : null;
+  const healthSentinel = createHealthSentinel({
+    onChange: () => {
+      for (const r of records) r.engine.markContextDirty();
+    },
+    ledger: (event, d) => {
+      const dir = records[0]?.engine.paths.configDir;
+      if (dir) {
+        appendPassLedger(dir, "health-sentinel", 0, {
+          [`distress:${event}:${d.kind}`]: 1,
+          distressSinceTs: d.sinceTs
+        });
+      }
+    }
+  });
   let serverPending = null;
   const boundaryListeners = [];
   let boundaryFlushing = false;
@@ -60193,6 +60506,10 @@ async function startMultiDaemon(opts = {}) {
       reviewUrl: () => `${baseUrl}/ws/${id}/review`,
       sharedStore,
       pendingUpdate: () => serverPending ?? updatePoller?.current() ?? null,
+      // Ops-gated (default OFF): the 🚨 notice reads as "errata broke my
+      // machine" to a non-operator. Detection + ledger run regardless — only
+      // this push surface (and the toast, gated in notifyOpsEvent) is scoped.
+      daemonDistress: () => loadConfig().opsNotices ? healthSentinel.current() : null,
       ...opts.skipWatchers ? { skipWatchers: true } : {}
     });
     const webApp = buildWebUi({
@@ -60281,7 +60598,7 @@ async function startMultiDaemon(opts = {}) {
       registerWorkspace(rec.engine.profile, rec.root);
     } catch {
     }
-    void rec.engine.reindex({ skipEmbed: true }).catch(() => {
+    void rec.engine.reindex({ skipEmbed: true, quiet: rec.engine.store.nodeCount() > 0 }).catch(() => {
     });
     console.log(`[errata] hot-registered ${rec.entry.name} (${rec.id}) \u2014 now watching live`);
     return { attached: true, id: rec.id };
@@ -61199,6 +61516,7 @@ async function startMultiDaemon(opts = {}) {
         (res) => server.close(res)
       );
       updatePoller?.stop();
+      healthSentinel.stop();
       for (const r of records) await r.engine.stop();
       if (consolidateWorker) await consolidateWorker.stop();
       try {
@@ -61954,7 +62272,7 @@ var DEFAULT_CONSOLIDATION_POLICY = {
   quiescenceMs: 6e4
   // sim preferred 60s over 90s (fresher, esp. heavy-code)
 };
-function numEnv3(env2, key, fallback) {
+function numEnv5(env2, key, fallback) {
   const raw2 = env2[key];
   if (raw2 == null || raw2.trim() === "") return fallback;
   const n = Number(raw2);
@@ -61962,12 +62280,12 @@ function numEnv3(env2, key, fallback) {
 }
 function consolidationPolicyFromEnv(env2 = process.env) {
   return {
-    baseFloorMs: numEnv3(env2, "ERRATA_CONSOLIDATE_BASE_FLOOR_MS", DEFAULT_CONSOLIDATION_POLICY.baseFloorMs),
-    dutyFactor: numEnv3(env2, "ERRATA_CONSOLIDATE_DUTY_FACTOR", DEFAULT_CONSOLIDATION_POLICY.dutyFactor),
-    momentumThreshold: numEnv3(env2, "ERRATA_CONSOLIDATE_MOMENTUM", DEFAULT_CONSOLIDATION_POLICY.momentumThreshold),
-    momentumRatio: numEnv3(env2, "ERRATA_CONSOLIDATE_MOMENTUM_RATIO", DEFAULT_CONSOLIDATION_POLICY.momentumRatio),
-    momentumRatioCap: numEnv3(env2, "ERRATA_CONSOLIDATE_MOMENTUM_RATIO_CAP", DEFAULT_CONSOLIDATION_POLICY.momentumRatioCap),
-    quiescenceMs: numEnv3(env2, "ERRATA_CONSOLIDATE_QUIESCENCE_MS", DEFAULT_CONSOLIDATION_POLICY.quiescenceMs)
+    baseFloorMs: numEnv5(env2, "ERRATA_CONSOLIDATE_BASE_FLOOR_MS", DEFAULT_CONSOLIDATION_POLICY.baseFloorMs),
+    dutyFactor: numEnv5(env2, "ERRATA_CONSOLIDATE_DUTY_FACTOR", DEFAULT_CONSOLIDATION_POLICY.dutyFactor),
+    momentumThreshold: numEnv5(env2, "ERRATA_CONSOLIDATE_MOMENTUM", DEFAULT_CONSOLIDATION_POLICY.momentumThreshold),
+    momentumRatio: numEnv5(env2, "ERRATA_CONSOLIDATE_MOMENTUM_RATIO", DEFAULT_CONSOLIDATION_POLICY.momentumRatio),
+    momentumRatioCap: numEnv5(env2, "ERRATA_CONSOLIDATE_MOMENTUM_RATIO_CAP", DEFAULT_CONSOLIDATION_POLICY.momentumRatioCap),
+    quiescenceMs: numEnv5(env2, "ERRATA_CONSOLIDATE_QUIESCENCE_MS", DEFAULT_CONSOLIDATION_POLICY.quiescenceMs)
   };
 }
 function consolidationGapMs(lastPassMs, policy) {
@@ -62105,6 +62423,8 @@ async function main() {
       return cmdConsent(rest);
     case "notifications":
       return cmdNotifications(rest[0] ?? "");
+    case "ops-notices":
+      return cmdOpsNotices(rest[0] ?? "");
     case "update":
       return cmdUpdate(rest);
     case "projects":
@@ -62228,6 +62548,9 @@ Commands:
                       Send scrubbed feedback to the maintainers (needs login)
   notifications <on|off>
                       Desktop toasts on problem open/resolve + review ready
+  ops-notices <on|off>
+                      Ops-grade health surfaces (daemon-distress toast + agent
+                      notice). Default off; for people operating errata itself
 
 Environment:
   ERRATA_CLOUD_URL                Cloud base URL (default ${DEFAULT_CLOUD_URL})
@@ -64753,6 +65076,19 @@ async function cmdNotifications(state) {
   saveConfig(cfg);
   console.log(`desktop notifications ${cfg.notifications ? "enabled" : "disabled"}`);
 }
+async function cmdOpsNotices(state) {
+  const s = state.toLowerCase();
+  if (s !== "on" && s !== "off") {
+    console.error("usage: errata ops-notices <on|off>");
+    process.exit(2);
+  }
+  const cfg = loadConfig();
+  cfg.opsNotices = s === "on";
+  saveConfig(cfg);
+  console.log(
+    `ops health notices ${cfg.opsNotices ? "enabled \u2014 distress conditions will toast and reach the agent context" : "disabled \u2014 detection and `errata status` still run"}`
+  );
+}
 async function cmdFeedback(args2) {
   const cfg = loadConfig();
   if (!hasCloudCredential(cfg)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inerrata-corporation/errata",
-  "version": "2.0.2-dev.1130",
+  "version": "2.0.2-dev.1166",
   "description": "errata - local-first observation engine for AI coding agents",
   "type": "module",
   "bin": {