@askexenow/exe-os 0.9.127 → 0.9.129

package/dist/chunk-MLCUPTP7.js

@@ -0,0 +1,132 @@
+// src/lib/session-wrappers.ts
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  chmodSync,
+  readdirSync,
+  unlinkSync
+} from "fs";
+import { execSync } from "child_process";
+import path from "path";
+import { homedir } from "os";
+var MAX_N = 9;
+function generateSessionWrappers(packageRoot, homeDir) {
+  const home = homeDir ?? homedir();
+  const binDir = path.join(home, ".exe-os", "bin");
+  const rosterPath = path.join(home, ".exe-os", "exe-employees.json");
+  const shouldMirrorToGlobalBin = homeDir === void 0;
+  mkdirSync(binDir, { recursive: true });
+  const exeStartDst = path.join(binDir, "exe-start");
+  const candidates = [
+    path.join(packageRoot, "dist", "bin", "exe-start.sh"),
+    path.join(packageRoot, "src", "bin", "exe-start.sh")
+  ];
+  for (const src of candidates) {
+    if (existsSync(src)) {
+      writeFileSync(exeStartDst, readFileSync(src));
+      chmodSync(exeStartDst, 493);
+      break;
+    }
+  }
+  let employees = [];
+  try {
+    employees = JSON.parse(readFileSync(rosterPath, "utf8"));
+  } catch {
+    return { created: 0, pathConfigured: false };
+  }
+  if (employees.length === 0) {
+    return { created: 0, pathConfigured: false };
+  }
+  try {
+    for (const f of readdirSync(binDir)) {
+      if (f === "exe-start") continue;
+      const fPath = path.join(binDir, f);
+      try {
+        const content = readFileSync(fPath, "utf8");
+        if (content.includes("exe-start")) {
+          unlinkSync(fPath);
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  let created = 0;
+  const wrapperContent = `#!/bin/bash
+exec "${exeStartDst}" "$0" "$@"
+`;
+  const globalBinDir = shouldMirrorToGlobalBin ? resolveGlobalBinDir() : null;
+  for (const emp of employees) {
+    for (let n = 1; n <= MAX_N; n++) {
+      writeWrapper(path.join(binDir, `${emp.name}${n}`), wrapperContent);
+      if (globalBinDir) {
+        writeWrapper(path.join(globalBinDir, `${emp.name}${n}`), wrapperContent);
+      }
+      created++;
+    }
+  }
+  const pathConfigured = ensurePath(home, binDir);
+  return { created, pathConfigured };
+}
+function writeWrapper(wrapperPath, content) {
+  try {
+    writeFileSync(wrapperPath, content);
+    chmodSync(wrapperPath, 493);
+  } catch {
+  }
+}
+function resolveGlobalBinDir() {
+  try {
+    const exeOsPath = execSync("command -v exe-os", { encoding: "utf8", timeout: 3e3 }).trim().split("\n")[0];
+    if (exeOsPath) return path.dirname(exeOsPath);
+  } catch {
+  }
+  try {
+    const prefix = execSync("npm prefix -g", { encoding: "utf8", timeout: 3e3 }).trim();
+    if (prefix) return path.join(prefix, "bin");
+  } catch {
+  }
+  return null;
+}
+function ensurePath(home, binDir) {
+  if (process.env.PATH?.split(":").includes(binDir)) {
+    return false;
+  }
+  const exportLine = `
+# exe-os session commands
+export PATH="${binDir}:$PATH"
+`;
+  const shell = process.env.SHELL ?? "/bin/bash";
+  const profilePaths = [];
+  if (shell.includes("zsh")) {
+    profilePaths.push(path.join(home, ".zshrc"));
+  } else if (shell.includes("bash")) {
+    profilePaths.push(path.join(home, ".bashrc"));
+    profilePaths.push(path.join(home, ".bash_profile"));
+  } else {
+    profilePaths.push(path.join(home, ".profile"));
+  }
+  for (const profilePath of profilePaths) {
+    try {
+      let content = "";
+      try {
+        content = readFileSync(profilePath, "utf8");
+      } catch {
+      }
+      if (content.includes(".exe-os/bin")) {
+        return false;
+      }
+      writeFileSync(profilePath, content + exportLine);
+      return true;
+    } catch {
+      continue;
+    }
+  }
+  return false;
+}
+
+export {
+  generateSessionWrappers
+};

package/dist/chunk-MPURH6JI.js

@@ -0,0 +1,445 @@
+import {
+  init_session_scope,
+  session_scope_exports
+} from "./chunk-MVBWW2EO.js";
+import {
+  createTaskCore,
+  deleteTaskCore,
+  init_tasks_crud,
+  updateTaskStatus
+} from "./chunk-2QD7KBJN.js";
+import {
+  cleanupReviewFile,
+  employeeSessionName,
+  ensureEmployee,
+  init_notifications,
+  init_task_scope,
+  init_tasks_review,
+  init_tmux_routing,
+  markAsReadByTaskFile,
+  notifyParentExe,
+  resolveExeSession,
+  sendIntercom,
+  sessionScopeFilter,
+  writeNotification
+} from "./chunk-N7L33TED.js";
+import {
+  getTransport,
+  init_transport
+} from "./chunk-R4M6XCMU.js";
+import {
+  getSessionKey,
+  init_session_key
+} from "./chunk-HP43GLZ6.js";
+import {
+  init_state_bus,
+  orgBus
+} from "./chunk-WZQ4CPRG.js";
+import {
+  getClient,
+  init_database
+} from "./chunk-A2NZP64U.js";
+import {
+  getCoordinatorName,
+  init_employees,
+  isCoordinatorName,
+  isMultiInstance
+} from "./chunk-RUG3N6P4.js";
+import {
+  EXE_AI_DIR,
+  init_config
+} from "./chunk-KVPG5UT6.js";
+import {
+  __esm,
+  __toCommonJS
+} from "./chunk-KFQGP6VL.js";
+
+// src/lib/tasks-chain.ts
+import path from "path";
+import { readFile, writeFile } from "fs/promises";
+async function cascadeUnblock(taskId, baseDir, now) {
+  const client = getClient();
+  const unblocked = await client.execute({
+    sql: `UPDATE tasks SET status = 'open', blocked_by = NULL, updated_at = ?
+          WHERE blocked_by = ? AND status = 'blocked'`,
+    args: [now, taskId]
+  });
+  if (unblocked.rowsAffected === 0) return;
+  const ubScope = sessionScopeFilter();
+  const unblockedRows = await client.execute({
+    sql: `SELECT id, title, assigned_to, priority, task_file FROM tasks WHERE blocked_by IS NULL AND updated_at = ?${ubScope.sql}`,
+    args: [now, ...ubScope.args]
+  });
+  if (baseDir) {
+    for (const ur of unblockedRows.rows) {
+      try {
+        const ubFile = path.join(baseDir, String(ur.task_file));
+        let ubContent = await readFile(ubFile, "utf-8");
+        ubContent = ubContent.replace(/\*\*Status:\*\* blocked/, "**Status:** open");
+        ubContent = ubContent.replace(/\n\*\*Blocked by:\*\*.*\n/, "\n");
+        await writeFile(ubFile, ubContent, "utf-8");
+      } catch {
+      }
+    }
+  }
+  if (unblockedRows.rows.length > 0 && !process.env.VITEST) {
+    try {
+      const { queueIntercom } = await import("./intercom-queue-PEEGAJ33.js");
+      const dispatched = /* @__PURE__ */ new Set();
+      for (const ur of unblockedRows.rows) {
+        const assignee = String(ur.assigned_to);
+        if (dispatched.has(assignee)) continue;
+        dispatched.add(assignee);
+        queueIntercom(`${assignee}`, `unblocked: "${String(ur.title)}" is now ready`);
+      }
+    } catch {
+    }
+  }
+}
+async function findNextTask(assignedTo) {
+  const client = getClient();
+  const ntScope = sessionScopeFilter();
+  const nextResult = await client.execute({
+    sql: `SELECT title, task_file, priority FROM tasks
+          WHERE assigned_to = ? AND status = 'open'${ntScope.sql}
+          ORDER BY priority ASC, created_at ASC
+          LIMIT 1`,
+    args: [assignedTo, ...ntScope.args]
+  });
+  if (nextResult.rows.length === 1) {
+    const nr = nextResult.rows[0];
+    return {
+      title: String(nr.title),
+      priority: String(nr.priority),
+      taskFile: String(nr.task_file)
+    };
+  }
+  return void 0;
+}
+async function checkSubtaskCompletion(parentTaskId, projectName) {
+  const client = getClient();
+  const scScope = sessionScopeFilter();
+  const remaining = await client.execute({
+    sql: `SELECT COUNT(*) as cnt FROM tasks
+          WHERE parent_task_id = ? AND status NOT IN ('done', 'cancelled', 'closed')${scScope.sql}`,
+    args: [parentTaskId, ...scScope.args]
+  });
+  const cnt = Number(remaining.rows[0]?.cnt ?? 1);
+  if (cnt === 0) {
+    const parentRow = await client.execute({
+      sql: `SELECT assigned_to, title, task_file, project_name FROM tasks WHERE id = ?`,
+      args: [parentTaskId]
+    });
+    if (parentRow.rows.length === 1) {
+      const pr = parentRow.rows[0];
+      const parentProject = pr.project_name == null ? projectName : String(pr.project_name);
+      await writeNotification({
+        agentId: String(pr.assigned_to),
+        agentRole: "system",
+        event: "subtasks_complete",
+        project: parentProject,
+        summary: `All subtasks complete for "${String(pr.title)}" \u2014 ready for rollup review`,
+        taskFile: String(pr.task_file)
+      });
+    }
+  }
+}
+var init_tasks_chain = __esm({
+  "src/lib/tasks-chain.ts"() {
+    "use strict";
+    init_database();
+    init_notifications();
+    init_task_scope();
+  }
+});
+
+// src/lib/tasks-notify.ts
+async function dispatchTaskToEmployee(input) {
+  if (isCoordinatorName(input.assignedTo)) return { dispatched: "skipped" };
+  let crossProject = false;
+  if (input.projectName) {
+    try {
+      const { assertSessionScope } = (init_session_scope(), __toCommonJS(session_scope_exports));
+      const check = assertSessionScope("dispatch_task", input.projectName);
+      if (check.reason === "cross_session_denied") {
+        crossProject = true;
+        return { dispatched: "skipped", crossProject: true };
+      }
+    } catch {
+    }
+  }
+  try {
+    const transport = getTransport();
+    const exeSession = resolveExeSession();
+    if (!exeSession) return { dispatched: "session_missing" };
+    const sessionName = employeeSessionName(input.assignedTo, exeSession);
+    if (transport.isAlive(sessionName)) {
+      const result = sendIntercom(sessionName);
+      const dispatched = result === "acknowledged" || result === "debounced" || result === "queued" ? "verified" : result === "delivered" ? "sent_unverified" : "session_dead";
+      process.stderr.write(
+        `[dispatch-audit] intercom \u2192 ${sessionName} | task="${input.title}" [${input.priority}] | result=${dispatched} (sendIntercom=${result})
+`
+      );
+      return { dispatched, session: sessionName, crossProject };
+    } else {
+      const projectDir = input.projectDir ?? process.cwd();
+      const result = ensureEmployee(input.assignedTo, exeSession, projectDir, {
+        autoInstance: isMultiInstance(input.assignedTo)
+      });
+      if (result.status === "failed") {
+        process.stderr.write(
+          `[dispatch-audit] SPAWN FAILED \u2192 ${input.assignedTo} | task="${input.title}" [${input.priority}] | error=${result.error}
+`
+        );
+        return { dispatched: "session_missing" };
+      }
+      process.stderr.write(
+        `[dispatch-audit] SPAWNED \u2192 ${result.sessionName} | task="${input.title}" [${input.priority}]
+`
+      );
+      return { dispatched: "spawned", session: result.sessionName, crossProject };
+    }
+  } catch {
+    return { dispatched: "session_missing" };
+  }
+}
+function notifyTaskDone() {
+  try {
+    const key = getSessionKey();
+    if (key && !process.env.VITEST) {
+      notifyParentExe(key);
+      process.stderr.write(
+        `[dispatch-audit] notifyTaskDone \u2192 parent coordinator (session=${key})
+`
+      );
+    }
+  } catch {
+  }
+}
+async function markTaskNotificationsRead(taskFile) {
+  try {
+    await markAsReadByTaskFile(taskFile);
+  } catch {
+  }
+}
+var init_tasks_notify = __esm({
+  "src/lib/tasks-notify.ts"() {
+    "use strict";
+    init_tmux_routing();
+    init_session_key();
+    init_notifications();
+    init_transport();
+    init_employees();
+  }
+});
+
+// src/lib/tasks.ts
+import path2 from "path";
+import { writeFileSync, mkdirSync, unlinkSync } from "fs";
+async function createTask(input) {
+  const result = await createTaskCore(input);
+  if (!input.skipDispatch && result.status !== "blocked" && !process.env.VITEST) {
+    dispatchTaskToEmployee({
+      assignedTo: input.assignedTo,
+      title: input.title,
+      priority: input.priority,
+      taskFile: result.taskFile,
+      initialStatus: result.status,
+      projectName: input.projectName
+    });
+  }
+  return result;
+}
+async function updateTask(input) {
+  const { row, taskFile, now, taskId } = await updateTaskStatus(input);
+  try {
+    const agent = String(row.assigned_to);
+    const cacheDir = path2.join(EXE_AI_DIR, "session-cache");
+    const cachePath = path2.join(cacheDir, `current-task-${agent}.json`);
+    if (input.status === "in_progress") {
+      mkdirSync(cacheDir, { recursive: true });
+      writeFileSync(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
+    } else if (input.status === "done" || input.status === "blocked" || input.status === "cancelled" || input.status === "closed") {
+      try {
+        unlinkSync(cachePath);
+      } catch {
+      }
+    }
+  } catch {
+  }
+  if (input.status === "done" || input.status === "closed") {
+    await cleanupReviewFile(row, taskFile, input.baseDir);
+  }
+  if (input.status === "done" || input.status === "cancelled" || input.status === "closed") {
+    try {
+      const client = getClient();
+      const taskTitle = String(row.title);
+      const escaped = taskTitle.replace(/%/g, "\\%").replace(/_/g, "\\_");
+      await client.execute({
+        sql: `UPDATE tasks SET status = 'cancelled', updated_at = ?
+              WHERE title LIKE ? ESCAPE '\\' AND status IN ('open', 'in_progress')`,
+        args: [now, `%left '${escaped}' as in\\_progress%`]
+      });
+    } catch {
+    }
+    const assignedAgent = String(row.assigned_to);
+    if (!isCoordinatorName(assignedAgent)) {
+      try {
+        const draftClient = getClient();
+        if (input.status === "done" || input.status === "closed") {
+          await draftClient.execute({
+            sql: `UPDATE memories SET draft = 0 WHERE agent_id = ? AND draft = 1`,
+            args: [assignedAgent]
+          });
+        } else if (input.status === "cancelled") {
+          const now2 = (/* @__PURE__ */ new Date()).toISOString();
+          await draftClient.execute({
+            sql: `UPDATE memories SET status = 'deleted', deleted_at = ? WHERE agent_id = ? AND draft = 1`,
+            args: [now2, assignedAgent]
+          });
+        }
+      } catch {
+      }
+    }
+    try {
+      const client = getClient();
+      const cascaded = await client.execute({
+        sql: `UPDATE tasks SET status = 'closed', updated_at = ?
+              WHERE parent_task_id = ? AND status = 'needs_review'`,
+        args: [now, taskId]
+      });
+      if (cascaded.rowsAffected > 0) {
+        process.stderr.write(
+          `[cascade] Closed ${cascaded.rowsAffected} orphaned review task(s) for parent ${taskId}
+`
+        );
+      }
+    } catch {
+    }
+  }
+  const isTerminal = input.status === "done" || input.status === "needs_review" || input.status === "closed";
+  if (isTerminal) {
+    const isCoordinator = isCoordinatorName(String(row.assigned_to));
+    if (!isCoordinator) {
+      notifyTaskDone();
+    }
+    await markTaskNotificationsRead(taskFile);
+    if (input.status === "needs_review" && !isCoordinator) {
+      try {
+        const { writeNotification: writeNotification2 } = await import("./notifications-CJFULBMN.js");
+        await writeNotification2({
+          agentId: String(row.assigned_to),
+          agentRole: String(row.assigned_to),
+          event: "task_complete",
+          project: String(row.project_name),
+          summary: `"${String(row.title)}" is ready for review`,
+          taskFile
+        });
+      } catch {
+      }
+    }
+    if (input.status === "done" || input.status === "closed") {
+      try {
+        await cascadeUnblock(taskId, input.baseDir, now);
+      } catch {
+      }
+      orgBus.emit({
+        type: "task_completed",
+        taskId,
+        employee: String(row.assigned_to),
+        result: input.result ?? "",
+        timestamp: now
+      });
+      if (row.parent_task_id) {
+        try {
+          await checkSubtaskCompletion(String(row.parent_task_id), String(row.project_name));
+        } catch {
+        }
+      }
+    }
+  }
+  if (input.status === "cancelled") {
+    try {
+      await cascadeUnblock(taskId, input.baseDir, now);
+    } catch {
+    }
+  }
+  if ((input.status === "done" || input.status === "closed") && !isCoordinatorName(String(row.assigned_to)) && !process.env.VITEST) {
+    import("./lib/skill-learning.js").then(
+      ({ captureAndLearn }) => captureAndLearn({
+        taskId,
+        agentId: String(row.assigned_to),
+        projectName: String(row.project_name),
+        taskTitle: String(row.title)
+      })
+    ).catch((err) => {
+      process.stderr.write(
+        `[updateTask] skill learning failed: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    });
+  }
+  let nextTask;
+  if (isTerminal && !isCoordinatorName(String(row.assigned_to))) {
+    try {
+      nextTask = await findNextTask(String(row.assigned_to));
+    } catch {
+    }
+  }
+  return {
+    id: String(row.id),
+    title: String(row.title),
+    assignedTo: String(row.assigned_to),
+    assignedBy: String(row.assigned_by),
+    projectName: String(row.project_name),
+    priority: String(row.priority),
+    status: input.status,
+    taskFile,
+    createdAt: String(row.created_at),
+    updatedAt: now,
+    budgetTokens: row.budget_tokens !== void 0 && row.budget_tokens !== null ? Number(row.budget_tokens) : null,
+    budgetFallbackModel: row.budget_fallback_model !== void 0 && row.budget_fallback_model !== null ? String(row.budget_fallback_model) : null,
+    tokensUsed: Number(row.tokens_used ?? 0),
+    tokensWarnedAt: row.tokens_warned_at !== void 0 && row.tokens_warned_at !== null ? Number(row.tokens_warned_at) : null,
+    spawnRuntime: row.spawn_runtime !== void 0 && row.spawn_runtime !== null ? String(row.spawn_runtime) : null,
+    spawnModel: row.spawn_model !== void 0 && row.spawn_model !== null ? String(row.spawn_model) : null,
+    nextTask
+  };
+}
+async function deleteTask(taskId, baseDir) {
+  const client = getClient();
+  const { taskFile, assignedTo, assignedBy, taskSlug } = await deleteTaskCore(taskId, baseDir);
+  const coordinatorName = getCoordinatorName();
+  const reviewer = assignedBy || coordinatorName;
+  const reviewSlug = `review-${assignedTo}-${taskSlug}`;
+  const reviewFile = `exe/${reviewer}/${reviewSlug}.md`;
+  const legacyReviewFile = `exe/${coordinatorName}/${reviewSlug}.md`;
+  await client.execute({
+    sql: "DELETE FROM tasks WHERE task_file = ? OR task_file = ? OR task_file = ?",
+    args: [reviewFile, legacyReviewFile, `exe/exe/${reviewSlug}.md`]
+  });
+  await markAsReadByTaskFile(taskFile);
+  await markAsReadByTaskFile(reviewFile);
+}
+var init_tasks = __esm({
+  "src/lib/tasks.ts"() {
+    init_database();
+    init_config();
+    init_notifications();
+    init_state_bus();
+    init_employees();
+    init_tasks_crud();
+    init_tasks_review();
+    init_tasks_crud();
+    init_tasks_chain();
+    init_tasks_review();
+    init_tasks_notify();
+  }
+});
+
+export {
+  createTask,
+  updateTask,
+  deleteTask,
+  init_tasks
+};

package/dist/chunk-MVBWW2EO.js

@@ -0,0 +1,89 @@
+import {
+  getProjectName,
+  init_project_name
+} from "./chunk-LPGBKR4H.js";
+import {
+  init_tmux_routing,
+  resolveExeSession
+} from "./chunk-N7L33TED.js";
+import {
+  init_session_registry,
+  listSessions
+} from "./chunk-KRLOFIPI.js";
+import {
+  init_employees,
+  isCoordinatorName
+} from "./chunk-RUG3N6P4.js";
+import {
+  __esm,
+  __export
+} from "./chunk-KFQGP6VL.js";
+
+// src/lib/session-scope.ts
+var session_scope_exports = {};
+__export(session_scope_exports, {
+  assertSessionScope: () => assertSessionScope,
+  findSessionForProject: () => findSessionForProject,
+  getSessionProject: () => getSessionProject
+});
+function getSessionProject(sessionName) {
+  const sessions = listSessions();
+  const entry = sessions.find((s) => s.windowName === sessionName);
+  if (!entry) return null;
+  const parts = entry.projectDir.split("/").filter(Boolean);
+  return parts[parts.length - 1] ?? null;
+}
+function findSessionForProject(projectName) {
+  const sessions = listSessions();
+  for (const s of sessions) {
+    const proj = s.projectDir.split("/").filter(Boolean).pop();
+    if (proj === projectName && isCoordinatorName(s.agentId)) return s;
+  }
+  return null;
+}
+function assertSessionScope(actionType, targetProject) {
+  try {
+    const currentProject = getProjectName();
+    const exeSession = resolveExeSession();
+    if (!exeSession) {
+      return { allowed: true, reason: "no_session" };
+    }
+    if (currentProject === targetProject) {
+      return {
+        allowed: true,
+        reason: "same_session",
+        currentProject,
+        targetProject
+      };
+    }
+    process.stderr.write(
+      `[session-scope] BLOCKED cross-project ${actionType}: session project="${currentProject}" \u2260 target project="${targetProject}"
+`
+    );
+    return {
+      allowed: false,
+      reason: "cross_session_denied",
+      currentProject,
+      targetProject,
+      targetSession: findSessionForProject(targetProject)?.windowName
+    };
+  } catch {
+    return { allowed: true, reason: "no_session" };
+  }
+}
+var init_session_scope = __esm({
+  "src/lib/session-scope.ts"() {
+    init_session_registry();
+    init_project_name();
+    init_tmux_routing();
+    init_employees();
+  }
+});
+
+export {
+  getSessionProject,
+  findSessionForProject,
+  assertSessionScope,
+  session_scope_exports,
+  init_session_scope
+};

package/dist/chunk-MZIGUUDQ.js

@@ -0,0 +1,42 @@
+// src/lib/update-check.ts
+import { execSync } from "child_process";
+import { readFileSync } from "fs";
+import path from "path";
+function getLocalVersion(packageRoot) {
+  const pkgPath = path.join(packageRoot, "package.json");
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+  return pkg.version;
+}
+function getRemoteVersion() {
+  try {
+    const output = execSync("npm view @askexenow/exe-os version", {
+      encoding: "utf-8",
+      timeout: 15e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return output.trim();
+  } catch {
+    return null;
+  }
+}
+function checkForUpdate(packageRoot) {
+  const localVersion = getLocalVersion(packageRoot);
+  const remoteVersion = getRemoteVersion();
+  if (!remoteVersion) {
+    return {
+      updateAvailable: false,
+      localVersion,
+      error: "Could not reach npm registry or package not published yet"
+    };
+  }
+  if (remoteVersion === localVersion) {
+    return { updateAvailable: false, localVersion, remoteVersion };
+  }
+  return { updateAvailable: true, localVersion, remoteVersion };
+}
+
+export {
+  getLocalVersion,
+  getRemoteVersion,
+  checkForUpdate
+};