@askexenow/exe-os 0.9.292 → 0.9.293

package/dist/chunk-RAERYWCL.js

@@ -0,0 +1,299 @@
+import {
+  recordOrchestrationEventBestEffort
+} from "./chunk-DVFHAY2J.js";
+import {
+  atomicWriteJsonSync
+} from "./chunk-LYH5HE24.js";
+
+// src/lib/session-registry.ts
+import { readFileSync, mkdirSync, existsSync, openSync, closeSync, writeSync, unlinkSync, constants } from "fs";
+import { execFileSync } from "child_process";
+import path from "path";
+import os from "os";
+var REGISTRY_PATH = path.join(os.homedir(), ".exe-os", "session-registry.json");
+var REGISTRY_LOCK_PATH = `${REGISTRY_PATH}.lock`;
+var REGISTRY_CACHE_TTL_MS = 100;
+var registryCache = null;
+function acquireRegistryLock() {
+  const dir = path.dirname(REGISTRY_PATH);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  const data = JSON.stringify({ pid: process.pid, timestamp: Date.now() });
+  const deadline = Date.now() + 250;
+  while (Date.now() < deadline) {
+    try {
+      const fd = openSync(REGISTRY_LOCK_PATH, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, 384);
+      writeSync(fd, data);
+      closeSync(fd);
+      return true;
+    } catch (err) {
+      if (err.code !== "EEXIST") return false;
+      try {
+        const lock = JSON.parse(readFileSync(REGISTRY_LOCK_PATH, "utf8"));
+        if (Date.now() - Number(lock.timestamp ?? 0) > 3e4) unlinkSync(REGISTRY_LOCK_PATH);
+      } catch {
+        try {
+          unlinkSync(REGISTRY_LOCK_PATH);
+        } catch {
+        }
+      }
+    }
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25);
+  }
+  return false;
+}
+function releaseRegistryLock() {
+  try {
+    unlinkSync(REGISTRY_LOCK_PATH);
+  } catch {
+  }
+}
+function readSessionsUncached() {
+  try {
+    const raw = readFileSync(REGISTRY_PATH, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
+function writeSessions(sessions) {
+  atomicWriteJsonSync(REGISTRY_PATH, sessions);
+  registryCache = { at: Date.now(), sessions };
+}
+function registerSession(entry) {
+  const dir = path.dirname(REGISTRY_PATH);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const _locked = acquireRegistryLock();
+  try {
+    const sessions = readSessionsUncached();
+    const idx = sessions.findIndex((s) => s.windowName === entry.windowName);
+    if (idx >= 0) {
+      sessions[idx] = entry;
+    } else {
+      sessions.push(entry);
+    }
+    writeSessions(sessions);
+  } finally {
+    if (_locked) releaseRegistryLock();
+  }
+  recordOrchestrationEventBestEffort({
+    eventType: "registry.registered",
+    source: "session-registry.registerSession",
+    agentId: entry.agentId,
+    sessionScope: entry.parentExe,
+    tmuxSession: entry.windowName,
+    payload: { hasProjectDir: Boolean(entry.projectDir) }
+  });
+}
+function refreshSessionProject(windowName, projectDir) {
+  if (!acquireRegistryLock()) return;
+  try {
+    const sessions = readSessionsUncached();
+    const entry = sessions.find((s) => s.windowName === windowName);
+    if (!entry || entry.projectDir === projectDir) return;
+    entry.projectDir = projectDir;
+    writeSessions(sessions);
+  } catch {
+  } finally {
+    releaseRegistryLock();
+  }
+}
+function listSessions() {
+  const now = Date.now();
+  if (registryCache && now - registryCache.at < REGISTRY_CACHE_TTL_MS) {
+    return registryCache.sessions;
+  }
+  const sessions = readSessionsUncached();
+  registryCache = { at: now, sessions };
+  return sessions;
+}
+function pruneStaleSessions() {
+  if (!acquireRegistryLock()) return 0;
+  const sessions = readSessionsUncached();
+  if (sessions.length === 0) {
+    releaseRegistryLock();
+    return 0;
+  }
+  let liveSessions = [];
+  try {
+    liveSessions = execFileSync("tmux", ["list-sessions", "-F", "#{session_name}"], {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim().split("\n").filter(Boolean);
+  } catch {
+    releaseRegistryLock();
+    return 0;
+  }
+  const liveSet = new Set(liveSessions);
+  const alive = sessions.filter((s) => liveSet.has(s.windowName));
+  const staleSessions = sessions.filter((s) => !liveSet.has(s.windowName));
+  if (staleSessions.length > 0) {
+    recordOrchestrationEventBestEffort({
+      eventType: "registry.missing_tmux",
+      source: "session-registry.pruneStaleSessions",
+      severity: "warn",
+      attempt: staleSessions.length,
+      payload: {
+        count: staleSessions.length,
+        examples: staleSessions.slice(0, 5).map((s) => s.windowName)
+      }
+    });
+  }
+  const pruned = sessions.length - alive.length;
+  if (pruned > 0) {
+    writeSessions(alive);
+  }
+  releaseRegistryLock();
+  return pruned;
+}
+function checkSessionRegistryConsistency(liveSessionsOverride) {
+  const sessions = listSessions();
+  const result = { missingTmux: 0, missingRegistry: 0 };
+  let liveSessions = liveSessionsOverride;
+  if (!liveSessions) {
+    try {
+      liveSessions = execFileSync("tmux", ["list-sessions", "-F", "#{session_name}"], {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim().split("\n").filter(Boolean);
+    } catch {
+      return result;
+    }
+  }
+  const liveSet = new Set(liveSessions);
+  const registeredSet = new Set(sessions.map((s) => s.windowName));
+  const missingTmuxExamples = [];
+  const missingRegistryExamples = [];
+  for (const entry of sessions) {
+    if (liveSet.has(entry.windowName)) continue;
+    result.missingTmux++;
+    if (missingTmuxExamples.length < 5) missingTmuxExamples.push(entry.windowName);
+  }
+  for (const live of liveSessions) {
+    if (registeredSet.has(live)) continue;
+    if (!looksLikeExeOsSession(live)) continue;
+    result.missingRegistry++;
+    if (missingRegistryExamples.length < 5) missingRegistryExamples.push(live);
+  }
+  if (result.missingTmux > 0) {
+    recordOrchestrationEventBestEffort({
+      eventType: "registry.missing_tmux",
+      source: "session-registry.checkSessionRegistryConsistency",
+      severity: "warn",
+      attempt: result.missingTmux,
+      payload: {
+        count: result.missingTmux,
+        examples: missingTmuxExamples
+      }
+    });
+  }
+  if (result.missingRegistry > 0) {
+    recordOrchestrationEventBestEffort({
+      eventType: "registry.missing_entry",
+      source: "session-registry.checkSessionRegistryConsistency",
+      severity: "warn",
+      attempt: result.missingRegistry,
+      payload: {
+        count: result.missingRegistry,
+        examples: missingRegistryExamples
+      }
+    });
+  }
+  return result;
+}
+function deregisterSession(windowName) {
+  if (!acquireRegistryLock()) return null;
+  try {
+    const sessions = readSessionsUncached();
+    const idx = sessions.findIndex((s) => s.windowName === windowName);
+    if (idx < 0) return null;
+    const removed = sessions.splice(idx, 1)[0];
+    writeSessions(sessions);
+    recordOrchestrationEventBestEffort({
+      eventType: "registry.deregistered",
+      source: "session-registry.deregisterSession",
+      agentId: removed.agentId,
+      sessionScope: removed.parentExe,
+      tmuxSession: windowName,
+      payload: { reason: "admin_force_deregister" }
+    });
+    return removed;
+  } finally {
+    releaseRegistryLock();
+  }
+}
+function cleanupDeadSessions() {
+  if (!acquireRegistryLock()) return { pruned: 0, remaining: 0, removed: [] };
+  try {
+    const sessions = readSessionsUncached();
+    if (sessions.length === 0) return { pruned: 0, remaining: 0, removed: [] };
+    let liveTmux;
+    try {
+      const raw = execFileSync("tmux", ["list-sessions", "-F", "#{session_name}"], {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      liveTmux = new Set(raw.split("\n").filter(Boolean));
+    } catch {
+      liveTmux = /* @__PURE__ */ new Set();
+    }
+    const alive = [];
+    const removed = [];
+    for (const s of sessions) {
+      const tmuxAlive = liveTmux.has(s.windowName);
+      let pidAlive = false;
+      try {
+        process.kill(s.pid, 0);
+        pidAlive = true;
+      } catch {
+      }
+      if (tmuxAlive || pidAlive) {
+        alive.push(s);
+      } else {
+        removed.push(s.windowName);
+      }
+    }
+    if (removed.length > 0) {
+      writeSessions(alive);
+      recordOrchestrationEventBestEffort({
+        eventType: "registry.cleanup",
+        source: "session-registry.cleanupDeadSessions",
+        severity: "info",
+        payload: { pruned: removed.length, remaining: alive.length, examples: removed.slice(0, 10) }
+      });
+    }
+    return { pruned: removed.length, remaining: alive.length, removed };
+  } finally {
+    releaseRegistryLock();
+  }
+}
+function looksLikeExeOsSession(sessionName) {
+  const coordName = getCoordinatorNameCached();
+  const escaped = coordName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const coordPattern = new RegExp(`^${escaped}\\d*$`);
+  const employeePattern = new RegExp(`-${escaped}\\d*$`);
+  return coordPattern.test(sessionName) || employeePattern.test(sessionName);
+}
+function getCoordinatorNameCached() {
+  try {
+    const rosterPath = path.join(os.homedir(), ".exe-os", "exe-employees.json");
+    if (existsSync(rosterPath)) {
+      const roster = JSON.parse(readFileSync(rosterPath, "utf8"));
+      const coo = roster.find((e) => (e.role ?? "").toUpperCase() === "COO");
+      if (coo?.name) return coo.name;
+    }
+  } catch {
+  }
+  return "exe";
+}
+
+export {
+  registerSession,
+  refreshSessionProject,
+  listSessions,
+  pruneStaleSessions,
+  checkSessionRegistryConsistency,
+  deregisterSession,
+  cleanupDeadSessions
+};

package/dist/chunk-RT5NXMH2.js

@@ -0,0 +1,284 @@
+import {
+  routeTask
+} from "./chunk-ALYNEMIH.js";
+import {
+  createTaskCore,
+  employeeSessionName,
+  ensureEmployee,
+  getSessionState,
+  isEmployeeAlive,
+  sessionScopeFilter,
+  updateTaskStatus
+} from "./chunk-2ZXMXFGH.js";
+import {
+  DEFAULT_COORDINATOR_TEMPLATE_NAME,
+  getCoordinatorName
+} from "./chunk-TM2GZWIT.js";
+
+// src/runtime/orchestrator.ts
+var STALE_THRESHOLD_MS = 2 * 60 * 60 * 1e3;
+var MultiAgentOrchestrator = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Route and dispatch a single task to the best-fit employee.
+   */
+  async dispatchTask(task) {
+    let targetEmployee;
+    let routingScore = 0;
+    if (task.assignTo) {
+      const found = this.config.employees.find((e) => e.name === task.assignTo);
+      if (!found) {
+        return {
+          employee: task.assignTo,
+          sessionName: "",
+          status: "failed",
+          routingScore: 0,
+          error: `Employee "${task.assignTo}" not found`
+        };
+      }
+      targetEmployee = found;
+      routingScore = 1;
+    } else {
+      const routed = await routeTask(
+        `${task.title}
+${task.context}`,
+        this.config.employees,
+        this.config.embedFn,
+        this.config.searchFn
+      );
+      targetEmployee = routed.employee;
+      routingScore = routed.score;
+    }
+    try {
+      await createTaskCore({
+        title: task.title,
+        assignedTo: targetEmployee.name,
+        assignedBy: getCoordinatorName(),
+        projectName: task.projectName,
+        priority: task.priority,
+        context: task.context,
+        baseDir: this.config.projectDir,
+        skipDispatch: true
+      });
+    } catch (err) {
+      return {
+        employee: targetEmployee.name,
+        sessionName: "",
+        status: "failed",
+        routingScore,
+        error: `Task creation failed: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+    const result = ensureEmployee(
+      targetEmployee.name,
+      this.config.exeSession,
+      this.config.projectDir,
+      task.spawnOpts
+    );
+    return {
+      employee: targetEmployee.name,
+      sessionName: result.sessionName,
+      status: result.status === "failed" ? "failed" : result.status === "spawned" ? "dispatched" : "already_running",
+      routingScore,
+      error: result.error
+    };
+  }
+  /**
+   * Check health of all employees. Detect stuck and idle agents.
+   */
+  async healthCheck() {
+    const { getClient } = await import("./lib/database.js");
+    const client = getClient();
+    const employees = [];
+    const stuckAgents = [];
+    const idleAgents = [];
+    const crashedSessions = [];
+    let totalOpen = 0;
+    let totalInProgress = 0;
+    for (const emp of this.config.employees) {
+      const sessionName = employeeSessionName(emp.name, this.config.exeSession);
+      const alive = isEmployeeAlive(sessionName);
+      const state = alive ? getSessionState(sessionName) : "offline";
+      const oScope = sessionScopeFilter();
+      const tasks = await client.execute({
+        sql: `SELECT title, status, updated_at FROM tasks
+              WHERE assigned_to = ? AND status IN ('open', 'in_progress')${oScope.sql}
+              ORDER BY priority ASC`,
+        args: [emp.name, ...oScope.args]
+      });
+      const openCount = tasks.rows.filter((r) => r.status === "open").length;
+      const inProgressCount = tasks.rows.filter((r) => r.status === "in_progress").length;
+      totalOpen += openCount;
+      totalInProgress += inProgressCount;
+      const staleTasks = [];
+      for (const row of tasks.rows) {
+        if (row.status === "in_progress" && row.updated_at) {
+          const age = Date.now() - new Date(String(row.updated_at)).getTime();
+          if (age > STALE_THRESHOLD_MS) {
+            staleTasks.push(String(row.title));
+          }
+        }
+      }
+      const crashed = !alive && inProgressCount > 0;
+      if (staleTasks.length > 0) {
+        stuckAgents.push(emp.name);
+      }
+      if (crashed) {
+        crashedSessions.push(emp.name);
+      }
+      if (alive && state === "idle" && openCount + inProgressCount === 0) {
+        idleAgents.push(emp.name);
+      }
+      employees.push({
+        name: emp.name,
+        role: emp.role,
+        sessionName,
+        alive,
+        crashed,
+        state,
+        taskCount: openCount + inProgressCount,
+        inProgressCount,
+        staleTasks
+      });
+    }
+    return {
+      employees,
+      stuckAgents,
+      idleAgents,
+      crashedSessions,
+      totalOpenTasks: totalOpen,
+      totalInProgress
+    };
+  }
+  /**
+   * Process completed reviews. Auto-approve P2 tasks with passing results.
+   */
+  async processReviews() {
+    const { getClient } = await import("./lib/database.js");
+    const client = getClient();
+    const autoApproved = [];
+    const needsReview = [];
+    const coordinatorName = getCoordinatorName();
+    const rScope = sessionScopeFilter();
+    const reviews = await client.execute({
+      sql: `SELECT id, title, assigned_to, priority, result, task_file FROM tasks
+            WHERE (assigned_to = ? OR assigned_to = ?)
+              AND status IN ('open', 'in_progress')
+              AND task_file LIKE '%review-%'${rScope.sql}
+            ORDER BY priority ASC
+            LIMIT 20`,
+      args: [coordinatorName, DEFAULT_COORDINATOR_TEMPLATE_NAME, ...rScope.args]
+    });
+    for (const row of reviews.rows) {
+      const item = {
+        taskId: String(row.id),
+        title: String(row.title),
+        assignedTo: String(row.assigned_to),
+        priority: String(row.priority),
+        result: String(row.result ?? ""),
+        taskFile: String(row.task_file)
+      };
+      if (this.config.autoApproveP2 && item.priority === "p2" && /tests?\s+pass/i.test(item.result)) {
+        try {
+          await updateTaskStatus({
+            taskId: item.taskId,
+            status: "done",
+            result: `[auto-approved] ${item.result}`,
+            skipReviewCreation: true
+          });
+        } catch {
+          await client.execute({
+            sql: `UPDATE tasks SET status = 'done', result = ? WHERE id = ?`,
+            args: [`[auto-approved] ${item.result}`, item.taskId]
+          });
+        }
+        autoApproved.push(item);
+      } else {
+        needsReview.push(item);
+      }
+    }
+    return {
+      autoApproved,
+      needsReview,
+      processed: autoApproved.length + needsReview.length
+    };
+  }
+  /**
+   * Run one full orchestration cycle: health check + process reviews.
+   * Does NOT dispatch tasks — call dispatchTask() explicitly.
+   */
+  async tick() {
+    const health = await this.healthCheck();
+    const reviews = await this.processReviews();
+    for (const stuck of health.stuckAgents) {
+      const sessionName = employeeSessionName(stuck, this.config.exeSession);
+      if (isEmployeeAlive(sessionName)) {
+        const { sendIntercom } = await import("./lib/tmux-routing.js");
+        sendIntercom(sessionName);
+      }
+    }
+    for (const crashed of health.crashedSessions) {
+      this.recoverSession(crashed);
+    }
+    return {
+      dispatched: [],
+      health,
+      reviews,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Recover a crashed session by spawning a fresh CC session.
+   * The new session boots with identity via --system-prompt, finds existing in_progress tasks, and resumes.
+   */
+  recoverSession(employeeName) {
+    const sessionName = employeeSessionName(employeeName, this.config.exeSession);
+    const result = ensureEmployee(
+      employeeName,
+      this.config.exeSession,
+      this.config.projectDir
+    );
+    if (result.status === "failed") {
+      return { status: "failed", sessionName, error: result.error };
+    }
+    return { status: "recovered", sessionName: result.sessionName };
+  }
+  /**
+   * Dispatch a batch of tasks, auto-routing each to the best employee.
+   */
+  async dispatchBatch(tasks) {
+    const results = [];
+    for (const task of tasks) {
+      const result = await this.dispatchTask(task);
+      results.push(result);
+    }
+    return results;
+  }
+  /**
+   * Get a formatted status summary (matches exe boot brief style).
+   */
+  async getStatusSummary() {
+    const health = await this.healthCheck();
+    const lines = [];
+    lines.push("\u25B8 ORCHESTRATOR STATUS");
+    lines.push(`  Tasks:   ${health.totalOpenTasks} open, ${health.totalInProgress} in progress`);
+    lines.push(`  Crashed: ${health.crashedSessions.length > 0 ? health.crashedSessions.join(", ") : "none"}`);
+    lines.push(`  Stuck:   ${health.stuckAgents.length > 0 ? health.stuckAgents.join(", ") : "none"}`);
+    lines.push(`  Idle:    ${health.idleAgents.length > 0 ? health.idleAgents.join(", ") : "none"}`);
+    lines.push("");
+    for (const emp of health.employees) {
+      const stateIcon = emp.alive ? emp.state === "idle" ? "\u{1F7E2}" : emp.state === "thinking" ? "\u{1F7E1}" : emp.state === "tool" ? "\u{1F535}" : "\u26AA" : "\u{1F534}";
+      const taskInfo = emp.taskCount > 0 ? `${emp.taskCount} task${emp.taskCount > 1 ? "s" : ""} (${emp.inProgressCount} active)` : "idle";
+      const staleWarning = emp.staleTasks.length > 0 ? ` \u26A0 stale: ${emp.staleTasks[0]}` : "";
+      lines.push(`  ${stateIcon} ${emp.name} (${emp.role}): ${taskInfo}${staleWarning}`);
+    }
+    return lines.join("\n");
+  }
+};
+
+export {
+  MultiAgentOrchestrator
+};