@askexenow/exe-os 0.9.374 → 0.9.376

package/dist/{chunk-VKJGHAZT.js → chunk-MGVILAYU.js}

@@ -1,10 +1,10 @@
-import {
-  isCrdtSyncEnabled
-} from "./chunk-KQ6RJWRW.js";
 import {
   compress,
   decompress
 } from "./chunk-NEHOQ3P2.js";
+import {
+  isCrdtSyncEnabled
+} from "./chunk-VPT6VMBG.js";
 import {
   orgMembershipsPath,
   orgModeActive
@@ -21,14 +21,14 @@ import {
 } from "./chunk-3SXHEQ7X.js";
 import {
   getAuthHeader
-} from "./chunk-NUTZJZKW.js";
+} from "./chunk-SKTAZGFI.js";
 import {
   GHOST_BEHAVIOR_SQL,
   isGhostBehaviorRow
-} from "./chunk-WMEYJT4R.js";
+} from "./chunk-6FG34V6D.js";
 import {
   retryOnDaemonTransportError
-} from "./chunk-XZ65ST2I.js";
+} from "./chunk-QV5CQLQH.js";
 import {
   decryptSyncBlob,
   encryptSyncBlob,
@@ -41,10 +41,10 @@ import {
   loadEmployees,
   registerBinSymlinks,
   saveEmployees
-} from "./chunk-TAMDAOCU.js";
+} from "./chunk-66CGXQUA.js";
 import {
   loadDeviceId
-} from "./chunk-L6RXG36J.js";
+} from "./chunk-Y2HD2YB7.js";
 import {
   EXE_AI_DIR
 } from "./chunk-ZIG7VPJV.js";
