@askexenow/exe-os 0.9.288 → 0.9.290

package/dist/chunk-Q2R3WUW4.js

@@ -0,0 +1,448 @@
+import {
+  dispatchTaskToEmployee,
+  markTaskNotificationsRead,
+  notifyTaskDone
+} from "./chunk-LHW7TZGJ.js";
+import {
+  cleanupReviewFile,
+  createTaskCore,
+  deleteTaskCore,
+  markAsReadByTaskFile,
+  sessionScopeFilter,
+  updateTaskStatus,
+  writeNotification
+} from "./chunk-F23GFLKY.js";
+import {
+  orgBus
+} from "./chunk-MP2AFCGL.js";
+import {
+  getClient,
+  getCoordinatorName,
+  isCoordinatorName
+} from "./chunk-3X2ZT5FN.js";
+import {
+  EXE_AI_DIR
+} from "./chunk-5P3HOBZX.js";
+
+// src/lib/tasks.ts
+import path2 from "path";
+import { writeFileSync, mkdirSync, unlinkSync } from "fs";
+
+// 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 ubScope = sessionScopeFilter();
+  const blockedRows = await client.execute({
+    sql: `SELECT id, title, assigned_to, priority, task_file, project_name FROM tasks WHERE blocked_by = ? AND status = 'blocked'${ubScope.sql}`,
+    args: [taskId, ...ubScope.args]
+  });
+  if (blockedRows.rows.length === 0) return;
+  const ids = blockedRows.rows.map((r) => String(r.id));
+  const ph = ids.map(() => "?").join(",");
+  await client.execute({
+    sql: `UPDATE tasks SET status = 'open', blocked_by = NULL, updated_at = ?
+          WHERE id IN (${ph})`,
+    args: [now, ...ids]
+  });
+  const unblockedRows = blockedRows;
+  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 { dispatchTaskToEmployee: dispatchTaskToEmployee2 } = await import("./tasks-notify-AJSRQHLZ.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);
+        const unblockedId = String(ur.id);
+        const title = String(ur.title);
+        const priority = String(ur.priority ?? "P2");
+        const taskFile = String(ur.task_file ?? "");
+        const projectName = ur.project_name != null ? String(ur.project_name) : void 0;
+        dispatchTaskToEmployee2({
+          assignedTo: assignee,
+          taskId: unblockedId,
+          title,
+          priority,
+          taskFile,
+          initialStatus: "open",
+          projectDir: baseDir,
+          projectName
+        }).catch(() => {
+        });
+      }
+    } catch {
+      try {
+        const { queueIntercom } = await import("./intercom-queue-6M5IRX3Y.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', 'needs_review', '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, session_scope 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),
+        // Scope the notification to the parent task's coordinator session —
+        // prevents subtask-complete notifications from leaking to other coordinator lanes.
+        sessionScope: pr.session_scope ? String(pr.session_scope) : void 0
+      });
+    }
+  }
+}
+
+// src/lib/tasks.ts
+async function createTask(input) {
+  const result = await createTaskCore(input);
+  if (!input.skipDispatch && result.status !== "blocked" && !process.env.VITEST) {
+    dispatchTaskToEmployee({
+      assignedTo: input.assignedTo,
+      taskId: result.id,
+      title: input.title,
+      priority: input.priority,
+      taskFile: result.taskFile,
+      initialStatus: result.status,
+      projectName: input.projectName,
+      spawnRuntime: input.spawnRuntime ?? void 0,
+      spawnModel: input.spawnModel ?? void 0
+    });
+  }
+  return result;
+}
+async function updateTask(input) {
+  const { row, taskFile, now, taskId, previousStatus, requestedStatus } = 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 === "needs_review" || input.status === "done" || input.status === "blocked" || input.status === "cancelled" || input.status === "closed") {
+      try {
+        unlinkSync(cachePath);
+      } catch {
+      }
+    }
+  } catch (e) {
+    process.stderr.write(`[tasks] trajectory tagging failed: ${e instanceof Error ? e.message : String(e)}
+`);
+  }
+  if (input.status === "needs_review" || input.status === "done" || input.status === "closed") {
+    await cleanupReviewFile(row, taskFile, input.baseDir);
+  }
+  if (input.status === "needs_review" || 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 (e) {
+      process.stderr.write(`[tasks] shadow task cleanup failed: ${e instanceof Error ? e.message : String(e)}
+`);
+    }
+    const assignedAgent = String(row.assigned_to);
+    if (!isCoordinatorName(assignedAgent)) {
+      try {
+        const draftClient = getClient();
+        if (input.status === "needs_review" || 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 (e) {
+        process.stderr.write(`[tasks] draft memory promotion/purge failed: ${e instanceof Error ? e.message : String(e)}
+`);
+      }
+    }
+    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 (e) {
+      process.stderr.write(`[tasks] review cascade close failed: ${e instanceof Error ? e.message : String(e)}
+`);
+    }
+  }
+  const isCoordinator = isCoordinatorName(String(row.assigned_to));
+  if (input.status === "done" && row.reviewer && !isCoordinator) {
+    input.status = "needs_review";
+  }
+  const isTerminal = input.status === "done" || input.status === "needs_review" || input.status === "closed";
+  const isCompletionReviewTransition = requestedStatus === "done" && input.status === "needs_review" && (previousStatus === "open" || previousStatus === "in_progress");
+  if (isTerminal) {
+    if (!isCoordinator && isCompletionReviewTransition) {
+      notifyTaskDone();
+    }
+    if (isCompletionReviewTransition && row.reviewer && !isCoordinator) {
+      const reviewer = String(row.reviewer);
+      const taskTitle = String(row.title);
+      let delivered = false;
+      try {
+        const { sendIntercom, resolveExeSession, employeeSessionName } = await import("./lib/tmux-routing.js");
+        const exeSession = row.session_scope ? String(row.session_scope) : resolveExeSession();
+        if (exeSession) {
+          if (isCoordinatorName(reviewer)) {
+            const cooResult = sendIntercom(exeSession, { force: true, reason: "completion" });
+            if (cooResult !== "failed") {
+              delivered = true;
+              process.stderr.write(`[tasks] EVENT: notified coordinator "${reviewer}" for "${taskTitle}" (force)
+`);
+            }
+          } else {
+            const reviewerSession = employeeSessionName(reviewer, exeSession);
+            const result = sendIntercom(reviewerSession, { force: true, reason: "completion" });
+            if (result !== "failed") {
+              delivered = true;
+              process.stderr.write(`[tasks] EVENT: notified reviewer "${reviewer}" via tmux for "${taskTitle}"
+`);
+            }
+          }
+        }
+      } catch (e) {
+        process.stderr.write(`[tasks] EVENT: tmux delivery failed: ${e instanceof Error ? e.message : String(e)}
+`);
+      }
+      if (!delivered) {
+        try {
+          process.stderr.write(`[tasks] EVENT: tmux delivery failed for reviewer="${reviewer}". Queueing for daemon delivery.
+`);
+          const { queueIntercom } = await import("./intercom-queue-6M5IRX3Y.js");
+          const { resolveExeSession } = await import("./lib/tmux-routing.js");
+          const exeSession = row.session_scope ? String(row.session_scope) : resolveExeSession();
+          if (exeSession) {
+            const reviewerSession = isCoordinatorName(reviewer) ? exeSession : `${reviewer}-${exeSession}`;
+            queueIntercom(
+              reviewerSession,
+              `Review ready: "${taskTitle}" by ${String(row.assigned_to)}. Run /exe-review.`,
+              "completion"
+            );
+          }
+        } catch (e) {
+          process.stderr.write(`[tasks] EVENT: intercom queue failed: ${e instanceof Error ? e.message : String(e)}
+`);
+        }
+      }
+      try {
+        const { pushNotifyAsync } = await import("./push-notifications-X7E7GSC7.js");
+        pushNotifyAsync({
+          event: "review_ready",
+          title: `Review ready: ${taskTitle.slice(0, 50)}`,
+          body: `${String(row.assigned_to)} completed "${taskTitle}". Reviewer: ${reviewer}`,
+          priority: "normal"
+        });
+      } catch {
+      }
+    }
+    if (!isCoordinator && isCompletionReviewTransition) {
+      try {
+        const { pushNotifyAsync } = await import("./push-notifications-X7E7GSC7.js");
+        const event = input.status === "needs_review" ? "review_ready" : "task_complete";
+        pushNotifyAsync({
+          event,
+          title: `${String(row.assigned_to)} completed: ${String(row.title).slice(0, 80)}`,
+          body: input.result ? String(input.result).slice(0, 500) : `Task "${String(row.title)}" is ${input.status}.`,
+          agent: String(row.assigned_to),
+          project: String(row.project_name)
+        });
+      } catch {
+      }
+    }
+    await markTaskNotificationsRead(taskFile);
+    if (isCompletionReviewTransition && !isCoordinator && row.reviewer) {
+      try {
+        const { writeNotification: writeNotification2 } = await import("./notifications-U3NJYMXX.js");
+        const reviewer = String(row.reviewer);
+        await writeNotification2({
+          agentId: reviewer,
+          agentRole: isCoordinatorName(reviewer) ? "COO" : "manager",
+          event: "task_complete",
+          project: String(row.project_name),
+          summary: `"${String(row.title)}" is ready for review`,
+          taskFile,
+          sessionScope: row.session_scope ? String(row.session_scope) : void 0
+        });
+      } catch (e) {
+        process.stderr.write(`[tasks] needs_review notification failed: ${e instanceof Error ? e.message : String(e)}
+`);
+      }
+    }
+    if (input.status === "needs_review" || input.status === "done" || input.status === "closed") {
+      try {
+        await cascadeUnblock(taskId, input.baseDir, now);
+      } catch (e) {
+        process.stderr.write(`[tasks] cascade unblock failed: ${e instanceof Error ? e.message : String(e)}
+`);
+      }
+      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 (e) {
+          process.stderr.write(`[tasks] subtask completion check failed: ${e instanceof Error ? e.message : String(e)}
+`);
+        }
+      }
+    }
+  }
+  if (input.status === "cancelled") {
+    try {
+      await cascadeUnblock(taskId, input.baseDir, now);
+    } catch (e) {
+      process.stderr.write(`[tasks] cancelled cascade unblock failed: ${e instanceof Error ? e.message : String(e)}
+`);
+    }
+  }
+  if ((input.status === "needs_review" || 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 (e) {
+      process.stderr.write(`[tasks] task chaining failed: ${e instanceof Error ? e.message : String(e)}
+`);
+    }
+  }
+  return {
+    id: String(row.id),
+    title: String(row.title),
+    assignedTo: String(row.assigned_to),
+    assignedBy: String(row.assigned_by),
+    reviewer: row.reviewer !== void 0 && row.reviewer !== null ? String(row.reviewer) : null,
+    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,
+    sessionScope: row.session_scope !== void 0 && row.session_scope !== null ? String(row.session_scope) : 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);
+}
+
+export {
+  createTask,
+  updateTask,
+  deleteTask
+};