@askexenow/exe-os 0.9.280 → 0.9.282

package/dist/chunk-NXYIFEPV.js

@@ -0,0 +1,539 @@
+import {
+  writeDispatchPending
+} from "./chunk-MLXJ5EZG.js";
+import {
+  createTask
+} from "./chunk-ZLAWNHQR.js";
+import {
+  getActiveAgent
+} from "./chunk-MYA2X5OY.js";
+import {
+  ensureEmployee,
+  logTaskDispatch,
+  resolveExeSession
+} from "./chunk-PC635OAG.js";
+import {
+  recordOrchestrationEventBestEffort
+} from "./chunk-FSRKIZGZ.js";
+import {
+  getAgentRuntime,
+  validateRuntimeModel
+} from "./chunk-PMVOUPTY.js";
+import {
+  getLicenseSync
+} from "./chunk-TQ4VXUAF.js";
+import {
+  getAgentContext
+} from "./chunk-GJV3WDWM.js";
+import {
+  isCoordinatorName
+} from "./chunk-52UDAVZE.js";
+
+// src/mcp/tools/create-task.ts
+import { z } from "zod";
+import { existsSync, readdirSync, statSync, 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);
+}
+function findProjectChildDir(parentDir, projectName) {
+  if (!existsSync(parentDir)) return null;
+  const normalizedProject = projectName.toLowerCase();
+  const aliases = /* @__PURE__ */ new Set([
+    normalizedProject,
+    normalizedProject.replace(/^exe-/, "")
+  ]);
+  const exactCandidate = join(parentDir, projectName);
+  if (existsSync(exactCandidate) && statSync(exactCandidate).isDirectory()) return exactCandidate;
+  try {
+    for (const entry of readdirSync(parentDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const lower = entry.name.toLowerCase();
+      if (aliases.has(lower) || `exe-${lower}` === normalizedProject) {
+        return join(parentDir, entry.name);
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+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;
+        }
+        const childProjectDir = findProjectChildDir(coordSession.projectDir, projectName);
+        if (childProjectDir) {
+          return childProjectDir;
+        }
+        process.stderr.write(
+          `[create-task] project mismatch: coordinator dir="${coordSession.projectDir}" (${basename(coordSession.projectDir).toLowerCase()}) vs task project="${projectName}". Falling through.
+`
+        );
+      }
+    } catch (err) {
+      process.stderr.write(
+        `[create-task] resolveProjectDir: coordinator-session resolution failed for callerSession="${callerSession}": ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+  }
+  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;
+  }
+  const cwd = process.cwd();
+  if (cwd !== home && existsSync(join(cwd, ".git"))) {
+    process.stderr.write(
+      `[create-task] WARN: could not resolve project dir for "${projectName}" \u2014 falling back to cwd (${cwd}). This may cause agents to spawn in the wrong repo.
+`
+    );
+    return cwd;
+  }
+  const fallback = join(home, projectName);
+  process.stderr.write(
+    `[create-task] ERROR: could not resolve project dir for "${projectName}". cwd=${cwd} is not a valid project directory. Using ${fallback} as fallback (may not exist). Ensure the project is cloned or the coordinator session registry is populated.
+`
+  );
+  return fallback;
+}
+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 effectiveRuntime = spawn_runtime ?? getAgentRuntime(assigned_to).runtime;
+      let effectiveSpawnModel = spawn_model;
+      if (spawn_model) {
+        const validated = validateRuntimeModel(effectiveRuntime, spawn_model);
+        if (!validated.ok) {
+          return {
+            content: [{ type: "text", text: validated.error }],
+            isError: true
+          };
+        }
+        effectiveSpawnModel = validated.model;
+      }
+      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: effectiveSpawnModel,
+        // 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-MDXUEVRZ.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-YV2WPKRD.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: effectiveSpawnModel ?? 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({
+                  // Audited 2026: intentionally unscoped PK update. The task was
+                  // just created in this request, and WHERE id = ? binds one row.
+                  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-O2GVE5B5.js

@@ -0,0 +1,58 @@
+import {
+  MODELS_DIR
+} from "./chunk-T3B5RK4H.js";
+
+// src/lib/reranker.ts
+import path from "path";
+import { existsSync } from "fs";
+var RERANKER_MODEL_FILE = process.env.EXE_RERANK_MODEL_FILE ?? "exe-reranker-v1-q4_k_m.gguf";
+function isRerankerAvailable() {
+  return existsSync(path.join(MODELS_DIR, RERANKER_MODEL_FILE));
+}
+function getRerankerModelPath() {
+  return path.join(MODELS_DIR, RERANKER_MODEL_FILE);
+}
+async function disposeReranker() {
+}
+async function rerankWithScores(query, texts, topK) {
+  if (texts.length === 0) return [];
+  const { rerankViaWorker } = await import("./lib/exe-daemon.js");
+  const scored = await rerankViaWorker(query, texts, topK);
+  return scored.map((s) => ({
+    text: texts[s.index] ?? "",
+    score: s.score,
+    index: s.index
+  }));
+}
+async function rerank(query, candidates, topK = 5) {
+  if (candidates.length === 0) return [];
+  if (candidates.length <= topK) return candidates;
+  const scored = await rerankWithScores(
+    query,
+    candidates.map((c) => c.raw_text),
+    topK
+  );
+  return scored.map((s) => candidates[s.index]);
+}
+async function rerankWithContext(query, candidates, topK) {
+  if (candidates.length === 0) return [];
+  const formattedTexts = candidates.map(
+    (c) => c.context ? `[${c.context}] ${c.text.slice(0, 460)}` : c.text.slice(0, 512)
+  );
+  const { rerankViaWorker } = await import("./lib/exe-daemon.js");
+  const scored = await rerankViaWorker(query, formattedTexts, topK);
+  return scored.map((s) => ({
+    text: candidates[s.index]?.text ?? "",
+    score: s.score,
+    index: s.index
+  }));
+}
+
+export {
+  isRerankerAvailable,
+  getRerankerModelPath,
+  disposeReranker,
+  rerankWithScores,
+  rerank,
+  rerankWithContext
+};