@askexenow/exe-os 0.9.280 → 0.9.282

package/dist/task-enforcement-5AOKXTY4.js

@@ -0,0 +1,439 @@
+import {
+  sendIntercom,
+  updateTaskStatus
+} from "./chunk-PC635OAG.js";
+import "./chunk-ARUTDXZX.js";
+import "./chunk-4FVVJ7ME.js";
+import "./chunk-4JERP7NT.js";
+import "./chunk-Y67VYYOA.js";
+import "./chunk-MVW62NIZ.js";
+import "./chunk-OYNKIAVW.js";
+import "./chunk-SSTLTIF3.js";
+import {
+  recordOrchestrationEventBestEffort
+} from "./chunk-FSRKIZGZ.js";
+import "./chunk-PMVOUPTY.js";
+import "./chunk-NGP6LSV2.js";
+import "./chunk-TQ4VXUAF.js";
+import "./chunk-CVYC6DUW.js";
+import "./chunk-OPU3NYOO.js";
+import "./chunk-GJV3WDWM.js";
+import "./chunk-MP2AFCGL.js";
+import "./chunk-JBXANNNB.js";
+import "./chunk-HYZV25LY.js";
+import {
+  isCoordinatorName
+} from "./chunk-52UDAVZE.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-YGWFBN5A.js";
+import "./chunk-5DNJPRDW.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-EAPUSVKS.js";
+import "./chunk-T3B5RK4H.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+
+// src/lib/task-enforcement.ts
+import { appendFile } from "fs/promises";
+import path from "path";
+var TASK_ENFORCEMENT_INTERVAL_MS = 6e4;
+var TASK_ENFORCEMENT_DEBOUNCE_MS = 18e4;
+var MANAGER_GRACE_PERIOD_MS = 6e5;
+var IDLE_PATTERNS = [
+  "Standing by",
+  "All tasks complete",
+  "No tasks found",
+  "Anything else?",
+  "What do you need?"
+];
+var NUDGE_ECHO_PATTERNS = [
+  "You have pending notifications",
+  "You have open tasks. Run list_tasks",
+  "You have more open tasks to dispatch",
+  "Run list_tasks to check for assigned work",
+  "Run list_tasks to find them"
+];
+var MCP_ZOMBIE_PATTERNS = [
+  "session expired",
+  "MCP server disconnected",
+  "MCP server is not connected",
+  'MCP server "exe-os" is not connected',
+  "MCP connection lost",
+  "MCP error",
+  "MCP_UNHEALTHY"
+];
+var MANAGER_ROLES = ["COO", "CTO"];
+var AUDIT_LOG_PATH = path.join(
+  process.env.HOME ?? process.env.USERPROFILE ?? "/tmp",
+  ".exe-os",
+  "enforcement-audit.jsonl"
+);
+function writeAuditEntry(entry) {
+  const line = JSON.stringify(entry) + "\n";
+  appendFile(AUDIT_LOG_PATH, line).catch(() => {
+  });
+}
+function decideManagerAction(counts, isIdle, withinGracePeriod, nudgeEcho) {
+  if (counts.openTasks === 0) return "skip";
+  if (withinGracePeriod) return "grace_period";
+  if (!isIdle) return "active";
+  if (nudgeEcho) return "active";
+  if ((counts.inProgressTasks ?? 0) > 0) return "active";
+  if (counts.activeSubtasks === 0) return "nudge";
+  return "soft_nudge";
+}
+function decideWorkerAction(taskCount, isIdle, nudgeEcho) {
+  if (taskCount === 0) return "skip";
+  if (nudgeEcho) return "idle";
+  return isIdle ? "nudge" : "idle";
+}
+function isIdlePane(paneText) {
+  return IDLE_PATTERNS.some((p) => paneText.includes(p));
+}
+function isCurrentlyIdle(paneText) {
+  const nonEmptyLines = paneText.split("\n").map((line) => line.trim()).filter(Boolean);
+  const lastLine = nonEmptyLines.at(-1) ?? "";
+  if (/(?:^|[>❯$#])\s*\/mcp\s*$/.test(lastLine)) return true;
+  if (IDLE_PATTERNS.some((p) => lastLine.includes(p))) return true;
+  if (lineHasMcpZombiePattern(lastLine)) return true;
+  const currentLines = nonEmptyLines.slice(-3);
+  return tailHasMcpZombieContext(currentLines) && lineLooksLikeMcpReconnectPrompt(lastLine);
+}
+function isNudgeEcho(paneText) {
+  return NUDGE_ECHO_PATTERNS.some((p) => paneText.includes(p));
+}
+function lineHasMcpZombiePattern(line) {
+  const lower = line.toLowerCase();
+  if (lower.includes("not connected") && !lower.includes("mcp server")) return false;
+  return MCP_ZOMBIE_PATTERNS.some((p) => lower.includes(p.toLowerCase()));
+}
+function tailHasMcpZombieContext(lines) {
+  return lines.some(lineHasMcpZombiePattern);
+}
+function lineLooksLikeMcpReconnectPrompt(line) {
+  const lower = line.toLowerCase();
+  return lower.includes("/mcp") && (lower.includes("reconnect") || lower.includes("connect") || lower.includes("run") || lower.includes("try"));
+}
+function isMcpZombiePane(paneText, paneCurrentlyIdle) {
+  if (!paneCurrentlyIdle) return false;
+  const nonEmptyLines = paneText.split("\n").map((line) => line.trim()).filter(Boolean);
+  const lastLine = nonEmptyLines.at(-1) ?? "";
+  if (/(?:^|[>❯$#])\s*\/mcp\s*$/.test(lastLine)) return true;
+  if (lineHasMcpZombiePattern(lastLine)) return true;
+  const currentLines = nonEmptyLines.slice(-3);
+  return tailHasMcpZombieContext(currentLines) && lineLooksLikeMcpReconnectPrompt(lastLine);
+}
+function sendNudge(transport, session, runtime, action) {
+  const message = action === "nudge" ? "You have open tasks. Run list_tasks to find them." : "You have more open tasks to dispatch. Run list_tasks.";
+  if (transport.sendKeysLiteral) {
+    transport.sendKeysLiteral(session, message);
+  } else {
+    transport.sendKeys(session, message);
+  }
+  process.stderr.write(
+    `[enforcement-audit] SENT nudge to ${session} (${runtime}, ${action})
+`
+  );
+}
+function _resetNudgeState() {
+}
+function coordinatorScopeFromSession(session) {
+  const dashIndex = session.indexOf("-");
+  if (dashIndex <= 0) return null;
+  const scope = session.slice(dashIndex + 1).trim();
+  return scope.length > 0 ? scope : null;
+}
+function strictTaskSessionScope(scope) {
+  if (!scope) return { sql: " AND session_scope IS NOT NULL AND 1 = 0", args: [] };
+  return { sql: " AND session_scope = ?", args: [scope] };
+}
+async function countOrphanedTasksForAgent(client, agentName, statuses) {
+  const result = await client.execute({
+    sql: `SELECT COUNT(*) as cnt FROM tasks WHERE assigned_to = ? AND status IN (${statuses}) AND session_scope IS NULL`,
+    args: [agentName]
+  });
+  return Number(result.rows[0]?.cnt ?? 0);
+}
+async function runTaskEnforcementTick(deps) {
+  const { transport, employees, client } = deps;
+  const now = deps.now ?? Date.now();
+  const tickStartedAt = Date.now();
+  const sessions = transport.listSessions();
+  let processedAnyEmployee = false;
+  let processedSessions = 0;
+  let nudgesSent = 0;
+  const processedScopes = /* @__PURE__ */ new Set();
+  recordOrchestrationEventBestEffort({
+    eventType: "daemon.tick.started",
+    source: "task-enforcement.runTaskEnforcementTick",
+    payload: { sessionCount: sessions.length }
+  });
+  const hasScopeRestriction = deps.scopeFilter.sql.length > 0;
+  const allowedScope = hasScopeRestriction && deps.scopeFilter.args.length > 0 ? String(deps.scopeFilter.args[deps.scopeFilter.args.length - 1]) : null;
+  for (const session of sessions) {
+    if (!session.includes("-")) continue;
+    const agentName = session.split("-")[0]?.replace(/\d+$/, "");
+    if (!agentName) continue;
+    if (allowedScope) {
+      const sessionSuffix = session.slice(session.indexOf("-") + 1);
+      if (sessionSuffix !== allowedScope) continue;
+    }
+    if ("isAlive" in transport && typeof transport.isAlive === "function") {
+      if (!transport.isAlive(session)) continue;
+    }
+    const employee = employees.find((e) => e.name === agentName);
+    if (!employee) continue;
+    processedAnyEmployee = true;
+    processedSessions++;
+    const coordinatorSession = coordinatorScopeFromSession(session);
+    const effectiveScope = strictTaskSessionScope(coordinatorSession);
+    if (coordinatorSession) processedScopes.add(coordinatorSession);
+    const isManager = MANAGER_ROLES.includes(employee.role);
+    try {
+      let action = "skip";
+      let reason = "";
+      let openTasks = 0;
+      let activeSubtasks = 0;
+      let paneIdle;
+      if (isManager) {
+        const openResult = await client.execute({
+          sql: `SELECT COUNT(*) as cnt FROM tasks WHERE assigned_to = ? AND status = 'open'${effectiveScope.sql}`,
+          args: [agentName, ...effectiveScope.args]
+        });
+        openTasks = Number(openResult.rows[0]?.cnt ?? 0);
+        if (openTasks === 0 && coordinatorSession) {
+          const orphaned = await countOrphanedTasksForAgent(client, agentName, "'open'");
+          if (orphaned > 0) {
+            process.stderr.write(
+              `[exed] Task enforcement: ${agentName}-${coordinatorSession} has ${orphaned} orphaned open task(s) with NULL session_scope; not nudging until owning scope is repaired.
+`
+            );
+          }
+        }
+        if (openTasks > 0) {
+          const subtaskResult = await client.execute({
+            sql: `SELECT COUNT(*) as cnt FROM tasks WHERE assigned_by = ? AND status = 'in_progress'${effectiveScope.sql}`,
+            args: [agentName, ...effectiveScope.args]
+          });
+          activeSubtasks = Number(subtaskResult.rows[0]?.cnt ?? 0);
+        }
+        let withinGracePeriod = false;
+        let graceRemaining = 0;
+        if (openTasks > 0) {
+          const newestResult = await client.execute({
+            sql: `SELECT created_at FROM tasks WHERE assigned_to = ? AND status = 'open'${effectiveScope.sql} ORDER BY created_at DESC LIMIT 1`,
+            args: [agentName, ...effectiveScope.args]
+          });
+          const newestCreatedAt = newestResult.rows[0]?.created_at;
+          if (newestCreatedAt) {
+            const taskAge = now - new Date(newestCreatedAt).getTime();
+            if (taskAge < MANAGER_GRACE_PERIOD_MS) {
+              withinGracePeriod = true;
+              graceRemaining = Math.round((MANAGER_GRACE_PERIOD_MS - taskAge) / 1e3);
+            }
+          }
+        }
+        let inProgressTasks = 0;
+        if (openTasks > 0) {
+          const ipResult = await client.execute({
+            sql: `SELECT COUNT(*) as cnt FROM tasks WHERE assigned_to = ? AND status = 'in_progress'${effectiveScope.sql}`,
+            args: [agentName, ...effectiveScope.args]
+          });
+          inProgressTasks = Number(ipResult.rows[0]?.cnt ?? 0);
+        }
+        const pane = deps.paneCache?.get(session) ?? (deps.capturePaneAsync ? await deps.capturePaneAsync(session, 20) : transport.capturePane(session, 20));
+        paneIdle = isIdlePane(pane);
+        const nudgeEcho = isNudgeEcho(pane);
+        action = decideManagerAction({ openTasks, activeSubtasks, inProgressTasks }, paneIdle, withinGracePeriod, nudgeEcho);
+        if (action === "skip") reason = "no open tasks";
+        else if (action === "grace_period") reason = `task assigned <10min ago (${graceRemaining}s remaining)`;
+        else if (action === "active") reason = nudgeEcho ? "pane shows previous nudge (anti-loop)" : inProgressTasks > 0 ? `${inProgressTasks} tasks in_progress` : "pane shows active work";
+        else if (action === "nudge") reason = `${openTasks} open tasks, 0 delegated, pane idle`;
+        else if (action === "soft_nudge") reason = `${openTasks} open tasks, ${activeSubtasks} delegated, pane idle`;
+        writeAuditEntry({
+          timestamp: new Date(now).toISOString(),
+          session,
+          agent: agentName,
+          role: "manager",
+          action,
+          reason,
+          openTasks,
+          activeSubtasks,
+          paneIdle,
+          graceRemaining: withinGracePeriod ? graceRemaining : void 0
+        });
+        process.stderr.write(
+          `[exed] Task enforcement: ${agentName} (manager) ${openTasks} open, ${activeSubtasks} delegated, pane=${paneIdle ? "idle" : "active"}. Action: ${action} (${reason})
+`
+        );
+      } else {
+        const taskResult = await client.execute({
+          sql: `SELECT COUNT(*) as cnt FROM tasks WHERE assigned_to = ? AND status IN ('open', 'in_progress')${effectiveScope.sql}`,
+          args: [agentName, ...effectiveScope.args]
+        });
+        const taskCount = Number(taskResult.rows[0]?.cnt ?? 0);
+        openTasks = taskCount;
+        if (taskCount === 0 && coordinatorSession) {
+          const orphaned = await countOrphanedTasksForAgent(client, agentName, "'open','in_progress'");
+          if (orphaned > 0) {
+            process.stderr.write(
+              `[exed] Task enforcement: ${agentName}-${coordinatorSession} has ${orphaned} orphaned task(s) with NULL session_scope; not nudging until owning scope is repaired.
+`
+            );
+          }
+        }
+        if (taskCount > 0) {
+          const pane = deps.paneCache?.get(session) ?? (deps.capturePaneAsync ? await deps.capturePaneAsync(session, 20) : transport.capturePane(session, 20));
+          paneIdle = isIdlePane(pane);
+          const workerNudgeEcho = isNudgeEcho(pane);
+          const paneCurrentlyIdle = isCurrentlyIdle(pane);
+          if (isMcpZombiePane(pane, paneCurrentlyIdle) && deps.zombieWorkerRecover) {
+            const reason2 = "pane shows dead MCP client";
+            await deps.zombieWorkerRecover(session, agentName, coordinatorSession ?? "", reason2);
+            writeAuditEntry({
+              timestamp: new Date(now).toISOString(),
+              session,
+              agent: agentName,
+              role: "worker",
+              action: "active",
+              reason: reason2,
+              openTasks: taskCount,
+              paneIdle
+            });
+            continue;
+          }
+          action = decideWorkerAction(taskCount, paneIdle, workerNudgeEcho);
+        }
+        if (action === "skip") reason = "no tasks";
+        else if (action === "idle") reason = `${taskCount} tasks but pane active`;
+        else if (action === "nudge") reason = `${taskCount} tasks, pane idle`;
+        writeAuditEntry({
+          timestamp: new Date(now).toISOString(),
+          session,
+          agent: agentName,
+          role: "worker",
+          action,
+          reason,
+          openTasks: taskCount,
+          paneIdle
+        });
+        process.stderr.write(
+          `[exed] Task enforcement: ${agentName} (worker) ${taskCount} tasks, pane=${paneIdle ?? "n/a"}. Action: ${action} (${reason})
+`
+        );
+      }
+      if (action === "skip" || action === "idle" || action === "grace_period" || action === "active") continue;
+      nudgesSent++;
+      sendIntercom(session, { callerSessionScope: coordinatorSession, reason: "nudge" });
+    } catch {
+    }
+  }
+  if (processedAnyEmployee) {
+    try {
+      const scopeList = allowedScope ? [...processedScopes].filter((s) => s === allowedScope) : [...processedScopes];
+      const staleBlocked = scopeList.length === 0 ? { rows: [] } : await client.execute({
+        sql: `SELECT t.id, t.title, b.status as blocker_status
+                  FROM tasks t
+                  JOIN tasks b ON t.blocked_by = b.id
+                  WHERE t.status = 'blocked'
+                    AND b.status IN ('done', 'cancelled', 'closed')
+                    AND t.session_scope IN (${scopeList.map(() => "?").join(",")})`,
+        args: scopeList
+      });
+      const nowIso = new Date(now).toISOString();
+      for (const row of staleBlocked.rows) {
+        try {
+          await updateTaskStatus({ taskId: String(row.id), status: "open" });
+        } catch {
+          await client.execute({
+            sql: `UPDATE tasks SET status = 'open', updated_at = ? WHERE id = ?`,
+            args: [nowIso, String(row.id)]
+          });
+        }
+        await client.execute({
+          sql: `UPDATE tasks SET blocked_by = NULL WHERE id = ?`,
+          args: [String(row.id)]
+        });
+        process.stderr.write(
+          `[exed] Auto-unblocked "${String(row.title)}" \u2014 blocker already ${String(row.blocker_status)}
+`
+        );
+      }
+    } catch {
+    }
+  }
+  if (processedAnyEmployee && deps.reviewerSpawn) {
+    try {
+      const scopeList = allowedScope ? [...processedScopes].filter((s) => s === allowedScope) : [...processedScopes];
+      const reviewerRows = scopeList.length === 0 ? { rows: [] } : await client.execute({
+        sql: `SELECT DISTINCT reviewer, session_scope FROM tasks
+                  WHERE status = 'needs_review'
+                    AND reviewer IS NOT NULL
+                    AND reviewer != ''
+                    AND session_scope IN (${scopeList.map(() => "?").join(",")})`,
+        args: scopeList
+      });
+      const liveSessionSet = new Set(sessions);
+      for (const row of reviewerRows.rows) {
+        const reviewerName = String(row.reviewer ?? "");
+        const sessionScope = row.session_scope ? String(row.session_scope) : null;
+        if (!reviewerName || !sessionScope) continue;
+        if (isCoordinatorName(reviewerName, employees)) {
+          process.stderr.write(
+            `[exed] Reviewer auto-spawn: skipping ${reviewerName} (coordinator, not dispatchable)
+`
+          );
+          continue;
+        }
+        const reviewerSession = `${reviewerName}-${sessionScope}`;
+        if (liveSessionSet.has(reviewerSession)) continue;
+        try {
+          const result = deps.reviewerSpawn(reviewerName, sessionScope);
+          if (!result) continue;
+          if (result.status === "spawned") {
+            process.stderr.write(
+              `[exed] Reviewer auto-spawn: spawned ${reviewerName} in ${sessionScope} (has needs_review tasks)
+`
+            );
+          } else if (result.status === "failed") {
+            process.stderr.write(
+              `[exed] Reviewer auto-spawn: failed to spawn ${reviewerName} in ${sessionScope}: ${result.error ?? "unknown"}
+`
+            );
+          }
+        } catch (spawnErr) {
+          process.stderr.write(
+            `[exed] Reviewer auto-spawn error for ${reviewerName}: ${spawnErr instanceof Error ? spawnErr.message : String(spawnErr)}
+`
+          );
+        }
+      }
+    } catch {
+    }
+  }
+  recordOrchestrationEventBestEffort({
+    eventType: "daemon.tick.completed",
+    source: "task-enforcement.runTaskEnforcementTick",
+    durationMs: Date.now() - tickStartedAt,
+    result: processedAnyEmployee ? "processed" : "no_employee_sessions",
+    payload: { sessionCount: sessions.length, processedSessions, nudgesSent }
+  });
+}
+export {
+  IDLE_PATTERNS,
+  MANAGER_GRACE_PERIOD_MS,
+  MANAGER_ROLES,
+  MCP_ZOMBIE_PATTERNS,
+  NUDGE_ECHO_PATTERNS,
+  TASK_ENFORCEMENT_DEBOUNCE_MS,
+  TASK_ENFORCEMENT_INTERVAL_MS,
+  _resetNudgeState,
+  decideManagerAction,
+  decideWorkerAction,
+  isCurrentlyIdle,
+  isIdlePane,
+  isMcpZombiePane,
+  isNudgeEcho,
+  runTaskEnforcementTick,
+  sendNudge
+};