@askexenow/exe-os 0.8.36 → 0.8.37

package/dist/tui/App.js

@@ -6028,6 +6028,7 @@ var init_capacity_monitor = __esm({
 // src/lib/tmux-routing.ts
 var tmux_routing_exports = {};
 __export(tmux_routing_exports, {
+  acquireSpawnLock: () => acquireSpawnLock,
   employeeSessionName: () => employeeSessionName,
   ensureEmployee: () => ensureEmployee,
   extractRootExe: () => extractRootExe,
@@ -6042,6 +6043,7 @@ __export(tmux_routing_exports, {
   notifyParentExe: () => notifyParentExe,
   parseParentExe: () => parseParentExe,
   registerParentExe: () => registerParentExe,
+  releaseSpawnLock: () => releaseSpawnLock,
   resolveExeSession: () => resolveExeSession,
   sendIntercom: () => sendIntercom,
   spawnEmployee: () => spawnEmployee,
@@ -6052,6 +6054,42 @@ import { readFileSync as readFileSync10, writeFileSync as writeFileSync5, mkdirS
 import path19 from "path";
 import os6 from "os";
 import { fileURLToPath } from "url";
+import { unlinkSync as unlinkSync4 } from "fs";
+function spawnLockPath(sessionName) {
+  return path19.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function acquireSpawnLock(sessionName) {
+  if (!existsSync11(SPAWN_LOCK_DIR)) {
+    mkdirSync5(SPAWN_LOCK_DIR, { recursive: true });
+  }
+  const lockFile = spawnLockPath(sessionName);
+  if (existsSync11(lockFile)) {
+    try {
+      const lock = JSON.parse(readFileSync10(lockFile, "utf8"));
+      const age = Date.now() - lock.timestamp;
+      if (isProcessAlive(lock.pid) && age < 6e4) {
+        return false;
+      }
+    } catch {
+    }
+  }
+  writeFileSync5(lockFile, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
+  return true;
+}
+function releaseSpawnLock(sessionName) {
+  try {
+    unlinkSync4(spawnLockPath(sessionName));
+  } catch {
+  }
+}
 function resolveBehaviorsExporterScript() {
   try {
     const thisFile = fileURLToPath(import.meta.url);
@@ -6150,10 +6188,10 @@ function isEmployeeAlive(sessionName) {
 }
 function findFreeInstance(employeeName, exeSession, maxInstances = 10, isAlive = isEmployeeAlive) {
   const base = employeeSessionName(employeeName, exeSession);
-  if (!isAlive(base)) return 0;
+  if (!isAlive(base) && acquireSpawnLock(base)) return 0;
   for (let i = 2; i <= maxInstances; i++) {
     const candidate = employeeSessionName(employeeName, exeSession, i);
-    if (!isAlive(candidate)) return i;
+    if (!isAlive(candidate) && acquireSpawnLock(candidate)) return i;
   }
   return null;
 }
@@ -6517,6 +6555,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     command: spawnCommand
   });
   if (spawnResult.error) {
+    releaseSpawnLock(sessionName);
     return { sessionName, error: `tmux new-session failed: ${spawnResult.error}` };
   }
   transport.pipeLog(sessionName, logFile);
@@ -6554,6 +6593,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     }
   }
   if (!booted) {
+    releaseSpawnLock(sessionName);
     return { sessionName, error: `${useExeAgent ? "exe-agent" : "claude"} did not boot within 15s` };
   }
   if (!useExeAgent) {
@@ -6570,9 +6610,10 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     pid: 0,
     registeredAt: (/* @__PURE__ */ new Date()).toISOString()
   });
+  releaseSpawnLock(sessionName);
   return { sessionName };
 }
-var SESSION_CACHE, BEHAVIORS_EXPORT_TIMEOUT_MS, VERIFY_PANE_LINES, INTERCOM_DEBOUNCE_MS, INTERCOM_LOG2, DEBOUNCE_FILE, DEBOUNCE_CLEANUP_AGE_MS, BUSY_PATTERN;
+var SPAWN_LOCK_DIR, SESSION_CACHE, BEHAVIORS_EXPORT_TIMEOUT_MS, VERIFY_PANE_LINES, INTERCOM_DEBOUNCE_MS, INTERCOM_LOG2, DEBOUNCE_FILE, DEBOUNCE_CLEANUP_AGE_MS, BUSY_PATTERN;
 var init_tmux_routing = __esm({
   "src/lib/tmux-routing.ts"() {
     "use strict";
@@ -6584,6 +6625,7 @@ var init_tmux_routing = __esm({
     init_provider_table();
     init_intercom_queue();
     init_plan_limits();
+    SPAWN_LOCK_DIR = path19.join(os6.homedir(), ".exe-os", "spawn-locks");
     SESSION_CACHE = path19.join(os6.homedir(), ".exe-os", "session-cache");
     BEHAVIORS_EXPORT_TIMEOUT_MS = 1e4;
     VERIFY_PANE_LINES = 200;
@@ -7734,7 +7776,8 @@ async function writeMemory(record) {
     has_error: record.has_error ? 1 : 0,
     raw_text: record.raw_text,
     vector: record.vector,
-    version: _nextVersion++,
+    version: 0,
+    // Placeholder — assigned atomically at flush time
     task_id: record.task_id ?? null,
     importance: record.importance ?? 5,
     status: record.status ?? "active",
@@ -7768,6 +7811,13 @@ async function flushBatch() {
   _flushing = true;
   try {
     const batch = _pendingRecords.slice(0);
+    const client = getClient();
+    const vResult = await client.execute("SELECT MAX(version) as max_v FROM memories");
+    let baseVersion = (Number(vResult.rows[0]?.max_v) || 0) + 1;
+    for (const row of batch) {
+      row.version = baseVersion++;
+    }
+    _nextVersion = baseVersion;
     const buildStmt = (row) => {
       const hasVector = row.vector !== null;
       const taskId = row.task_id ?? null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askexenow/exe-os",
-  "version": "0.8.36",
+  "version": "0.8.37",
   "description": "AI employee operating system — persistent memory, task management, and multi-agent coordination for Claude Code.",
   "license": "CC-BY-NC-4.0",
   "type": "module",
@@ -59,7 +59,7 @@
     "./mcp/server": "./dist/mcp/server.js"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20.0.0"
   },
   "scripts": {
     "test": "vitest run",

package/src/commands/exe/afk.md

@@ -0,0 +1,116 @@
+---
+description: "Enter AFK mode — autonomously process reviews, dispatch work, and monitor employees on a timer"
+allowed-tools: Bash, Read, Glob, Grep, mcp__exe-mem__list_tasks, mcp__exe-mem__get_task, mcp__exe-mem__close_task, mcp__exe-mem__create_task, mcp__exe-mem__update_task, mcp__exe-mem__store_memory, mcp__exe-mem__recall_my_memory, mcp__exe-mem__ask_team_memory, mcp__exe-mem__send_message, mcp__exe-mem__store_behavior, mcp__exe-mem__get_identity
+argument-hint: "[stop | interval-minutes]"
+---
+
+# AFK Mode — Autonomous COO Operations
+
+The founder is stepping away. You (exe) now operate autonomously.
+
+## If argument is "stop"
+
+Kill the background AFK loop and summarize:
+
+```bash
+# Kill the AFK background loop
+AFK_PID=$(cat ~/.exe-os/afk-loop.pid 2>/dev/null)
+if [ -n "$AFK_PID" ]; then
+  kill "$AFK_PID" 2>/dev/null
+  rm -f ~/.exe-os/afk-loop.pid
+  echo "AFK loop stopped (PID $AFK_PID)"
+else
+  echo "No active AFK loop found"
+fi
+```
+
+Then read the AFK log and summarize what happened:
+```bash
+cat ~/.exe-os/afk-log.txt 2>/dev/null || echo "No AFK log found"
+```
+
+Print: "AFK mode ended. Here's what happened while you were away:" then summarize all actions from the log. Clean up the log file.
+
+## Otherwise, start AFK mode
+
+Default interval: 5 minutes. Override with argument (e.g., `/exe-afk 10` = every 10 min).
+
+### Step 1: Determine the exe tmux session name
+```bash
+tmux display-message -p '#{session_name}' 2>/dev/null
+```
+
+### Step 2: Start the background ticker
+
+This launches a background bash loop that sends review prompts into YOUR tmux session on the interval. Each send triggers a fresh Claude turn — you'll process reviews as if the founder typed the command.
+
+```bash
+INTERVAL_SECONDS=$((${INTERVAL_MINUTES:-5} * 60))
+EXE_SESSION="${SESSION_NAME}"
+
+# Clean up any existing loop
+OLD_PID=$(cat ~/.exe-os/afk-loop.pid 2>/dev/null)
+[ -n "$OLD_PID" ] && kill "$OLD_PID" 2>/dev/null
+
+# Start the AFK ticker as a background process
+nohup bash -c "
+  echo \"AFK mode started at \$(date -Iseconds) — interval ${INTERVAL_SECONDS}s\" >> ~/.exe-os/afk-log.txt
+  while true; do
+    sleep ${INTERVAL_SECONDS}
+    # Send the review command into exe's tmux session
+    tmux send-keys -t '${EXE_SESSION}' '/exe-review' Enter 2>/dev/null
+    echo \"AFK tick at \$(date -Iseconds) — sent /exe-review to ${EXE_SESSION}\" >> ~/.exe-os/afk-log.txt
+  done
+" > /dev/null 2>&1 &
+
+# Save PID for stop command
+echo $! > ~/.exe-os/afk-loop.pid
+echo "AFK loop started — PID $!, interval ${INTERVAL_SECONDS}s, target session: ${EXE_SESSION}"
+```
+
+### Step 3: Confirm to founder
+
+Print:
+```
+🤖 AFK MODE ACTIVE — checking every {N}m
+Background loop PID: {PID}
+Target session: {SESSION}
+
+I'll automatically process reviews every {N} minutes.
+Each tick sends /exe-review into this session — I'll handle it like a normal prompt.
+Say /exe-afk stop when you return.
+```
+
+### Step 4: Do an immediate first tick
+
+Don't wait for the first interval — process reviews RIGHT NOW before the founder leaves:
+
+1. Run: `node "$(npm root -g)/exe-os/dist/bin/exe-pending-reviews.js" 2>/dev/null`
+2. If reviews pending: process them (get_task → verify → close_task or reject)
+3. Check blocked tasks: `list_tasks status=blocked`
+4. Check idle employees: `tmux capture-pane` on active sessions
+
+## What /exe-review does when triggered by AFK tick
+
+Each time the background loop sends `/exe-review` into the session, you (exe) will:
+
+1. **Check pending reviews** — process each one:
+   - Pull task with `get_task`
+   - Read deliverable (exe/output/, git log, worktree branches)
+   - Verify: tests pass? Output exists? Requirements met?
+   - PASS → `close_task` with result summary
+   - FAIL → `update_task` back to open with failure reason
+   - UNCERTAIN → skip, log for founder
+
+2. **Check stuck employees** — tmux capture-pane on active sessions
+3. **Check blocked tasks** — anything blocked >24h gets flagged
+4. **Dispatch next work** — idle employees with open tasks get assigned
+
+## Rules for autonomous operation
+- NEVER make architectural decisions — those wait for founder
+- NEVER modify code directly — dispatch to employees
+- NEVER approve work you can't verify (no tests = no approval)
+- DO process routine reviews (tests pass, output exists, requirements met)
+- DO dispatch queued work to idle employees
+- DO flag anything ambiguous for founder review
+- If you hit context capacity (>80%), run `/exe-afk stop` and summarize