@@ -751,7 +751,7 @@ var CLOUD_REUPLOAD_REQUIRED_MESSAGE = "Cloud sync is blocked because this device
 async function getCloudReuploadRequired(client = getClient()) {
   try {
     await client.execute("CREATE TABLE IF NOT EXISTS sync_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)");
-    const result = await client.execute("SELECT key, value FROM sync_meta WHERE key IN ('cloud_reupload_required', 'cloud_relink_required')");
+    const result = await client.execute("SELECT key, value FROM sync_meta WHERE key IN ('cloud_reupload_required', 'cloud_relink_required', 'cloud_reupload_in_progress')");
     return result.rows.some((row) => String(row.value ?? "") === "1");
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
@@ -759,15 +759,38 @@ async function getCloudReuploadRequired(client = getClient()) {
     throw new Error(`[cloud-sync] Key-rotation guard check failed: ${msg}`);
   }
 }
+async function getCloudReuploadInProgress(client = getClient()) {
+  await client.execute("CREATE TABLE IF NOT EXISTS sync_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)");
+  const result = await client.execute("SELECT value FROM sync_meta WHERE key = 'cloud_reupload_in_progress'");
+  return result.rows.some((row) => String(row.value ?? "") === "1");
+}
+async function beginCloudReupload(client = getClient()) {
+  await client.execute("CREATE TABLE IF NOT EXISTS sync_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)");
+  try {
+    await client.execute({
+      sql: "DELETE FROM sync_meta WHERE key IN ('last_cloud_pull_version', 'last_cloud_push_version', ?)",
+      args: [CLOUD_MEMORY_PUSH_SCAN_CURSOR_KEY]
+    });
+  } catch (e) {
+    await client.execute("INSERT INTO sync_meta (key, value) VALUES ('cloud_reupload_in_progress', '0') ON CONFLICT(key) DO UPDATE SET value = excluded.value");
+    throw e;
+  }
+  await client.execute("INSERT INTO sync_meta (key, value) VALUES ('cloud_reupload_in_progress', '1') ON CONFLICT(key) DO UPDATE SET value = excluded.value");
+}
+async function markCloudReuploadIncomplete(client = getClient()) {
+  await client.execute("CREATE TABLE IF NOT EXISTS sync_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)");
+  await client.execute("INSERT INTO sync_meta (key, value) VALUES ('cloud_reupload_required', '1') ON CONFLICT(key) DO UPDATE SET value = excluded.value");
+  await client.execute("INSERT INTO sync_meta (key, value) VALUES ('cloud_reupload_in_progress', '1') ON CONFLICT(key) DO UPDATE SET value = excluded.value");
+}
 async function clearCloudReuploadRequired(client = getClient()) {
   await client.execute("CREATE TABLE IF NOT EXISTS sync_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)");
   await client.execute("INSERT INTO sync_meta (key, value) VALUES ('cloud_reupload_required', '0') ON CONFLICT(key) DO UPDATE SET value = excluded.value");
   await client.execute("INSERT INTO sync_meta (key, value) VALUES ('cloud_relink_required', '0') ON CONFLICT(key) DO UPDATE SET value = excluded.value");
+  await client.execute("INSERT INTO sync_meta (key, value) VALUES ('cloud_reupload_in_progress', '0') ON CONFLICT(key) DO UPDATE SET value = excluded.value");
   await client.execute({
     sql: "INSERT INTO sync_meta (key, value) VALUES ('cloud_reuploaded_at', ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value",
     args: [(/* @__PURE__ */ new Date()).toISOString()]
   });
-  await client.execute("DELETE FROM sync_meta WHERE key IN ('last_cloud_pull_version', 'last_cloud_push_version')");
 }
 var getCloudRelinkRequired = getCloudReuploadRequired;
 async function clearCloudRelinkRequired(client = getClient()) {
@@ -783,6 +806,7 @@ async function clearCloudRelinkRequired(client = getClient()) {
 async function markCloudReuploadRequired(client = getClient()) {
   await client.execute("CREATE TABLE IF NOT EXISTS sync_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)");
   await client.execute("INSERT INTO sync_meta (key, value) VALUES ('cloud_reupload_required', '1') ON CONFLICT(key) DO UPDATE SET value = excluded.value");
+  await client.execute("INSERT INTO sync_meta (key, value) VALUES ('cloud_reupload_in_progress', '0') ON CONFLICT(key) DO UPDATE SET value = excluded.value");
 }
 function defaultOnProgress(stage, detail) {
   const msg = detail ? `[cloud-sync] ${stage}: ${detail}` : `[cloud-sync] ${stage}`;
@@ -1005,7 +1029,7 @@ async function cloudSync(config, options) {
       throw new Error("[cloud-sync] Database not initialized. Call initStore() before cloudSync().");
     }
     try {
-      if (await getCloudReuploadRequired(client)) throw new Error(CLOUD_REUPLOAD_REQUIRED_MESSAGE);
+      if (!options?.allowKeyRotationReupload && await getCloudReuploadRequired(client)) throw new Error(CLOUD_REUPLOAD_REQUIRED_MESSAGE);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       if (msg === CLOUD_REUPLOAD_REQUIRED_MESSAGE || msg.includes("key rotation") || msg.includes("guard check failed")) throw err;
@@ -1069,7 +1093,7 @@ async function cloudSync(config, options) {
           })
         };
         if (shouldUseCrdtMergeForCloudSync()) {
-          const { initCrdtDoc, importExistingMemories, readAllMemories } = await import("./crdt-sync-B3JN6AIV.js");
+          const { initCrdtDoc, importExistingMemories, readAllMemories } = await import("./crdt-sync-32B55NOJ.js");
           initCrdtDoc();
           importExistingMemories(
             pullResult.records.map((rec) => ({
@@ -1281,6 +1305,8 @@ async function cloudSync(config, options) {
       await stageDone("pull");
     }
     let pushed = 0;
+    let memoryPushErrors = 0;
+    let pendingMemories = 0;
     if (!shouldSkip("memories")) {
       onProgress("Cloud sync", `pushing memories...`);
       const pushMeta = await client.execute(
@@ -1292,6 +1318,7 @@ async function cloudSync(config, options) {
         lastPullVersion
       });
       pushed = memoryPush.pushed;
+      memoryPushErrors = memoryPush.errors;
       if (memoryPush.deferred) {
         const elapsedMs = Date.now() - syncStartTime;
         if (pushed > 0) {
@@ -1308,6 +1335,18 @@ async function cloudSync(config, options) {
         );
         return partialCloudSyncResult({ pushed, pulled, elapsedMs, deferred: true });
       }
+      if (memoryPushErrors > 0) {
+        try {
+          const pendingRes = await client.execute({
+            sql: "SELECT COUNT(*) AS cnt FROM memories WHERE (scope IS NULL OR scope != 'personal') AND version > ?",
+            args: [memoryPush.finalCursor]
+          });
+          pendingMemories = finiteVersion(pendingRes.rows[0]?.cnt, 0);
+        } catch (err) {
+          logError(`[cloud-sync] pending memory count failed after push errors: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        if (pendingMemories < 1) pendingMemories = 1;
+      }
       await stageDone("memories");
     }
     const rosterSkipped = shouldSkip("roster");
@@ -1654,7 +1693,9 @@ async function cloudSync(config, options) {
       coreMemory: coreMemoryResult,
       roster: rosterResult,
       codeContext: codeContextResult,
-      elapsedMs: Date.now() - syncStartTime
+      elapsedMs: Date.now() - syncStartTime,
+      memoryPushErrors,
+      pendingMemories
     };
   } finally {
     _cloudSyncInProgress = false;
@@ -3103,6 +3144,9 @@ export {
   cloudPull,
   CLOUD_REUPLOAD_REQUIRED_MESSAGE,
   getCloudReuploadRequired,
+  getCloudReuploadInProgress,
+  beginCloudReupload,
+  markCloudReuploadIncomplete,
   clearCloudReuploadRequired,
   getCloudRelinkRequired,
   clearCloudRelinkRequired,

package/dist/{chunk-DB55JZHU.js → chunk-MSLWRWTI.js}

@@ -1,7 +1,7 @@
 import {
   checkLicense,
   loadLicense
-} from "./chunk-L6RXG36J.js";
+} from "./chunk-Y2HD2YB7.js";
 
 // src/lib/license-gate.ts
 var _cachedLicense = null;

package/dist/{chunk-C2L622QJ.js → chunk-NB5IRTC4.js}

@@ -1,6 +1,53 @@
 // src/lib/git-main-guard.ts
 import { execFileSync } from "child_process";
 import path from "path";
+
+// src/lib/git-command-lex.ts
+var SHELLS = /* @__PURE__ */ new Set(["sh", "bash", "zsh", "dash", "ksh"]);
+function basename(tok) {
+  return tok.split("/").pop() ?? tok;
+}
+function isGitProgram(tok) {
+  return tok === "git" || /(?:^|\/)git$/.test(tok);
+}
+function isShellProgram(tok) {
+  return SHELLS.has(basename(tok));
+}
+function isDashC(tok) {
+  return /^-[a-z]*c[a-z]*$/i.test(tok) && tok.includes("c");
+}
+var SHELL_VALUE_OPTS = /* @__PURE__ */ new Set(["-o", "+o", "-O", "+O", "--rcfile", "--init-file"]);
+function shellDashCScriptIndex(tokens, i) {
+  if (!isShellProgram(tokens[i])) return -1;
+  let j = i + 1;
+  while (j < tokens.length) {
+    const t = tokens[j];
+    if (isDashC(t)) return j + 1 < tokens.length ? j + 1 : -1;
+    if (SHELL_VALUE_OPTS.has(t)) {
+      j += 2;
+      continue;
+    }
+    if (t.startsWith("-")) {
+      j++;
+      continue;
+    }
+    return -1;
+  }
+  return -1;
+}
+function isLeadingAssignment(tok) {
+  return /^[A-Za-z_][A-Za-z0-9_]*=/.test(tok);
+}
+function normalizeCleanGit(tokens) {
+  const first = tokens[0];
+  if (first === void 0) return { ok: false, reason: "empty command" };
+  if (isLeadingAssignment(first)) return { ok: false, reason: "leading environment assignment before git" };
+  if (isShellProgram(first)) return { ok: false, reason: `command runs a shell ("${first}") whose script cannot be verified` };
+  if (!isGitProgram(first)) return { ok: false, reason: `git is wrapped or embedded (program is "${first}", not a bare 'git')` };
+  return { ok: true, tokens: ["git", ...tokens.slice(1)] };
+}
+
+// src/lib/git-main-guard.ts
 var MAIN_GUARD_OVERRIDE_TOKEN = "EXE_FORCE_ALLOW_MAIN_HISTORY_REWRITE=1";
 var MAIN_GUARD_OVERRIDE_ENV = "EXE_FORCE_ALLOW_MAIN_HISTORY_REWRITE";
 var GIT_TIMEOUT_MS = (() => {
@@ -123,13 +170,6 @@ function tokenizeShell(command) {
   push();
   return { tokens, hasShellControl };
 }
-var SHELLS = /* @__PURE__ */ new Set(["sh", "bash", "zsh", "dash", "ksh"]);
-function basename(tok) {
-  return tok.split("/").pop() ?? tok;
-}
-function isGitProgram(tok) {
-  return tok === "git" || /(?:^|\/)git$/.test(tok);
-}
 function isGhProgram(tok) {
   return tok === "gh" || /(?:^|\/)gh$/.test(tok);
 }
@@ -164,34 +204,6 @@ function classifyGhSegment(tokens) {
   if (/git\/refs\/tags\//.test(refPath)) return "tag";
   return "block";
 }
-function isShellProgram(tok) {
-  return SHELLS.has(basename(tok));
-}
-function isDashC(tok) {
-  return /^-[a-z]*c[a-z]*$/i.test(tok) && tok.includes("c");
-}
-var SHELL_VALUE_OPTS = /* @__PURE__ */ new Set(["-o", "+o", "-O", "+O", "--rcfile", "--init-file"]);
-function shellDashCScriptIndex(tokens, i) {
-  if (!isShellProgram(tokens[i])) return -1;
-  let j = i + 1;
-  while (j < tokens.length) {
-    const t = tokens[j];
-    if (isDashC(t)) return j + 1 < tokens.length ? j + 1 : -1;
-    if (SHELL_VALUE_OPTS.has(t)) {
-      j += 2;
-      continue;
-    }
-    if (t.startsWith("-")) {
-      j++;
-      continue;
-    }
-    return -1;
-  }
-  return -1;
-}
-function isLeadingAssignment(tok) {
-  return /^[A-Za-z_][A-Za-z0-9_]*=/.test(tok);
-}
 var FORCE_PUSH_FLAGS = /* @__PURE__ */ new Set(["-f", "--force"]);
 function isForcePushFlag(t) {
   return FORCE_PUSH_FLAGS.has(t) || /^--force-with-lease(=.*)?$/.test(t) || t === "--force-if-includes";
@@ -646,14 +658,6 @@ function hasEmergencyOverride(command, env = process.env) {
   if (env[MAIN_GUARD_OVERRIDE_ENV] === "1") return true;
   return new RegExp(String.raw`^\s*${MAIN_GUARD_OVERRIDE_ENV}=1\s+(?:git|gh)\b`).test(command);
 }
-function normalizeCleanGit(tokens) {
-  const first = tokens[0];
-  if (first === void 0) return { ok: false, reason: "empty command" };
-  if (isLeadingAssignment(first)) return { ok: false, reason: "leading environment assignment before git" };
-  if (isShellProgram(first)) return { ok: false, reason: `command runs a shell ("${first}") whose script cannot be verified` };
-  if (!isGitProgram(first)) return { ok: false, reason: `git is wrapped or embedded (program is "${first}", not a bare 'git')` };
-  return { ok: true, tokens: ["git", ...tokens.slice(1)] };
-}
 function evaluateMainGuard(command, opts = {}) {
   const env = opts.env ?? process.env;
   const cwd = opts.cwd ?? process.cwd();
@@ -775,10 +779,14 @@ ${OVERRIDE_LINE}`;
 }
 
 export {
+  basename,
+  isGitProgram,
+  isShellProgram,
+  shellDashCScriptIndex,
+  isLeadingAssignment,
   MAIN_GUARD_OVERRIDE_TOKEN,
   MAIN_GUARD_OVERRIDE_ENV,
   tokenizeShell,
-  isGitProgram,
   isGhProgram,
   splitShellSegments,
   containsDestructiveGitCandidate,

package/dist/{chunk-2ZOEC4KC.js → chunk-ND75TGPR.js}

@@ -1,10 +1,10 @@
 import {
   getCurrentSessionScope,
   strictSessionScopeFilter
-} from "./chunk-AKLQSC6W.js";
+} from "./chunk-KI7O64XV.js";
 import {
   getProjectName
-} from "./chunk-JTVIANUB.js";
+} from "./chunk-AEUGIJDO.js";
 
 // src/lib/session-events.ts
 import { randomUUID } from "crypto";

package/dist/{chunk-VRTCVZND.js → chunk-NE34MWVL.js}

@@ -4,6 +4,12 @@ import {
   SUSPEND_CLUSTER_WINDOW_MS,
   findTimerWakeClusterArtifacts
 } from "./chunk-YQGMSXT5.js";
+import {
+  TIMER_HARM_SEVERE_MS,
+  collectTimerHarmContext,
+  foldTimerHarm,
+  harmStateLabel
+} from "./chunk-3OX5S7KZ.js";
 
 // src/lib/daemon-timer-report.ts
 import { existsSync, readFileSync, statSync, openSync, readSync, closeSync } from "fs";
@@ -69,11 +75,35 @@ function median(values) {
   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) {
+function classifyByDuration(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 classifyByHarm(harmState, maxHarmMs, maxMs, p95Ms, trippedBlockThreshold, chargedTrips) {
+  if (chargedTrips > 0) return "blocked";
+  if (harmState === "unknown") return classifyByDuration(maxMs, p95Ms, trippedBlockThreshold);
+  if (harmState === "blocking") return maxHarmMs >= TIMER_SEVERE_MS ? "blocked" : "slow";
+  return "healthy";
+}
+function parsePausedIntervals(raw, atMs, wallMs) {
+  if (!Array.isArray(raw) || raw.length === 0) return null;
+  if (atMs === null || wallMs === null || !Number.isFinite(wallMs)) return null;
+  const tickStartMs = atMs - Math.max(0, wallMs);
+  const intervals = [];
+  for (const entry of raw) {
+    if (typeof entry !== "object" || entry === null) continue;
+    const startOffsetMs = entry.startOffsetMs;
+    const endOffsetMs = entry.endOffsetMs;
+    if (typeof startOffsetMs !== "number" || !Number.isFinite(startOffsetMs)) continue;
+    if (typeof endOffsetMs !== "number" || !Number.isFinite(endOffsetMs)) continue;
+    const startMs = tickStartMs + startOffsetMs;
+    const endMs = tickStartMs + endOffsetMs;
+    if (endMs < startMs) continue;
+    intervals.push({ startMs, endMs });
+  }
+  return intervals.length > 0 ? intervals : null;
+}
 function buildTimerReport(opts = {}) {
   const maxBytes = opts.maxBytesPerFile ?? 4 * 1024 * 1024;
   const inFlightKnown = Array.isArray(opts.inFlight);
@@ -84,6 +114,13 @@ function buildTimerReport(opts = {}) {
   const samplesByTimer = /* @__PURE__ */ new Map();
   const clockJumpsByTimer = /* @__PURE__ */ new Map();
   const timeoutsByTimer = /* @__PURE__ */ new Map();
+  const awaitLagByTimer = /* @__PURE__ */ new Map();
+  const awaitAtByTimer = /* @__PURE__ */ new Map();
+  const harmContext = collectTimerHarmContext(records, (ts) => {
+    if (typeof ts !== "string") return null;
+    const parsed = Date.parse(ts);
+    return Number.isFinite(parsed) ? parsed : null;
+  });
   let oldestMs = null;
   let newestMs = null;
   const stampOf = (rec) => {
@@ -101,26 +138,62 @@ function buildTimerReport(opts = {}) {
       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 };
+      const cur = timeoutsByTimer.get(timer2) ?? { count: 0, lastAtMs: null, atMs: [] };
       cur.count += 1;
+      cur.atMs.push(atMs2);
       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_long_await") {
+      const timer2 = typeof data.timer === "string" ? data.timer : null;
+      const lag = typeof data.maxEventLoopLagMs === "number" ? data.maxEventLoopLagMs : null;
+      const awaitAtMs = stampOf(rec);
+      if (timer2 !== null && lag !== null && Number.isFinite(lag)) {
+        const lags = awaitLagByTimer.get(timer2) ?? [];
+        lags.push(lag);
+        awaitLagByTimer.set(timer2, lags);
+        const ats = awaitAtByTimer.get(timer2) ?? [];
+        ats.push(awaitAtMs);
+        awaitAtByTimer.set(timer2, ats);
+      }
+      continue;
+    }
     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 wallMs = typeof data.durationMs === "number" && Number.isFinite(data.durationMs) ? data.durationMs : null;
+    if (timer === null || wallMs === null) 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 busyMs = typeof data.busyMs === "number" && Number.isFinite(data.busyMs) ? data.busyMs : null;
+    const sweepPausedMs = typeof data.sweepPausedMs === "number" && Number.isFinite(data.sweepPausedMs) ? data.sweepPausedMs : null;
+    const tick = {
+      timer,
+      atMs,
+      wallMs,
+      busyMs,
+      sweepPausedMs,
+      syncExecMs: typeof data.syncExecMs === "number" && Number.isFinite(data.syncExecMs) ? data.syncExecMs : null,
+      peakLagMs: typeof data.peakLagMs === "number" && Number.isFinite(data.peakLagMs) ? data.peakLagMs : null,
+      attribution: typeof data.attribution === "string" ? data.attribution : null,
+      // Bug 7eaaf4f3: null (field absent) means the record predates this
+      // instrumentation — the harm model keeps the historical whole-tick
+      // disclaim for it. A present number (0 or more) is precise evidence.
+      peakLagOutsideParkMs: typeof data.peakLagOutsideParkMs === "number" && Number.isFinite(data.peakLagOutsideParkMs) ? data.peakLagOutsideParkMs : null,
+      // Bug set following 7eaaf4f3 (codex-review P1s on PR #962, findings
+      // #2/#4): see parsePausedIntervals in daemon-restart-report.ts for the
+      // same conversion (tick-relative offsets -> absolute epoch ms).
+      pausedIntervals: parsePausedIntervals(data.pausedIntervals, atMs, wallMs)
+    };
+    const durationMs = busyMs !== null ? Math.max(0, busyMs) : Math.max(0, wallMs - (sweepPausedMs ?? 0));
     const arr = samplesByTimer.get(timer) ?? [];
-    arr.push({ durationMs, atMs });
+    arr.push({ durationMs, atMs, tick });
     samplesByTimer.set(timer, arr);
   }
   const suspendArtifacts = /* @__PURE__ */ new Set();
@@ -150,8 +223,18 @@ function buildTimerReport(opts = {}) {
   ]);
   const timers = [...allTimers].map((timer) => {
     const samples = samplesByTimer.get(timer) ?? [];
-    const timeouts = timeoutsByTimer.get(timer) ?? { count: 0, lastAtMs: null };
+    const timeouts = timeoutsByTimer.get(timer) ?? { count: 0, lastAtMs: null, atMs: [] };
     const durations = samples.map((s) => s.durationMs);
+    const harm = foldTimerHarm({
+      timer,
+      ticks: samples.map((s) => s.tick),
+      watchdogTripAtMs: timeouts.atMs,
+      respondedAwaitLagMs: awaitLagByTimer.get(timer) ?? [],
+      respondedAwaitAtMs: awaitAtByTimer.get(timer) ?? [],
+      stalls: harmContext.stalls,
+      hostStarvationAtMs: harmContext.hostStarvationAtMs,
+      globalBlockAtMs: harmContext.globalBlockAtMs
+    });
     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);
@@ -185,12 +268,27 @@ function buildTimerReport(opts = {}) {
       lastTimeoutAtMs: timeouts.lastAtMs,
       trippedBlockThreshold,
       inFlight: inFlightKnown ? inFlightSet.has(timer) : null,
-      status: classify(maxMs, p95Ms, trippedBlockThreshold)
+      status: classifyByHarm(
+        harm.state,
+        harm.maxHarmMs,
+        maxMs,
+        p95Ms,
+        trippedBlockThreshold,
+        harm.chargedTrips
+      ),
+      maxHarmMs: harm.maxHarmMs,
+      harmState: harm.state,
+      maxSyncExecMs: harm.maxSyncExecMs,
+      disclaimedLagMs: harm.disclaimedLagMs,
+      disclaimReason: harm.disclaimReason,
+      chargedTrips: harm.chargedTrips,
+      disclaimedTrips: harm.disclaimedTrips,
+      parkedMs: harm.parkedMs
     };
   });
   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)
+    (a, b) => rank[a.status] - rank[b.status] || b.maxHarmMs - a.maxHarmMs || b.maxMs - a.maxMs || b.timeoutCount - a.timeoutCount || a.timer.localeCompare(b.timer)
   );
   return {
     logsFound: sources.length > 0,
@@ -267,12 +365,12 @@ function formatTimerReport(report, now = Date.now()) {
     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`;
+  const head = `   ${"timer".padEnd(26)} ${"last".padStart(8)} ${"avg".padStart(8)} ${"p95".padStart(8)} ${"max".padStart(8)} ${"harm".padStart(8)} ${"state".padEnd(10)} ${"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)}`
+      `${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)} ${ms(t.maxHarmMs).padStart(8)} ${harmStateLabel(t.harmState).padEnd(10)} ${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("");
@@ -285,13 +383,26 @@ function formatTimerReport(report, now = Date.now()) {
   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).`
+      `\u{1F534} BLOCKING RISK \u2014 these HELD the event loop (harm \u2265${TIMER_HARM_SEVERE_MS / 1e3}s, or a duration-only record in the danger zone).`
     );
     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}`);
+      const trips = t.chargedTrips > 0 ? `${t.chargedTrips} watchdog trip(s), last ${shortClock(t.lastTimeoutAtMs)}` : "no watchdog trip (single slow tick)";
+      const harmNote = t.harmState === "unknown" ? "harm unmeasured (record predates the harm fields)" : `harm ${ms(t.maxHarmMs)}`;
+      lines.push(`   \u2022 ${t.timer}: ${harmNote}, active max ${ms(t.maxMs)} \u2014 ${trips}`);
+    }
+  }
+  const disclaimed = report.timers.filter((t) => t.disclaimedLagMs > 0 || t.disclaimedTrips > 0);
+  if (disclaimed.length > 0) {
+    lines.push("");
+    lines.push("\u{1F7E2} NOT charged as harm \u2014 the log explains these away (the system working):");
+    for (const t of disclaimed) {
+      const bits = [];
+      if (t.disclaimedLagMs > 0) bits.push(`peak lag ${ms(t.disclaimedLagMs)}`);
+      if (t.disclaimedTrips > 0) bits.push(`${t.disclaimedTrips} watchdog trip(s)`);
+      if (t.parkedMs > 0) bits.push(`parked ${ms(t.parkedMs)} with the loop FREE`);
+      lines.push(`   \u2022 ${t.timer}: ${bits.join(", ")}${t.disclaimReason ? ` \u2014 ${t.disclaimReason}` : ""}`);
     }
   }
   lines.push("");
@@ -313,12 +424,27 @@ function formatTimerReport(report, now = Date.now()) {
   );
   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"
+    "   harm = event-loop hold this timer can be BLAMED for; it drives colour and rank, NOT"
+  );
+  lines.push(
+    "   duration. last/avg/p95/max are ACTIVE time (deliberate starvation-gate pauses already"
+  );
+  lines.push(
+    "   subtracted) and are still an ASYNC SPAN, not CPU on the loop: a long span may be"
+  );
+  lines.push(
+    "   awaited I/O and harmless. state: BLOCKING held the loop; long-await ran long with the"
+  );
+  lines.push(
+    "   loop free; unmeasured = the record predates the harm fields, so colour falls back to"
+  );
+  lines.push(
+    "   duration \u2014 absence of evidence is NOT evidence of health."
   );
   lines.push(
-    "   may be awaited I/O (harmless to the loop) \u2014 but it still trips the 10s watchdog and"
+    "   CAVEAT: a long span still trips the 10s watchdog and the overlap guard, so the next"
   );
-  lines.push("   the overlap guard, so the next tick is SKIPPED. Both matter.");
+  lines.push("   tick is SKIPPED. Harmless to the loop is not the same as free.");
   lines.push("");
   return lines.join("\n");
 }

package/dist/{chunk-S2WBS6BG.js → chunk-NMOFLWDY.js}

@@ -4,7 +4,7 @@ import {
   getGitRootAsync,
   isWorktreeDirty,
   isWorktreeDirtyAsync
-} from "./chunk-4EN3IZ3Q.js";
+} from "./chunk-64ODONK2.js";
 
 // src/lib/worktree-sweep.ts
 import { execFile } from "child_process";