@askexenow/exe-os 0.9.384 → 0.9.389

package/dist/{chunk-APL7HUE3.js → chunk-5QQJUO3F.js}

@@ -1,12 +1,12 @@
 import {
   isPaneBusy
-} from "./chunk-MKM6D7JM.js";
+} from "./chunk-RWG7DLOG.js";
 import {
   recordSessionKill
-} from "./chunk-P3UX5EH4.js";
+} from "./chunk-RWKAHHIX.js";
 import {
   updateTask
-} from "./chunk-2FKU4ZEO.js";
+} from "./chunk-QDBKMEYY.js";
 import {
   BUSY_PATTERN,
   countPendingReviews,
@@ -24,27 +24,29 @@ import {
   sessionScopeFilter,
   strictSessionScopeFilter,
   writeNotification
-} from "./chunk-7UHZBVP3.js";
+} from "./chunk-QDVLVLXP.js";
 import {
   LEASE_MINUTES,
   isLeaseExpired
 } from "./chunk-E23LNUWJ.js";
 import {
   listSessions
-} from "./chunk-ALRHGEAJ.js";
+} from "./chunk-637FL62O.js";
 import {
   capturePaneLinesAsync,
+  capturePaneLinesStrictAsync,
+  getPanePidAsync,
   listTmuxSessions,
   listTmuxSessionsAsync,
   parseContextPercentage,
   parseContextPercentageAsync
-} from "./chunk-PUBA5B4M.js";
+} from "./chunk-6L4VIYLZ.js";
 import {
   getTransport
 } from "./chunk-VI4ATC6I.js";
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-LSNBTGW4.js";
+} from "./chunk-DPYZW42H.js";
 import {
   checkDispatchStatus,
   readTerminalLauncherFailure,
@@ -53,7 +55,7 @@ import {
 } from "./chunk-T5SM4RXY.js";
 import {
   getAgentRuntime
-} from "./chunk-L5EPGGDP.js";
+} from "./chunk-GWAN2BDB.js";
 import {
   isValidSessionScope
 } from "./chunk-BTSWFMEH.js";
@@ -72,7 +74,7 @@ import {
   getCoordinatorName,
   isCoordinatorName,
   shouldAutoInstance
-} from "./chunk-GL47M7NY.js";
+} from "./chunk-3UD3OF3X.js";
 import {
   eventLoopBlockedMarkerPath
 } from "./chunk-ZQEJ4IX2.js";
@@ -225,6 +227,109 @@ async function collectAgentSignals(client, agentId, sessionName, intercomAckWind
   };
 }
 
