@askexenow/exe-os 0.9.263 → 0.9.265

package/dist/chunk-A4UY44T7.js

@@ -0,0 +1,486 @@
+import {
+  writeDispatchPending
+} from "./chunk-MLXJ5EZG.js";
+import {
+  createTask
+} from "./chunk-3T4PNG5O.js";
+import {
+  getActiveAgent
+} from "./chunk-YG7PIB2R.js";
+import {
+  ensureEmployee,
+  logTaskDispatch,
+  resolveExeSession
+} from "./chunk-D55SXO3N.js";
+import {
+  recordOrchestrationEventBestEffort
+} from "./chunk-JTADPL6X.js";
+import {
+  getAgentRuntime
+} from "./chunk-XJUUWHVN.js";
+import {
+  getLicenseSync
+} from "./chunk-A3T5KDD3.js";
+import {
+  getAgentContext
+} from "./chunk-GJV3WDWM.js";
+import {
+  isCoordinatorName
+} from "./chunk-QQZMP6QL.js";
+
+// src/mcp/tools/create-task.ts
+import { z } from "zod";
+import { existsSync, writeFileSync, mkdirSync } from "fs";
+import { basename, join } from "path";
+import { homedir } from "os";
+function rootFromSessionName(sessionName) {
+  const raw = (sessionName ?? "").trim();
+  if (!raw) return "";
+  const lastDash = raw.lastIndexOf("-");
+  return lastDash >= 0 ? raw.slice(lastDash + 1) : raw;
+}
+function isRootSessionName(sessionName) {
+  return sessionName.length > 0 && !sessionName.includes("-");
+}
+function projectDirMatches(projectDir, projectName) {
+  const dirBasename = basename(projectDir).toLowerCase();
+  const normalizedProject = projectName.toLowerCase();
+  return dirBasename === normalizedProject || dirBasename === normalizedProject.replace(/^exe-/, "") || `exe-${dirBasename}` === normalizedProject || projectDir.toLowerCase().includes(normalizedProject);
+}
+async function listCoordinatorRoots() {
+  const roots = /* @__PURE__ */ new Set();
+  try {
+    const { listSessions } = await import("./lib/session-registry.js");
+    for (const session of listSessions()) {
+      if (isRootSessionName(session.windowName)) roots.add(session.windowName);
+    }
+  } catch {
+  }
+  try {
+    const { listTmuxSessions } = await import("./lib/tmux-status.js");
+    for (const sessionName of listTmuxSessions()) {
+      if (isRootSessionName(sessionName) && /^exe\d*$/i.test(sessionName)) roots.add(sessionName);
+    }
+  } catch {
+  }
+  return [...roots].sort();
+}
+async function inferCoordinatorRootForProject(projectName) {
+  try {
+    const liveRoots = new Set(await listCoordinatorRoots());
+    const { listSessions } = await import("./lib/session-registry.js");
+    const matches = listSessions().filter((session) => isRootSessionName(session.windowName)).filter((session) => !liveRoots.size || liveRoots.has(session.windowName)).filter((session) => session.projectDir && existsSync(session.projectDir)).filter((session) => projectDirMatches(session.projectDir, projectName)).map((session) => session.windowName);
+    return [...new Set(matches)].length === 1 ? matches[0] : "";
+  } catch {
+    return "";
+  }
+}
+function resolveDispatchRuntime(agentId, override) {
+  if (override) return override;
+  try {
+    return getAgentRuntime(agentId).runtime ?? null;
+  } catch {
+    return null;
+  }
+}
+async function resolveProjectDir(projectName, callerSession) {
+  const home = homedir();
+  if (callerSession) {
+    try {
+      const { listSessions } = await import("./lib/session-registry.js");
+      const sessions = listSessions();
+      const coordName = callerSession.includes("-") ? callerSession.slice(callerSession.indexOf("-") + 1) : callerSession;
+      const coordSession = sessions.find((s) => s.windowName === coordName) ?? sessions.find((s) => s.windowName === callerSession);
+      if (coordSession?.projectDir && existsSync(coordSession.projectDir)) {
+        if (projectDirMatches(coordSession.projectDir, projectName)) {
+          return coordSession.projectDir;
+        }
+        process.stderr.write(
+          `[create-task] project mismatch: coordinator dir="${coordSession.projectDir}" (${basename(coordSession.projectDir).toLowerCase()}) vs task project="${projectName}". Falling through.
+`
+        );
+      }
+    } catch {
+    }
+  }
+  try {
+    const ctx = getAgentContext();
+    if (ctx?.projectName) {
+      const alsCandidate = join(home, ctx.projectName);
+      if (existsSync(alsCandidate)) return alsCandidate;
+    }
+  } catch {
+  }
+  const candidates = [
+    join(home, projectName),
+    join(home, projectName.replace(/^exe-/, ""))
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+  process.stderr.write(
+    `[create-task] WARN: could not resolve project dir for "${projectName}" \u2014 falling back to cwd (${process.cwd()}). This may cause agents to spawn in the wrong repo.
+`
+  );
+  return process.cwd();
+}
+function registerCreateTask(server) {
+  server.registerTool(
+    "create_task",
+    {
+      title: "Create Task",
+      description: "Create and assign a task to an employee. Writes a .md task file and DB row.",
+      inputSchema: {
+        title: z.string().describe("Task title"),
+        assigned_to: z.string().describe("Employee name to assign to"),
+        project_name: z.string().describe("Project name"),
+        priority: z.enum(["p0", "p1", "p2"]).default("p1").describe("Priority level"),
+        complexity: z.enum(["routine", "standard", "complex", "critical"]).default("standard").describe("Bloom taxonomy complexity level. Affects routing tier and review requirements."),
+        context: z.string().describe("Full task description and context"),
+        blocked_by: z.string().optional().describe("Task ID or slug of the blocking task. If set, task starts as 'blocked'."),
+        parent_task_id: z.string().optional().describe("Parent task ID or slug. Links this task as a subtask."),
+        reviewer: z.string().optional().describe("Who should review this task when done. Defaults to assigner."),
+        budget_tokens: z.number().optional().describe("Max tokens allowed for this task (null = unlimited)"),
+        budget_fallback_model: z.string().optional().describe("Model to route to when budget is exhausted"),
+        spawn_runtime: z.string().optional().describe("Override runtime for spawned session (e.g., 'claude', 'codex', 'opencode')"),
+        spawn_model: z.string().optional().describe("Override model for spawned session (e.g., 'claude-sonnet-4.6', 'claude-haiku-4.5')")
+      }
+    },
+    async ({ title, assigned_to, project_name, priority, complexity, context, blocked_by, parent_task_id, reviewer, budget_tokens, budget_fallback_model, spawn_runtime, spawn_model }) => {
+      if (!isCoordinatorName(assigned_to)) {
+        const license = getLicenseSync();
+        if (license.plan === "free") {
+          return {
+            content: [{
+              type: "text",
+              text: "Upgrade to hire specialists. Free plan includes your coordinator only. Get a license at https://askexe.com"
+            }],
+            isError: true
+          };
+        }
+      }
+      const { agentId: assignedBy } = getActiveAgent();
+      let callerTmux = "";
+      let callerSource = "";
+      try {
+        callerTmux = getAgentContext()?.sessionHint ?? "";
+        if (callerTmux) callerSource = "als";
+      } catch {
+      }
+      if (!callerTmux) {
+        callerTmux = process.env.EXE_SESSION_NAME || process.env.EXE_SESSION || "";
+        if (callerTmux) callerSource = "env";
+      }
+      let callerRoot = rootFromSessionName(callerTmux);
+      if (!callerRoot) {
+        const projectRoot = await inferCoordinatorRootForProject(project_name);
+        if (projectRoot) {
+          callerRoot = projectRoot;
+          callerTmux = projectRoot;
+          callerSource = "project_registry";
+          process.stderr.write(
+            `[create_task] INFO: inferred session "${projectRoot}" from project "${project_name}" because X-Exe-Session was missing.
+`
+          );
+        }
+      }
+      if (!callerRoot) {
+        const coordinatorSessions = await listCoordinatorRoots();
+        if (coordinatorSessions.length > 1 && process.env.VITEST !== "true" && process.env.NODE_ENV !== "test") {
+          const message = `BLOCKED: create_task cannot determine the caller session. ${coordinatorSessions.length} coordinator sessions are active (${coordinatorSessions.join(", ")}), X-Exe-Session is missing, and project "${project_name}" did not map to exactly one registered coordinator. Refusing to guess because guessing causes cross-session dispatch (for example exe2 tasks spawning yoshi2-exe1). Restart this coordinator or ensure the MCP client sends X-Exe-Session.`;
+          process.stderr.write(`[create_task] ${message}
+`);
+          recordOrchestrationEventBestEffort({
+            eventType: "dispatch.failed",
+            source: "create-task.mcp",
+            severity: "error",
+            agentId: assigned_to,
+            projectName: project_name,
+            errorCode: "missing_session_hint_ambiguous",
+            payload: { coordinatorSessions, priority }
+          });
+          return {
+            content: [{ type: "text", text: message }],
+            isError: true
+          };
+        }
+        try {
+          const resolved = resolveExeSession();
+          if (resolved) {
+            callerRoot = resolved;
+            callerTmux = resolved;
+            callerSource = "resolve_fallback";
+          }
+        } catch {
+        }
+      }
+      const projectDir = await resolveProjectDir(project_name, callerRoot);
+      const task = await createTask({
+        title,
+        assignedTo: assigned_to,
+        assignedBy,
+        projectName: project_name,
+        priority,
+        complexity,
+        context,
+        baseDir: projectDir,
+        blockedBy: blocked_by,
+        parentTaskId: parent_task_id,
+        reviewer: reviewer ?? assignedBy,
+        budgetTokens: budget_tokens,
+        budgetFallbackModel: budget_fallback_model,
+        spawnRuntime: spawn_runtime,
+        spawnModel: spawn_model,
+        // Pass the pre-resolved caller session to tasks-crud so it doesn't
+        // re-resolve independently (eliminates cross-session scope divergence).
+        callerSession: callerTmux || callerRoot || void 0,
+        // Skip internal dispatch — we handle it below with autoInstance
+        // support. Without this, createTask fires dispatchTaskToEmployee
+        // (no autoInstance) in parallel, racing with our ensureEmployee
+        // (autoInstance: true) and spawning duplicate sessions.
+        skipDispatch: true
+      });
+      try {
+        const { existsSync: existsSync2, mkdirSync: mkdirSync2, writeFileSync: writeFileSync2 } = await import("fs");
+        const { identityPath } = await import("./lib/identity.js");
+        const idPath = identityPath(assigned_to);
+        if (!existsSync2(idPath)) {
+          const { loadEmployees } = await import("./lib/employees.js");
+          const employees = await loadEmployees();
+          const emp = employees.find((e) => e.name === assigned_to);
+          if (emp) {
+            const { getTemplateForTitle } = await import("./lib/identity-templates.js");
+            const template = getTemplateForTitle(emp.role);
+            if (template) {
+              const dir = (await import("path")).dirname(idPath);
+              if (!existsSync2(dir)) mkdirSync2(dir, { recursive: true });
+              writeFileSync2(idPath, template.replace(/^agent_id: \w+/m, `agent_id: ${assigned_to}`), "utf-8");
+            }
+          }
+        }
+      } catch {
+      }
+      try {
+        const sessionScope = task.sessionScope || callerRoot || "default";
+        const { taskSignalPath: getSignalPath } = await import("./signal-paths-4GOIRLGH.js");
+        const { taskSignalDir } = await import("./signal-paths-4GOIRLGH.js");
+        const signalDir = taskSignalDir(sessionScope);
+        mkdirSync(signalDir, { recursive: true });
+        const signalPath = getSignalPath(sessionScope, assigned_to, task.id);
+        writeFileSync(signalPath, JSON.stringify({
+          task_id: task.id,
+          title,
+          priority,
+          assigned_by: assignedBy,
+          session_scope: sessionScope,
+          created_at: (/* @__PURE__ */ new Date()).toISOString()
+        }), "utf-8");
+        const { recordOrchestrationEventBestEffort: recordOE } = await import("./orchestration-events-UYG5H5H2.js");
+        recordOE({
+          eventType: "signal.created",
+          source: "create-task.mcp",
+          taskId: task.id,
+          agentId: assigned_to,
+          sessionScope,
+          payload: { priority }
+        });
+      } catch {
+      }
+      let dispatchStatus = "";
+      if (task.status !== "blocked" && !process.env.VITEST) {
+        try {
+          const exeSession = task.sessionScope || callerRoot;
+          const dispatchRuntime = resolveDispatchRuntime(assigned_to, spawn_runtime ?? null);
+          recordOrchestrationEventBestEffort({
+            eventType: "dispatch.attempted",
+            source: "create-task.mcp",
+            taskId: task.id,
+            agentId: assigned_to,
+            sessionScope: task.sessionScope || callerRoot || exeSession || null,
+            projectName: project_name,
+            runtime: dispatchRuntime,
+            payload: { priority }
+          });
+          if (exeSession) {
+            const { shouldAutoInstance } = await import("./lib/employees.js");
+            const autoOpts = shouldAutoInstance(assigned_to);
+            let projectConflictOpts = {};
+            try {
+              const { getClient } = await import("./lib/database.js");
+              const { sessionScopeFilter } = await import("./task-scope-GNCB2GAM.js");
+              const client = getClient();
+              const scope = sessionScopeFilter(task.sessionScope || callerRoot || exeSession || null);
+              const existing = await client.execute({
+                sql: `SELECT project_name FROM tasks WHERE assigned_to = ? AND status = 'in_progress'${scope.sql} LIMIT 1`,
+                args: [assigned_to, ...scope.args]
+              });
+              if (existing.rows.length > 0) {
+                const existingProject = String(existing.rows[0].project_name ?? "");
+                if (existingProject && existingProject !== project_name) {
+                  process.stderr.write(
+                    `[create-task] project conflict: ${assigned_to} has in_progress task for "${existingProject}", spawning new instance for "${project_name}"
+`
+                  );
+                  projectConflictOpts = { autoInstance: true, maxAutoInstances: 5 };
+                }
+              }
+            } catch {
+            }
+            try {
+              writeDispatchPending(task.id, assigned_to);
+            } catch {
+            }
+            const result = ensureEmployee(assigned_to, exeSession, projectDir, {
+              ...autoOpts,
+              ...projectConflictOpts,
+              runtimeOverride: spawn_runtime ?? void 0,
+              modelOverride: spawn_model ?? void 0
+            });
+            switch (result.status) {
+              case "intercom_sent":
+                dispatchStatus = `
+Dispatched: intercom sent to ${result.sessionName}`;
+                break;
+              case "intercom_unprocessed":
+                dispatchStatus = `
+Dispatched: intercom delivered to ${result.sessionName}`;
+                break;
+              case "spawned":
+                dispatchStatus = `
+Dispatched: spawned ${result.sessionName}`;
+                break;
+              case "failed":
+                dispatchStatus = `
+Dispatch failed: ${result.error ?? "unknown"}`;
+                break;
+            }
+            recordOrchestrationEventBestEffort({
+              eventType: result.status === "failed" ? "dispatch.failed" : "dispatch.completed",
+              source: "create-task.mcp",
+              severity: result.status === "failed" ? "warn" : "info",
+              taskId: task.id,
+              agentId: assigned_to,
+              sessionScope: task.sessionScope || callerRoot || exeSession,
+              projectName: project_name,
+              tmuxSession: result.sessionName || null,
+              runtime: dispatchRuntime,
+              result: result.status,
+              errorCode: result.status === "failed" ? "ensure_employee_failed" : null,
+              payload: { priority, error: result.error ?? null }
+            });
+            try {
+              const { sendIntercom: si } = await import("./lib/tmux-routing.js");
+              const { listTmuxSessions } = await import("./lib/tmux-status.js");
+              if (!autoOpts.autoInstance) {
+                const liveSessions = listTmuxSessions();
+                for (const s of liveSessions) {
+                  const agentPart = s.split("-")[0]?.replace(/\d+$/, "") ?? "";
+                  if (agentPart === assigned_to && s !== result.sessionName) {
+                    si(s, { force: true });
+                  }
+                }
+              }
+            } catch {
+            }
+            if (result.sessionName && result.status !== "failed") {
+              try {
+                const { getClient: gc } = await import("./lib/database.js");
+                await gc().execute({
+                  sql: `UPDATE tasks
+                        SET instance_id = ?,
+                            assigned_tmux = CASE
+                              WHEN assigned_tmux IS NULL OR assigned_tmux = 'unknown' THEN ?
+                              ELSE assigned_tmux
+                            END
+                        WHERE id = ?`,
+                  args: [result.sessionName, result.sessionName, task.id]
+                });
+              } catch {
+              }
+              try {
+                const sessionScope = task.sessionScope || callerRoot || "default";
+                const { taskSignalPath: getSignalPath } = await import("./signal-paths-4GOIRLGH.js");
+                const signalPath = getSignalPath(sessionScope, assigned_to, task.id);
+                writeFileSync(signalPath, JSON.stringify({
+                  task_id: task.id,
+                  title,
+                  priority,
+                  assigned_by: assignedBy,
+                  session_scope: sessionScope,
+                  instance_id: result.sessionName,
+                  created_at: (/* @__PURE__ */ new Date()).toISOString()
+                }), "utf-8");
+              } catch {
+              }
+            }
+            try {
+              writeDispatchPending(task.id, assigned_to, result.sessionName);
+            } catch {
+            }
+            logTaskDispatch({
+              taskId: task.id,
+              assignedTo: assigned_to,
+              callerRoot,
+              exeSession,
+              callerSource,
+              dispatchResult: result.status,
+              sessionName: result.sessionName,
+              error: result.error
+            });
+          } else {
+            recordOrchestrationEventBestEffort({
+              eventType: "dispatch.failed",
+              source: "create-task.mcp",
+              severity: "warn",
+              taskId: task.id,
+              agentId: assigned_to,
+              sessionScope: task.sessionScope || callerRoot || null,
+              projectName: project_name,
+              runtime: dispatchRuntime,
+              errorCode: "no_exe_session",
+              payload: { priority }
+            });
+          }
+        } catch (dispatchErr) {
+          recordOrchestrationEventBestEffort({
+            eventType: "dispatch.failed",
+            source: "create-task.mcp",
+            severity: "warn",
+            taskId: task.id,
+            agentId: assigned_to,
+            sessionScope: task.sessionScope || callerRoot || null,
+            projectName: project_name,
+            runtime: resolveDispatchRuntime(assigned_to, spawn_runtime ?? null),
+            errorCode: "exception"
+          });
+          process.stderr.write(`[create-task] dispatch error for ${assigned_to}: ${dispatchErr instanceof Error ? dispatchErr.message : String(dispatchErr)}
+${dispatchErr instanceof Error ? dispatchErr.stack : ""}
+`);
+        }
+      }
+      let text = `Task created: ${task.id}
+File: ${task.taskFile}
+Assigned to: ${task.assignedTo} [${task.priority.toUpperCase()}]${dispatchStatus}`;
+      if (task.status === "blocked") {
+        text += `
+Status: blocked (waiting on ${blocked_by})`;
+      }
+      if (task.warning) {
+        text += `
+Warning: ${task.warning}`;
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text
+          }
+        ]
+      };
+    }
+  );
+}
+
+export {
+  registerCreateTask
+};

