@askexenow/exe-os 0.8.80 → 0.8.82

package/dist/mcp/tools/update-task.js

@@ -26,23 +26,6 @@ var init_db_retry = __esm({
   }
 });
 
-// src/lib/database.ts
-import { createClient } from "@libsql/client";
-function getClient() {
-  if (!_resilientClient) {
-    throw new Error("Database client not initialized. Call initDatabase() first.");
-  }
-  return _resilientClient;
-}
-var _resilientClient;
-var init_database = __esm({
-  "src/lib/database.ts"() {
-    "use strict";
-    init_db_retry();
-    _resilientClient = null;
-  }
-});
-
 // src/lib/config.ts
 import { readFile, writeFile, mkdir, chmod } from "fs/promises";
 import { readFileSync, existsSync, renameSync } from "fs";
@@ -189,13 +172,7 @@ var init_config = __esm({
       wikiUrl: "",
       wikiApiKey: "",
       wikiSyncIntervalMs: 30 * 60 * 1e3,
-      wikiWorkspaceMapping: {
-        exe: "Executive",
-        yoshi: "Engineering",
-        mari: "Marketing",
-        tom: "Engineering",
-        sasha: "Production"
-      },
+      wikiWorkspaceMapping: {},
       wikiAutoUpdate: true,
       wikiAutoUpdateThreshold: 0.5,
       wikiAutoUpdateCreateNew: true,
@@ -232,15 +209,80 @@ var init_config = __esm({
   }
 });
 
-// src/lib/notifications.ts
-import crypto from "crypto";
+// src/lib/employees.ts
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { existsSync as existsSync2, symlinkSync, readlinkSync, readFileSync as readFileSync2, renameSync as renameSync2, unlinkSync, writeFileSync } from "fs";
+import { execSync } from "child_process";
 import path2 from "path";
 import os2 from "os";
+function normalizeRole(role) {
+  return (role ?? "").trim().toLowerCase();
+}
+function isCoordinatorRole(role) {
+  return normalizeRole(role) === normalizeRole(COORDINATOR_ROLE);
+}
+function getCoordinatorEmployee(employees) {
+  return employees.find((e) => isCoordinatorRole(e.role));
+}
+function getCoordinatorName(employees = loadEmployeesSync()) {
+  return getCoordinatorEmployee(employees)?.name ?? DEFAULT_COORDINATOR_TEMPLATE_NAME;
+}
+function isCoordinatorName(agentName, employees = loadEmployeesSync()) {
+  if (!agentName) return false;
+  return agentName.toLowerCase() === getCoordinatorName(employees).toLowerCase();
+}
+function canCoordinate(agentName, agentRole, employees = loadEmployeesSync()) {
+  return agentName === "default" || isCoordinatorRole(agentRole) || isCoordinatorName(agentName, employees);
+}
+function loadEmployeesSync(employeesPath = EMPLOYEES_PATH) {
+  if (!existsSync2(employeesPath)) return [];
+  try {
+    return JSON.parse(readFileSync2(employeesPath, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function getEmployee(employees, name) {
+  return employees.find((e) => e.name.toLowerCase() === name.toLowerCase());
+}
+var EMPLOYEES_PATH, DEFAULT_COORDINATOR_TEMPLATE_NAME, COORDINATOR_ROLE;
+var init_employees = __esm({
+  "src/lib/employees.ts"() {
+    "use strict";
+    init_config();
+    EMPLOYEES_PATH = path2.join(EXE_AI_DIR, "exe-employees.json");
+    DEFAULT_COORDINATOR_TEMPLATE_NAME = "exe";
+    COORDINATOR_ROLE = "COO";
+  }
+});
+
+// src/lib/database.ts
+import { createClient } from "@libsql/client";
+function getClient() {
+  if (!_resilientClient) {
+    throw new Error("Database client not initialized. Call initDatabase() first.");
+  }
+  return _resilientClient;
+}
+var _resilientClient;
+var init_database = __esm({
+  "src/lib/database.ts"() {
+    "use strict";
+    init_db_retry();
+    init_employees();
+    _resilientClient = null;
+  }
+});
+
+// src/lib/notifications.ts
+import crypto from "crypto";
+import path3 from "path";
+import os3 from "os";
 import {
-  readFileSync as readFileSync2,
+  readFileSync as readFileSync3,
   readdirSync,
-  unlinkSync,
-  existsSync as existsSync2,
+  unlinkSync as unlinkSync2,
+  existsSync as existsSync3,
   rmdirSync
 } from "fs";
 async function writeNotification(notification) {
@@ -340,24 +382,24 @@ var init_state_bus = __esm({
 });
 
 // src/lib/session-registry.ts
-import path3 from "path";
-import os3 from "os";
+import path4 from "path";
+import os4 from "os";
 var REGISTRY_PATH;
 var init_session_registry = __esm({
   "src/lib/session-registry.ts"() {
     "use strict";
-    REGISTRY_PATH = path3.join(os3.homedir(), ".exe-os", "session-registry.json");
+    REGISTRY_PATH = path4.join(os4.homedir(), ".exe-os", "session-registry.json");
   }
 });
 
 // src/lib/session-key.ts
-import { execSync } from "child_process";
+import { execSync as execSync2 } from "child_process";
 function getSessionKey() {
   if (_cached) return _cached;
   let pid = process.ppid;
   for (let i = 0; i < 10; i++) {
     try {
-      const info = execSync(`ps -p ${pid} -o ppid=,comm=`, {
+      const info = execSync2(`ps -p ${pid} -o ppid=,comm=`, {
         encoding: "utf8",
         timeout: 2e3
       }).trim();
@@ -493,7 +535,7 @@ var init_transport = __esm({
 });
 
 // src/lib/cc-agent-support.ts
-import { execSync as execSync2 } from "child_process";
+import { execSync as execSync3 } from "child_process";
 var init_cc_agent_support = __esm({
   "src/lib/cc-agent-support.ts"() {
     "use strict";
@@ -522,17 +564,17 @@ var init_provider_table = __esm({
 });
 
 // src/lib/intercom-queue.ts
-import { readFileSync as readFileSync3, writeFileSync, renameSync as renameSync2, existsSync as existsSync3, mkdirSync } from "fs";
-import path4 from "path";
-import os4 from "os";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, renameSync as renameSync3, existsSync as existsSync4, mkdirSync } from "fs";
+import path5 from "path";
+import os5 from "os";
 function ensureDir() {
-  const dir = path4.dirname(QUEUE_PATH);
-  if (!existsSync3(dir)) mkdirSync(dir, { recursive: true });
+  const dir = path5.dirname(QUEUE_PATH);
+  if (!existsSync4(dir)) mkdirSync(dir, { recursive: true });
 }
 function readQueue() {
   try {
-    if (!existsSync3(QUEUE_PATH)) return [];
-    return JSON.parse(readFileSync3(QUEUE_PATH, "utf8"));
+    if (!existsSync4(QUEUE_PATH)) return [];
+    return JSON.parse(readFileSync4(QUEUE_PATH, "utf8"));
   } catch {
     return [];
   }
@@ -540,8 +582,8 @@ function readQueue() {
 function writeQueue(queue) {
   ensureDir();
   const tmp = `${QUEUE_PATH}.tmp`;
-  writeFileSync(tmp, JSON.stringify(queue, null, 2));
-  renameSync2(tmp, QUEUE_PATH);
+  writeFileSync2(tmp, JSON.stringify(queue, null, 2));
+  renameSync3(tmp, QUEUE_PATH);
 }
 function queueIntercom(targetSession, reason) {
   const queue = readQueue();
@@ -564,24 +606,9 @@ var QUEUE_PATH, TTL_MS, INTERCOM_LOG;
 var init_intercom_queue = __esm({
   "src/lib/intercom-queue.ts"() {
     "use strict";
-    QUEUE_PATH = path4.join(os4.homedir(), ".exe-os", "intercom-queue.json");
+    QUEUE_PATH = path5.join(os5.homedir(), ".exe-os", "intercom-queue.json");
     TTL_MS = 60 * 60 * 1e3;
-    INTERCOM_LOG = path4.join(os4.homedir(), ".exe-os", "intercom.log");
-  }
-});
-
-// src/lib/employees.ts
-import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { existsSync as existsSync4, symlinkSync, readlinkSync, readFileSync as readFileSync4, renameSync as renameSync3, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
-import { execSync as execSync3 } from "child_process";
-import path5 from "path";
-import os5 from "os";
-var EMPLOYEES_PATH;
-var init_employees = __esm({
-  "src/lib/employees.ts"() {
-    "use strict";
-    init_config();
-    EMPLOYEES_PATH = path5.join(EXE_AI_DIR, "exe-employees.json");
+    INTERCOM_LOG = path5.join(os5.homedir(), ".exe-os", "intercom.log");
   }
 });
 
@@ -625,8 +652,10 @@ function getMySession() {
   return getTransport().getMySession();
 }
 function extractRootExe(name) {
-  const match = name.match(/(exe\d+)$/);
-  return match?.[1] ?? null;
+  if (!name) return null;
+  if (!name.includes("-")) return name;
+  const parts = name.split("-").filter(Boolean);
+  return parts.length > 0 ? parts[parts.length - 1] : null;
 }
 function getParentExe(sessionKey) {
   try {
@@ -717,12 +746,14 @@ function getSessionState(sessionName) {
   }
 }
 function isExeSession(sessionName) {
-  return /^exe\d*$/.test(sessionName);
+  const matchesBaseWithInstance = (baseName) => sessionName === baseName || sessionName.startsWith(baseName) && /^\d+$/.test(sessionName.slice(baseName.length));
+  const coordinatorName = getCoordinatorName();
+  return matchesBaseWithInstance(coordinatorName) || matchesBaseWithInstance("exe");
 }
 function sendIntercom(targetSession) {
   const transport = getTransport();
   if (isExeSession(targetSession)) {
-    logIntercom(`SKIP_EXE \u2192 ${targetSession} (exe sessions use prompt-submit hook)`);
+    logIntercom(`SKIP_COORDINATOR \u2192 ${targetSession} (coordinator sessions use prompt-submit hook)`);
     return "skipped_exe";
   }
   if (isDebounced(targetSession)) {
@@ -774,7 +805,7 @@ function notifyParentExe(sessionKey) {
   if (result === "failed") {
     const rootExe = resolveExeSession();
     if (rootExe && rootExe !== target) {
-      process.stderr.write(`[intercom] notifyParentExe: dispatcher ${target} dead, falling back to root exe ${rootExe}
+      process.stderr.write(`[intercom] notifyParentExe: dispatcher ${target} dead, falling back to root coordinator session ${rootExe}
 `);
       const fallback = sendIntercom(rootExe);
       return fallback !== "failed";
@@ -795,6 +826,7 @@ var init_tmux_routing = __esm({
     init_provider_table();
     init_intercom_queue();
     init_plan_limits();
+    init_employees();
     SPAWN_LOCK_DIR = path8.join(os6.homedir(), ".exe-os", "spawn-locks");
     SESSION_CACHE = path8.join(os6.homedir(), ".exe-os", "session-cache");
     INTERCOM_DEBOUNCE_MS = 3e4;
@@ -909,6 +941,36 @@ async function resolveTask(client, identifier, scopeSession) {
   }
   throw new Error(`Task not found: ${identifier}`);
 }
+function isTmuxSessionAlive(identifier) {
+  if (!identifier || identifier === "unknown") return true;
+  try {
+    if (identifier.startsWith("%")) {
+      const output = execSync4("tmux list-panes -a -F '#{pane_id}'", {
+        timeout: 2e3,
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return output.split("\n").some((l) => l.trim() === identifier);
+    } else {
+      execSync4(`tmux has-session -t ${JSON.stringify(identifier)}`, {
+        timeout: 2e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return true;
+    }
+  } catch {
+    if (identifier.startsWith("%")) return true;
+    try {
+      execSync4("tmux list-sessions", {
+        timeout: 2e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return false;
+    } catch {
+      return true;
+    }
+  }
+}
 function checkStaleCompletion(taskContext, taskCreatedAt) {
   if (!taskContext) return null;
   if (!DELEGATION_KEYWORDS.test(taskContext)) return null;
@@ -971,13 +1033,59 @@ ${input.result}` : `\u26A0\uFE0F ${warning}`;
     });
     if (claim.rowsAffected === 0) {
       const current = await client.execute({
-        sql: "SELECT status, assigned_tmux FROM tasks WHERE id = ?",
+        sql: "SELECT status, assigned_tmux, assigned_by FROM tasks WHERE id = ?",
         args: [taskId]
       });
       const cur = current.rows[0];
-      const status = cur?.status ?? "unknown";
-      const claimedBy = cur?.assigned_tmux ? ` (claimed by ${cur.assigned_tmux})` : "";
-      throw new Error(`${TASK_ALREADY_CLAIMED_PREFIX}: task ${taskId} is ${status}${claimedBy}`);
+      const curStatus = cur?.status ?? "unknown";
+      const claimedBySession = cur?.assigned_tmux ?? "";
+      const assignedBy = cur?.assigned_by ?? "";
+      if (curStatus === "in_progress" && claimedBySession && !isTmuxSessionAlive(claimedBySession)) {
+        process.stderr.write(
+          `[tasks] Auto-releasing dead claim on ${taskId} (was ${claimedBySession})
+`
+        );
+        await client.execute({
+          sql: "UPDATE tasks SET status = 'open', assigned_tmux = NULL, updated_at = ? WHERE id = ?",
+          args: [now, taskId]
+        });
+        const retried = await client.execute({
+          sql: `UPDATE tasks SET status = 'in_progress', assigned_tmux = ?, updated_at = ? WHERE id = ? AND status = 'open'`,
+          args: [tmuxSession, now, taskId]
+        });
+        if (retried.rowsAffected > 0) {
+          try {
+            await writeCheckpoint({
+              taskId,
+              step: "reclaimed_dead_session",
+              contextSummary: `Task reclaimed after dead session ${claimedBySession} released.`
+            });
+          } catch {
+          }
+          return { row, taskFile, now, taskId };
+        }
+      }
+      if (curStatus === "in_progress" && input.callerAgentId && (input.callerAgentId === assignedBy || input.callerAgentId === "exe")) {
+        process.stderr.write(
+          `[tasks] Assigner override: ${input.callerAgentId} reclaiming ${taskId}
+`
+        );
+        await client.execute({
+          sql: `UPDATE tasks SET status = 'in_progress', assigned_tmux = ?, updated_at = ? WHERE id = ?`,
+          args: [tmuxSession, now, taskId]
+        });
+        try {
+          await writeCheckpoint({
+            taskId,
+            step: "assigner_override",
+            contextSummary: `Task force-reclaimed by assigner ${input.callerAgentId}.`
+          });
+        } catch {
+        }
+        return { row, taskFile, now, taskId };
+      }
+      const claimedBy = claimedBySession ? ` (claimed by ${claimedBySession})` : "";
+      throw new Error(`${TASK_ALREADY_CLAIMED_PREFIX}: task ${taskId} is ${curStatus}${claimedBy}`);
     }
     try {
       await writeCheckpoint({
@@ -1016,7 +1124,7 @@ var init_tasks_crud = __esm({
     "use strict";
     init_database();
     init_task_scope();
-    DELEGATION_KEYWORDS = /parallel|delegate|wave|tom\d*-exe/i;
+    DELEGATION_KEYWORDS = /parallel|delegate|wave|worktree|multi-instance/i;
     TASK_ALREADY_CLAIMED_PREFIX = "TASK_ALREADY_CLAIMED";
   }
 });
@@ -1547,6 +1655,24 @@ async function updateTask(input) {
       });
     } catch {
     }
+    const assignedAgent = String(row.assigned_to);
+    if (!isCoordinatorName(assignedAgent)) {
+      try {
+        const draftClient = getClient();
+        if (input.status === "done") {
+          await draftClient.execute({
+            sql: `UPDATE memories SET draft = 0 WHERE agent_id = ? AND draft = 1`,
+            args: [assignedAgent]
+          });
+        } else if (input.status === "cancelled") {
+          await draftClient.execute({
+            sql: `DELETE FROM memories WHERE agent_id = ? AND draft = 1`,
+            args: [assignedAgent]
+          });
+        }
+      } catch {
+      }
+    }
     try {
       const client = getClient();
       const cascaded = await client.execute({
@@ -1565,8 +1691,8 @@ async function updateTask(input) {
   }
   const isTerminal = input.status === "done" || input.status === "needs_review";
   if (isTerminal) {
-    const isExe = String(row.assigned_to) === "exe";
-    if (!isExe) {
+    const isCoordinator = String(row.assigned_to) === "exe" || isCoordinatorName(String(row.assigned_to));
+    if (!isCoordinator) {
       notifyTaskDone();
     }
     await markTaskNotificationsRead(taskFile);
@@ -1590,7 +1716,7 @@ async function updateTask(input) {
       }
     }
   }
-  if (input.status === "done" && String(row.assigned_to) !== "exe" && !process.env.VITEST) {
+  if (input.status === "done" && String(row.assigned_to) !== "exe" && !isCoordinatorName(String(row.assigned_to)) && !process.env.VITEST) {
     Promise.resolve().then(() => (init_skill_learning(), skill_learning_exports)).then(
       ({ captureAndLearn: captureAndLearn2 }) => captureAndLearn2({
         taskId,
@@ -1606,7 +1732,7 @@ async function updateTask(input) {
     });
   }
   let nextTask;
-  if (isTerminal && String(row.assigned_to) !== "exe") {
+  if (isTerminal && String(row.assigned_to) !== "exe" && !isCoordinatorName(String(row.assigned_to))) {
     try {
       nextTask = await findNextTask(String(row.assigned_to));
     } catch {
@@ -1637,6 +1763,7 @@ var init_tasks = __esm({
     init_config();
     init_notifications();
     init_state_bus();
+    init_employees();
     init_tasks_crud();
     init_tasks_review();
     init_tasks_crud();
@@ -1661,11 +1788,54 @@ __export(active_agent_exports, {
   clearActiveAgent: () => clearActiveAgent,
   getActiveAgent: () => getActiveAgent,
   getAllActiveAgents: () => getAllActiveAgents,
+  resolveActiveAgentFromTmuxSession: () => resolveActiveAgentFromTmuxSession,
   writeActiveAgent: () => writeActiveAgent
 });
 import { readFileSync as readFileSync9, writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, unlinkSync as unlinkSync5, readdirSync as readdirSync3 } from "fs";
 import { execSync as execSync5 } from "child_process";
 import path13 from "path";
+function isNameWithOptionalInstance(candidate, baseName) {
+  if (candidate === baseName) return true;
+  if (!candidate.startsWith(baseName)) return false;
+  return /^\d+$/.test(candidate.slice(baseName.length));
+}
+function resolveEmployeeFromSessionPrefix(prefix, employees) {
+  const sorted = [...employees].sort((a, b) => b.name.length - a.name.length);
+  for (const employee of sorted) {
+    if (isNameWithOptionalInstance(prefix, employee.name)) {
+      return { agentId: employee.name, agentRole: employee.role };
+    }
+  }
+  return null;
+}
+function resolveActiveAgentFromTmuxSession(sessionName) {
+  const employees = loadEmployeesSync();
+  const coordinator = getCoordinatorEmployee(employees);
+  const coordinatorName = coordinator?.name ?? DEFAULT_COORDINATOR_TEMPLATE_NAME;
+  if (isNameWithOptionalInstance(sessionName, coordinatorName)) {
+    return {
+      agentId: coordinatorName,
+      agentRole: coordinator?.role ?? "COO"
+    };
+  }
+  if (isNameWithOptionalInstance(sessionName, DEFAULT_COORDINATOR_TEMPLATE_NAME)) {
+    return {
+      agentId: coordinator?.name ?? DEFAULT_COORDINATOR_TEMPLATE_NAME,
+      agentRole: coordinator?.role ?? "COO"
+    };
+  }
+  if (sessionName.includes("-")) {
+    const prefix = sessionName.split("-")[0] ?? "";
+    const employee = resolveEmployeeFromSessionPrefix(prefix, employees);
+    if (employee) return employee;
+    const legacy = prefix.match(/^([a-zA-Z]+)\d*$/);
+    if (legacy?.[1] && legacy[1] !== DEFAULT_COORDINATOR_TEMPLATE_NAME) {
+      const emp = getEmployee(employees, legacy[1]);
+      return { agentId: emp?.name ?? legacy[1], agentRole: emp?.role ?? "employee" };
+    }
+  }
+  return null;
+}
 function getMarkerPath() {
   return path13.join(CACHE_DIR, `active-agent-${getSessionKey()}.json`);
 }
@@ -1718,13 +1888,8 @@ function getActiveAgent() {
       "tmux display-message -p '#{session_name}' 2>/dev/null",
       { encoding: "utf8", timeout: 2e3 }
     ).trim();
-    const empMatch = sessionName.match(/^([a-zA-Z]+)\d*-exe\d+$/);
-    if (empMatch && empMatch[1] !== "exe") {
-      return { agentId: empMatch[1], agentRole: "employee" };
-    }
-    if (/^exe\d+$/.test(sessionName)) {
-      return { agentId: "exe", agentRole: "COO" };
-    }
+    const resolved = resolveActiveAgentFromTmuxSession(sessionName);
+    if (resolved) return resolved;
   } catch {
   }
   return {
@@ -1785,6 +1950,7 @@ var init_active_agent = __esm({
     "use strict";
     init_config();
     init_session_key2();
+    init_employees();
     CACHE_DIR = path13.join(EXE_AI_DIR, "session-cache");
     STALE_MS = 24 * 60 * 60 * 1e3;
   }
@@ -1794,6 +1960,7 @@ var init_active_agent = __esm({
 init_tasks();
 init_database();
 init_tasks_crud();
+init_employees();
 import { z } from "zod";
 function registerUpdateTask(server) {
   server.registerTool(
@@ -1813,7 +1980,7 @@ function registerUpdateTask(server) {
         try {
           const { getActiveAgent: getActiveAgent2 } = await Promise.resolve().then(() => (init_active_agent(), active_agent_exports));
           const agent = getActiveAgent2();
-          if (agent.agentId !== "exe" && agent.agentId !== "default") {
+          if (!canCoordinate(agent.agentId, agent.agentRole)) {
             let isOwnReview = false;
             try {
               const client = getClient();
@@ -1840,7 +2007,7 @@ function registerUpdateTask(server) {
           if (assignedBy === "system" && taskFile.includes("review-")) {
             const { getActiveAgent: getActiveAgent2 } = await Promise.resolve().then(() => (init_active_agent(), active_agent_exports));
             const agent = getActiveAgent2();
-            if (agent.agentId !== assignedTo && agent.agentId !== "exe" && agent.agentId !== "default") {
+            if (agent.agentId !== assignedTo && !canCoordinate(agent.agentId, agent.agentRole)) {
               process.stderr.write(
                 `[update_task] BLOCKED: ${agent.agentId} tried to close review "${String(row.title)}" assigned to ${assignedTo}
 `
@@ -1863,13 +2030,20 @@ function registerUpdateTask(server) {
           };
         }
       }
+      let callerAgentId;
+      try {
+        const { getActiveAgent: getAgent } = await Promise.resolve().then(() => (init_active_agent(), active_agent_exports));
+        callerAgentId = getAgent().agentId;
+      } catch {
+      }
       let task;
       try {
         task = await updateTask({
           taskId: task_id,
           status,
           result,
-          baseDir: process.cwd()
+          baseDir: process.cwd(),
+          callerAgentId
         });
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);