@askexenow/exe-os 0.9.269 → 0.9.270

package/dist/task-enforcement-YXKZYS5L.js

@@ -0,0 +1,369 @@
+import {
+  sendIntercom,
+  updateTaskStatus
+} from "./chunk-BXY5Y3RI.js";
+import "./chunk-SD6UFZRH.js";
+import "./chunk-5CHYEKMH.js";
+import "./chunk-4JERP7NT.js";
+import "./chunk-GQ2XYRG3.js";
+import "./chunk-MVW62NIZ.js";
+import "./chunk-OYNKIAVW.js";
+import "./chunk-CX6GL3ZJ.js";
+import {
+  recordOrchestrationEventBestEffort
+} from "./chunk-JP45GCVR.js";
+import "./chunk-XJUUWHVN.js";
+import "./chunk-NGP6LSV2.js";
+import "./chunk-7SLLNRR3.js";
+import "./chunk-CVYC6DUW.js";
+import "./chunk-OPU3NYOO.js";
+import "./chunk-GJV3WDWM.js";
+import "./chunk-MP2AFCGL.js";
+import "./chunk-TN45CTOI.js";
+import "./chunk-HYZV25LY.js";
+import "./chunk-UNCGZXPU.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-VGYL7CN2.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-MOZ2YQ54.js";
+import "./chunk-VXIMSRTO.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",
+  "not connected",
+  "MCP server disconnected",
+  "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 isNudgeEcho(paneText) {
+  return NUDGE_ECHO_PATTERNS.some((p) => paneText.includes(p));
+}
+function isMcpZombiePane(paneText, paneIdle) {
+  if (!paneIdle) 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;
+  const currentLines = nonEmptyLines.slice(-3);
+  return currentLines.some((line) => {
+    const lower = line.toLowerCase();
+    return MCP_ZOMBIE_PATTERNS.some((p) => lower.includes(p.toLowerCase()));
+  });
+}
+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() {
+}
+async function runTaskEnforcementTick(deps) {
+  const { transport, employees, client, scopeFilter } = deps;
+  const now = deps.now ?? Date.now();
+  const tickStartedAt = Date.now();
+  const sessions = transport.listSessions();
+  let processedAnyEmployee = false;
+  let processedSessions = 0;
+  let nudgesSent = 0;
+  recordOrchestrationEventBestEffort({
+    eventType: "daemon.tick.started",
+    source: "task-enforcement.runTaskEnforcementTick",
+    payload: { sessionCount: sessions.length }
+  });
+  for (const session of sessions) {
+    if (!session.includes("-")) continue;
+    const agentName = session.split("-")[0]?.replace(/\d+$/, "");
+    if (!agentName) 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++;
+    let effectiveScope = scopeFilter;
+    const dashIndex = session.indexOf("-");
+    if (dashIndex > 0) {
+      const coordinatorSession = session.slice(dashIndex + 1);
+      if (coordinatorSession) {
+        effectiveScope = {
+          sql: " AND (session_scope IS NULL OR session_scope = ?)",
+          args: [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) {
+          const subtaskResult = await client.execute({
+            sql: `SELECT COUNT(*) as cnt FROM tasks WHERE assigned_by = ? AND status = 'in_progress'${scopeFilter.sql}`,
+            args: [agentName, ...scopeFilter.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'${scopeFilter.sql} ORDER BY created_at DESC LIMIT 1`,
+            args: [agentName, ...scopeFilter.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) {
+          const pane = deps.paneCache?.get(session) ?? (deps.capturePaneAsync ? await deps.capturePaneAsync(session, 20) : transport.capturePane(session, 20));
+          paneIdle = isIdlePane(pane);
+          const workerNudgeEcho = isNudgeEcho(pane);
+          if (isMcpZombiePane(pane, paneIdle) && deps.zombieWorkerRecover) {
+            const reason2 = "pane shows dead MCP client";
+            await deps.zombieWorkerRecover(session, agentName, effectiveScope.args[0] ? String(effectiveScope.args[0]) : "", 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);
+    } catch {
+    }
+  }
+  if (processedAnyEmployee) {
+    try {
+      const staleBlocked = 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')${scopeFilter.sql}`,
+        args: [...scopeFilter.args]
+      });
+      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 reviewerRows = await client.execute({
+        sql: `SELECT DISTINCT reviewer, session_scope FROM tasks
+              WHERE status = 'needs_review'
+                AND reviewer IS NOT NULL
+                AND reviewer != ''${scopeFilter.sql}`,
+        args: [...scopeFilter.args]
+      });
+      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;
+        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,
+  isIdlePane,
+  isMcpZombiePane,
+  isNudgeEcho,
+  runTaskEnforcementTick,
+  sendNudge
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askexenow/exe-os",
-  "version": "0.9.269",
+  "version": "0.9.270",
   "description": "AI employee operating system — persistent memory, task management, and multi-agent coordination for Claude Code.",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",

package/release-notes.json

@@ -1,6 +1,38 @@
 {
-  "current": "0.9.269",
+  "current": "0.9.270",
   "notes": {
+    "0.9.270": {
+      "version": "0.9.270",
+      "date": "2026-06-11",
+      "features": [],
+      "fixes": [
+        "harden MCP zombie gate + stale init-db.sql staging + CRM_GRAPHQL_URL default",
+        "exe-start PATH resolution + conservative MCP zombie/session recovery",
+        "stack-update rollback migrations, image pull verification, cloudflared healthcheck",
+        "Fix remaining exe-os support bugs",
+        "widen gateway-client waitFor to 15s for loaded 4-core runner",
+        "bind gateway-client mock WS server to 127.0.0.1 explicitly",
+        "ephemeral WS port + registry-host-agnostic parity assert",
+        "make tests robust on persistent self-hosted runner",
+        "Fix shard founder scope and MCP session TTL",
+        "Fix session-scoped notifications and RSS smoke gate",
+        "Fix degraded daemon boot bug paths",
+        "resource-triggered daemon restarts exit non-zero so launchd relaunches"
+      ],
+      "security": [
+        "Enforce cross-stack UX and security contracts"
+      ],
+      "other": [
+        "Update memory score history for 0.9.267 publish",
+        "quarantine gateway-client suite in CI with loud warning — tracked bug",
+        "retry budget (2) for gateway-client on the shared runner",
+        "separate vitest invocations for serial files — perf-stress fake timers poison a shared fork",
+        "daemon-perf-stress joins the serial pass — timing comparisons need a quiet box",
+        "run gateway-client serially after the parallel suite",
+        "retrigger"
+      ],
+      "migration_notes": []
+    },
     "0.9.269": {
       "version": "0.9.269",
       "date": "2026-06-10",
@@ -90,19 +122,6 @@
       ],
       "other": [],
       "migration_notes": []
-    },
-    "0.9.265": {
-      "version": "0.9.265",
-      "date": "2026-06-10",
-      "features": [
-        "honor sendUrl from gateway.json in send_whatsapp MCP tool"
-      ],
-      "fixes": [
-        "scope MCP queues and preserve live daemon chunks"
-      ],
-      "security": [],
-      "other": [],
-      "migration_notes": []
     }
   }
 }

package/stack.release.json

@@ -1,51 +1,51 @@
 {
- "$schema": "https://updates.askexe.com/schemas/stack.release.schema.json",
- "schemaVersion": 1,
- "repo": "AskExe/exe-os",
- "service": "exe-os",
- "packageName": "@askexenow/exe-os",
- "version": "0.9.258",
- "image": "ghcr.io/askexe/exe-os:v0.9.258",
- "imageEnv": "EXE_OS_IMAGE_TAG",
- "stackParticipation": {
-  "required": true,
-  "compatibleStack": ">=0.9.0 <1.0.0",
-  "health": [
-   {
-    "type": "http",
-    "url": "http://127.0.0.1:8765/health"
-   }
-  ],
-  "smokeTests": [
-   {
-    "name": "exe healthcheck",
-    "command": "exe-os healthcheck"
-   },
-   {
-    "name": "mcp startup",
-    "command": "node dist/mcp/server.js --help",
-    "optional": true
-   }
-  ],
-  "migrations": {
-   "command": "npm run build",
-   "rollback": "Restore previous EXE_OS_IMAGE_TAG and restart exe-os; local SQLCipher memory data is not overwritten by updates."
+  "$schema": "https://updates.askexe.com/schemas/stack.release.schema.json",
+  "schemaVersion": 1,
+  "repo": "AskExe/exe-os",
+  "service": "exe-os",
+  "packageName": "@askexenow/exe-os",
+  "version": "0.9.270",
+  "image": "ghcr.io/askexe/exe-os:v0.9.270",
+  "imageEnv": "EXE_OS_IMAGE_TAG",
+  "stackParticipation": {
+    "required": true,
+    "compatibleStack": ">=0.9.0 <1.0.0",
+    "health": [
+      {
+        "type": "http",
+        "url": "http://127.0.0.1:8765/health"
+      }
+    ],
+    "smokeTests": [
+      {
+        "name": "exe healthcheck",
+        "command": "exe-os healthcheck"
+      },
+      {
+        "name": "mcp startup",
+        "command": "node dist/mcp/server.js --help",
+        "optional": true
+      }
+    ],
+    "migrations": {
+      "command": "npm run build",
+      "rollback": "Restore previous EXE_OS_IMAGE_TAG and restart exe-os; local SQLCipher memory data is not overwritten by updates."
+    },
+    "config": {
+      "envExample": "deploy/compose/.env.example",
+      "requiredEnv": [
+        "EXE_OS_IMAGE_TAG",
+        "EXED_MCP_TOKEN",
+        "EXED_DEVICE_ID"
+      ]
+    },
+    "breakingChanges": [],
+    "dataSovereignty": "Customer-local memory/tasks/behaviors stay in SQLCipher/local storage. Updates must not overwrite roster, identity, behavior, or local memory files.",
+    "releaseLine": "v0.9 private/customer pilot; v1.0 is public-beta stable.",
+    "highGhostStack": "0.9.9",
+    "deploymentScope": "customer"
   },
-  "config": {
-   "envExample": "deploy/compose/.env.example",
-   "requiredEnv": [
-    "EXE_OS_IMAGE_TAG",
-    "EXED_MCP_TOKEN",
-    "EXED_DEVICE_ID"
-   ]
-  },
-  "breakingChanges": [],
-  "dataSovereignty": "Customer-local memory/tasks/behaviors stay in SQLCipher/local storage. Updates must not overwrite roster, identity, behavior, or local memory files.",
-  "releaseLine": "v0.9 private/customer pilot; v1.0 is public-beta stable.",
+  "deploymentScope": "customer",
   "highGhostStack": "0.9.9",
-  "deploymentScope": "customer"
- },
- "deploymentScope": "customer",
- "highGhostStack": "0.9.9",
- "sourceVersion": "0.9.258"
-}
+  "sourceVersion": "0.9.270"
+}