+// src/lib/kill-authority.ts
+function classifyPidProbe(err) {
+  if (err === null || err === void 0) return "exists";
+  const code = err?.code;
+  if (code === "ESRCH") return "gone";
+  if (code === "EPERM") return "exists";
+  return "unverified";
+}
+function probePid(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) return "unverified";
+  try {
+    process.kill(pid, 0);
+    return classifyPidProbe(null);
+  } catch (err) {
+    return classifyPidProbe(err);
+  }
+}
+function resolveKillAuthority(reading) {
+  const note = reading.note ? ` (${reading.note})` : "";
+  if (reading.sessionExists === "unknown") {
+    return {
+      authorised: false,
+      reason: "unverified",
+      detail: `tmux session probe failed at kill time${note} \u2014 cannot determine whether anything is there`
+    };
+  }
+  if (reading.sessionExists === false) {
+    return {
+      authorised: false,
+      reason: "unverified",
+      detail: "tmux session vanished between grading and kill \u2014 nothing left to destroy"
+    };
+  }
+  switch (reading.pidProbe) {
+    case "gone":
+      return { authorised: true, evidence: "pane process probe returned ESRCH \u2014 provably gone" };
+    case "unverified":
+      return {
+        authorised: false,
+        reason: "unverified",
+        detail: `pane process probe was uninterpretable${note} \u2014 refusing to destroy on an unreadable answer`
+      };
+    case "exists":
+      break;
+  }
+  if (reading.freshPane === null) {
+    return {
+      authorised: false,
+      reason: "unverified",
+      detail: `pane capture failed at kill time${note} \u2014 a failed capture is not proof of a quiet pane`
+    };
+  }
+  if (reading.freshPane.working) {
+    return {
+      authorised: false,
+      reason: "alive",
+      detail: "pane is WORKING at kill time \u2014 it recovered after being graded unreachable"
+    };
+  }
+  return { authorised: true, evidence: "pane process exists and reads not-working in a capture taken at the act" };
+}
+function normalizeKillAuthority(value) {
+  if (value === true) return { authorised: true, evidence: "guard returned true" };
+  if (value === false) {
+    return { authorised: false, reason: "alive", detail: "guard refused the destructive action" };
+  }
+  return value;
+}
+async function resolveKillAuthorityAt(sessionName, io) {
+  let sessionExists;
+  let note;
+  try {
+    sessionExists = await io.sessionExists(sessionName);
+  } catch (err) {
+    sessionExists = "unknown";
+    note = err instanceof Error ? err.message : String(err);
+  }
+  if (sessionExists !== true) {
+    return resolveKillAuthority({ sessionExists, pidProbe: "unverified", freshPane: null, note });
+  }
+  let pidProbe;
+  try {
+    const pid = await io.panePid(sessionName);
+    pidProbe = pid === null ? "unverified" : io.probePid(pid);
+    if (pid === null) note = note ?? "pane pid unreadable";
+  } catch (err) {
+    pidProbe = "unverified";
+    note = note ?? (err instanceof Error ? err.message : String(err));
+  }
+  if (pidProbe !== "exists") {
+    return resolveKillAuthority({ sessionExists: true, pidProbe, freshPane: null, note });
+  }
+  let freshPane;
+  try {
+    freshPane = await io.capturePane(sessionName);
+    if (freshPane === null) note = note ?? "pane capture returned nothing";
+  } catch (err) {
+    freshPane = null;
+    note = note ?? (err instanceof Error ? err.message : String(err));
+  }
+  return resolveKillAuthority({ sessionExists: true, pidProbe: "exists", freshPane, note });
+}
+
 // src/lib/daemon-orchestration.ts
 var cpuCount = () => osCpus().length;
 function parseVmStatAvailableGB(vmStatOutput) {
@@ -310,6 +415,12 @@ function shouldKillIdleSession(input) {
   if (input.idleTicks < input.ticksRequired) return false;
   return true;
 }
+function describeKillRefusal(authority) {
+  if (authority.authorised) {
+    return "daemon-loop backoff refused destructive action (authority itself was granted)";
+  }
+  return authority.reason === "alive" ? `REFUSED, TARGET ALIVE: ${authority.detail}` : `REFUSED, UNVERIFIED: ${authority.detail}`;
+}
 function isEventLoopBlockedRecently(nowMs = Date.now(), windowMs = Number(process.env.EXE_UNREACHABLE_BLOCK_BACKOFF_MS) || 3e4) {
   try {
     const age = nowMs - statSync2(eventLoopBlockedMarkerPath()).mtimeMs;
@@ -418,10 +529,10 @@ async function checkSessionTTL(deps, wedgeObservations = /* @__PURE__ */ new Map
               });
             } else {
               wedgeObservations.delete(entry.windowName);
-              const canKill = deps.canKillUnreachable ? await deps.canKillUnreachable(entry.windowName, snapshot) : true;
-              if (!canKill || deps.eventLoopBlockedRecently?.(Date.now())) {
+              const authority = deps.canKillUnreachable ? normalizeKillAuthority(await deps.canKillUnreachable(entry.windowName, snapshot)) : { authorised: true, evidence: "no guard configured" };
+              if (!authority.authorised || deps.eventLoopBlockedRecently?.(Date.now())) {
                 process.stderr.write(
-                  `[exed] Session TTL: unreachable KILL SUPPRESSED for ${entry.windowName} \u2014 tmux/activity check or daemon-loop backoff refused destructive action
+                  `[exed] Session TTL: unreachable KILL SUPPRESSED for ${entry.windowName} \u2014 ${describeKillRefusal(authority)}
 `
                 );
                 continue;
@@ -455,10 +566,10 @@ async function checkSessionTTL(deps, wedgeObservations = /* @__PURE__ */ new Map
             const pendingInput = await deps.hasPendingInput?.(entry.windowName) ?? false;
             if (isUnreachableActiveTaskSession({ ageHours, state, hasPendingInput: pendingInput })) {
               telemetryReason = "unreachable";
-              const canKill = deps.canKillUnreachable ? await deps.canKillUnreachable(entry.windowName, snapshot) : true;
-              if (!canKill || deps.eventLoopBlockedRecently?.(Date.now())) {
+              const authority = deps.canKillUnreachable ? normalizeKillAuthority(await deps.canKillUnreachable(entry.windowName, snapshot)) : { authorised: true, evidence: "no guard configured" };
+              if (!authority.authorised || deps.eventLoopBlockedRecently?.(Date.now())) {
                 process.stderr.write(
-                  `[exed] Session TTL: unreachable override SUPPRESSED for ${entry.windowName} \u2014 tmux/activity check or daemon-loop backoff refused destructive action
+                  `[exed] Session TTL: unreachable override SUPPRESSED for ${entry.windowName} \u2014 ${describeKillRefusal(authority)}
 `
                 );
                 continue;
@@ -534,6 +645,32 @@ async function checkSessionTTL(deps, wedgeObservations = /* @__PURE__ */ new Map
     });
   } else if (unreachableCandidates.length === 1) {
     const c = unreachableCandidates[0];
+    const authority = deps.canKillUnreachable ? normalizeKillAuthority(await deps.canKillUnreachable(c.sessionName, null)) : { authorised: true, evidence: "no guard configured" };
+    if (!authority.authorised || deps.eventLoopBlockedRecently?.(Date.now())) {
+      const refusal = describeKillRefusal(authority);
+      process.stderr.write(
+        `[exed] Session TTL: unreachable KILL REFUSED AT THE ACT for ${c.sessionName} \u2014 ${refusal}
+`
+      );
+      recordOrchestrationEventBestEffort({
+        eventType: "session.unreachable_kill_refused",
+        source: "daemon-orchestration.checkSessionTTL",
+        severity: authority.authorised === false && authority.reason === "unverified" ? "error" : "warn",
+        agentId: c.agentId,
+        tmuxSession: c.sessionName,
+        sessionScope: c.scope,
+        payload: {
+          ageHours: parseFloat(c.ageHours.toFixed(2)),
+          contextPct: c.contextPct,
+          // Two-valued on purpose: "alive" means leave it alone, "unverified"
+          // means the probe itself needs looking at. Opposite responses.
+          refusalReason: authority.authorised === false ? authority.reason : "loop_backoff",
+          refusal,
+          ...c.payload
+        }
+      });
+      return killed;
+    }
     process.stderr.write(
       `[exed] Session TTL: killing ${c.sessionName} (age=${c.ageHours.toFixed(1)}h, context=${c.contextPct}%, reason=unreachable)
 `
@@ -943,7 +1080,21 @@ function createIdleNudgeRealDeps(_getClient) {
     }
   };
 }
-function createSessionTTLRealDeps(getClient) {
+var realKillProbeIo = {
+  // Throwing propagates to resolveKillAuthorityAt as "unknown" — a transport
+  // that cannot answer is not a transport saying "gone".
+  sessionExists: (sessionName) => getTransport().isAlive(sessionName),
+  panePid: (sessionName) => getPanePidAsync(sessionName),
+  probePid,
+  // Strict twin on purpose. capturePaneLinesAsync answers [] for BOTH "the pane
+  // is empty" and "tmux did not answer", and [] derives a snapshot with
+  // working:false — so a capture that exits non-zero or outruns its 3s budget
+  // would read as a quiet pane and authorise the kill of a live agent. Throwing
+  // propagates to resolveKillAuthorityAt as freshPane:null → UNVERIFIED, with
+  // the tmux error carried out as the refusal detail.
+  capturePane: async (sessionName) => derivePaneSnapshot((await capturePaneLinesStrictAsync(sessionName, 12)).join("\n"))
+};
+function createSessionTTLRealDeps(getClient, killProbeIo = realKillProbeIo) {
   return {
     listRegisteredSessions: () => listSessions(),
     // Bug 1c870c78: TTL runs on a 5-min timer — list sessions async (execFile).
@@ -1006,17 +1157,18 @@ function createSessionTTLRealDeps(getClient) {
         return null;
       }
     },
-    canKillUnreachable: async (sessionName, snapshot) => {
-      try {
-        const transport = getTransport();
-        if (!transport.isAlive(sessionName)) return false;
-        const checked = snapshot ?? derivePaneSnapshot((await capturePaneLinesAsync(sessionName, 12)).join("\n"));
-        if (checked.working) return false;
-        return true;
-      } catch {
-        return false;
-      }
-    },
+    // Bug bc98f61f. This used to read:
+    //
+    //   const checked = snapshot ?? derivePaneSnapshot(await capture(...));
+    //
+    // i.e. it PREFERRED the snapshot that graded the session and treated a
+    // fresh capture as the fallback. That snapshot predates several awaits, so
+    // a pane that recovered, restarted, or was merely slow to answer the first
+    // probe was destroyed on a reading taken before we started waiting. The
+    // `snapshot` argument is now deliberately ignored for the verdict — every
+    // reading below is taken here, at the act — and the outcome is three-
+    // valued so a refusal says WHICH kind it is.
+    canKillUnreachable: async (sessionName, _gradingSnapshotIgnored) => resolveKillAuthorityAt(sessionName, killProbeIo),
     eventLoopBlockedRecently: (nowMs) => isEventLoopBlockedRecently(nowMs),
     // de5d9fe8: non-destructive recovery — clear the stuck input buffer (C-u, no
     // Enter) so the queued nudge can land. Never submits anything. execFileSync ->
@@ -1605,8 +1757,23 @@ async function pollOrphanedTasks(deps, nowMs = Date.now()) {
     }
     const retries = _autoWakeTaskRetries.get(topTask.taskId) ?? 0;
     if (retries >= AUTO_WAKE_MAX_RETRIES || terminalFailure) {
-      const reviewReason = terminalFailure ? `Terminal launcher failure (${terminalFailure.runtime}) \u2014 ${terminalFailure.reason}` : `Auto-wake failed ${AUTO_WAKE_MAX_RETRIES} times \u2014 session ended after producing a deliverable. Needs manual review.`;
-      const abandonReason = terminalFailure ? `Terminal launcher failure (${terminalFailure.runtime}) \u2014 ${terminalFailure.reason}${terminalFailure.detail ? ` [${terminalFailure.detail}]` : ""}` : `Auto-wake failed ${AUTO_WAKE_MAX_RETRIES} times \u2014 session ended with NO deliverable. Blocked for manual re-dispatch (not a completed review).`;
+      if (deps.liveSessionHoldingTask) {
+        let liveHolder = null;
+        try {
+          liveHolder = await deps.liveSessionHoldingTask(topTask.taskId, topTask.sessionScope);
+        } catch {
+          liveHolder = null;
+        }
+        if (liveHolder) {
+          process.stderr.write(
+            `[auto-wake] REFUSING to route ${agentId} task ${topTask.taskId} after ${retries} retries \u2014 session ${liveHolder} is confirmed alive and holds this task; not marking it reviewed/abandoned and not releasing its ownership
+`
+          );
+          continue;
+        }
+      }
+      const reviewReason = terminalFailure ? `Terminal launcher failure (${terminalFailure.runtime}) \u2014 ${terminalFailure.reason}` : `Auto-wake could not reach a session for this task ${AUTO_WAKE_MAX_RETRIES} times; a deliverable was already recorded. Routed here for a human to judge \u2014 this is NOT a completion claim.`;
+      const abandonReason = terminalFailure ? `Terminal launcher failure (${terminalFailure.runtime}) \u2014 ${terminalFailure.reason}${terminalFailure.detail ? ` [${terminalFailure.detail}]` : ""}` : `Auto-wake could not reach a session for this task ${AUTO_WAKE_MAX_RETRIES} times and NO deliverable was recorded. Blocked for manual re-dispatch (not a completed review).`;
       let routed = "needs_review";
       try {
         routed = await routeUnrecoverableTask(deps, topTask.taskId, reviewReason, abandonReason);
@@ -3557,7 +3724,7 @@ async function reapOrphanedWorktrees(deps, nowMs = Date.now()) {
 }
 async function createWorktreeReaperRealDeps() {
   const { getPaneCwdAsync } = await import("./lib/tmux-status.js");
-  const { getGitRootAsync, isWorktreeDirtyAsync, GIT_CRYPT_SMUDGE_BYPASS_ARGS } = await import("./worktree-EMQCPGFE.js");
+  const { getGitRootAsync, isWorktreeDirtyAsync, GIT_CRYPT_SMUDGE_BYPASS_ARGS } = await import("./worktree-NMWDVT6N.js");
   const { statSync: statSync3 } = await import("fs");
   const { basename: basename2 } = await import("path");
   const { promisify: promisify2 } = await import("util");
@@ -3804,7 +3971,7 @@ function shouldNotifyTaskGroupViaIntercom(executionMode) {
 }
 async function pollTaskGroupBarriers() {
   try {
-    const { checkAndFireBarriers } = await import("./tasks-crud-JHSWL5NM.js");
+    const { checkAndFireBarriers } = await import("./tasks-crud-CYKUKS3F.js");
     const firedGroupIds = await checkAndFireBarriers();
     if (firedGroupIds.length === 0) return 0;
     const { getClient } = await import("./lib/database.js");
@@ -3887,6 +4054,7 @@ export {
   WEDGE_RECOVERY_TICKS_REQUIRED,
   clearInputBufferArgs,
   shouldKillIdleSession,
+  describeKillRefusal,
   isEventLoopBlockedRecently,
   pollIdleEmployees,
   checkSessionTTL,
@@ -3900,6 +4068,7 @@ export {
   saveNudgeState,
   createReviewNudgeRealDeps,
   createIdleNudgeRealDeps,
+  realKillProbeIo,
   createSessionTTLRealDeps,
   createIdleKillRealDeps,
   AUTO_WAKE_COOLDOWN_MS,