package/dist/chunk-AZHPQGSI.js

@@ -0,0 +1,159 @@
+import {
+  EXE_AI_DIR
+} from "./chunk-VXIMSRTO.js";
+
+// src/lib/worker-gate.ts
+import { readdirSync, writeFileSync, unlinkSync, mkdirSync, existsSync, readFileSync } from "fs";
+import path from "path";
+var WORKER_PID_DIR = path.join(EXE_AI_DIR, "worker-pids");
+var MAX_CONCURRENT_WORKERS = 3;
+function tryAcquireWorkerSlot() {
+  try {
+    mkdirSync(WORKER_PID_DIR, { recursive: true });
+    const reservationId = `res-${process.pid}-${Date.now()}`;
+    const reservationPath = path.join(WORKER_PID_DIR, `${reservationId}.pid`);
+    writeFileSync(reservationPath, String(process.pid));
+    const files = readdirSync(WORKER_PID_DIR);
+    let alive = 0;
+    for (const f of files) {
+      if (!f.endsWith(".pid")) continue;
+      if (f.startsWith("res-")) {
+        const resParts = f.replace(".pid", "").split("-");
+        const resPid = parseInt(resParts[1] ?? "", 10);
+        if (!isNaN(resPid) && resPid > 0) {
+          try {
+            process.kill(resPid, 0);
+            alive++;
+          } catch {
+            try {
+              unlinkSync(path.join(WORKER_PID_DIR, f));
+            } catch {
+            }
+          }
+        } else {
+          alive++;
+        }
+        continue;
+      }
+      const dashIdx = f.lastIndexOf("-");
+      const pid = parseInt(f.slice(dashIdx + 1).replace(".pid", ""), 10);
+      if (isNaN(pid)) continue;
+      try {
+        process.kill(pid, 0);
+        alive++;
+      } catch {
+        try {
+          unlinkSync(path.join(WORKER_PID_DIR, f));
+        } catch {
+        }
+      }
+    }
+    if (alive >= MAX_CONCURRENT_WORKERS) {
+      try {
+        unlinkSync(reservationPath);
+      } catch {
+      }
+      return false;
+    }
+    try {
+      unlinkSync(reservationPath);
+    } catch {
+    }
+    return true;
+  } catch {
+    return true;
+  }
+}
+function registerWorkerPid(pid) {
+  try {
+    mkdirSync(WORKER_PID_DIR, { recursive: true });
+    writeFileSync(path.join(WORKER_PID_DIR, `worker-${pid}.pid`), String(pid));
+  } catch {
+  }
+}
+function cleanupWorkerPid() {
+  try {
+    unlinkSync(path.join(WORKER_PID_DIR, `worker-${process.pid}.pid`));
+  } catch {
+  }
+}
+var BACKFILL_LOCK = path.join(WORKER_PID_DIR, "backfill.lock");
+function tryAcquireBackfillLock() {
+  try {
+    mkdirSync(WORKER_PID_DIR, { recursive: true });
+    if (existsSync(BACKFILL_LOCK)) {
+      try {
+        const pid = parseInt(
+          readFileSync(BACKFILL_LOCK, "utf8").trim(),
+          10
+        );
+        if (!isNaN(pid) && pid > 0) {
+          try {
+            process.kill(pid, 0);
+            return false;
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+    writeFileSync(BACKFILL_LOCK, String(process.pid));
+    return true;
+  } catch {
+    return true;
+  }
+}
+function releaseBackfillLock() {
+  try {
+    unlinkSync(BACKFILL_LOCK);
+  } catch {
+  }
+}
+async function getTaskAwareCapacity() {
+  const { getClient } = await import("./lib/database.js");
+  const { sessionScopeFilter } = await import("./task-scope-GNCB2GAM.js");
+  const client = getClient();
+  const scope = sessionScopeFilter();
+  const result = await client.execute({
+    sql: `SELECT assigned_to, COUNT(*) as cnt
+          FROM tasks
+          WHERE status IN ('open', 'in_progress')${scope.sql}
+          GROUP BY assigned_to`,
+    args: [...scope.args]
+  });
+  const busyAgents = [];
+  let totalInProgress = 0;
+  for (const row of result.rows) {
+    const agent = String(row.assigned_to ?? "");
+    const count = Number(row.cnt ?? 0);
+    if (agent && count > 0) {
+      busyAgents.push(agent);
+      totalInProgress += count;
+    }
+  }
+  const idleAgents = [];
+  try {
+    const { listTmuxSessions } = await import("./lib/tmux-status.js");
+    const { isExeSession } = await import("./lib/tmux-routing.js");
+    const { baseAgentName } = await import("./lib/employees.js");
+    const liveSessions = listTmuxSessions().filter((s) => !isExeSession(s) && s.includes("-"));
+    const liveAgentNames = new Set(liveSessions.map((s) => baseAgentName(s.split("-")[0] ?? "")));
+    for (const name of liveAgentNames) {
+      if (name && !busyAgents.includes(name)) {
+        idleAgents.push(name);
+      }
+    }
+  } catch {
+  }
+  return { busyAgents, idleAgents, totalInProgress };
+}
+
+export {
+  MAX_CONCURRENT_WORKERS,
+  tryAcquireWorkerSlot,
+  registerWorkerPid,
+  cleanupWorkerPid,
+  tryAcquireBackfillLock,
+  releaseBackfillLock,
+  getTaskAwareCapacity
+};