@oxgeneral/orch 0.2.4 → 0.3.0

package/dist/{orchestrator-OMU46RCE.js → chunk-2UC4SVJB.js}

@@ -1,12 +1,57 @@
-#!/usr/bin/env node
-import { DEFAULT_PROMPT_TEMPLATE, buildPromptContext } from './chunk-HNKJ4IF7.js';
-import { resolveFailureStatus, isDispatchable, isTerminal, isBlocked, resolveCompletionStatus, calculateRetryDelay } from './chunk-33QNTNR6.js';
-import { AUTONOMOUS_LABEL } from './chunk-PNE6LQRF.js';
-import { LockConflictError, WorkspaceError, TaskAlreadyRunningError, NoAgentsError } from './chunk-3TGCIXJA.js';
+import { LockConflictError, WorkspaceError, TaskAlreadyRunningError, NoAgentsError } from './chunk-IQXRQBUK.js';
+import { AUTONOMOUS_LABEL, DEFAULT_PROMPT_TEMPLATE, buildPromptContext } from './chunk-B4JQM4NU.js';
 import { dirname } from 'path';
 import fs from 'fs/promises';
 import { execFile } from 'child_process';
 
+// src/domain/transitions.ts
+var VALID_TRANSITIONS = {
+  todo: ["in_progress", "cancelled"],
+  in_progress: ["review", "retrying", "failed", "cancelled"],
+  retrying: ["in_progress", "failed", "cancelled"],
+  review: ["done", "todo", "cancelled"],
+  done: [],
+  failed: ["todo", "retrying"],
+  cancelled: ["todo"]
+};
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set(["done", "failed", "cancelled"]);
+function canTransition(from, to) {
+  return VALID_TRANSITIONS[from].includes(to);
+}
+function isTerminal(status) {
+  return TERMINAL_STATUSES.has(status);
+}
+function isDispatchable(status) {
+  return status === "todo" || status === "retrying";
+}
+function isBlocked(task, allTasks) {
+  if (task.depends_on.length === 0) return false;
+  if (allTasks instanceof Map) {
+    return task.depends_on.some((depId) => {
+      const dep = allTasks.get(depId);
+      return !dep || dep.status !== "done";
+    });
+  }
+  return task.depends_on.some((depId) => {
+    const dep = allTasks.find((t) => t.id === depId);
+    return !dep || dep.status !== "done";
+  });
+}
+function resolveFailureStatus(task) {
+  if (task.attempts < task.max_attempts) {
+    return "retrying";
+  }
+  return "failed";
+}
+function resolveCompletionStatus(task, success, _autoApprove) {
+  {
+    return "review";
+  }
+}
+function calculateRetryDelay(attempt, baseDelayMs, maxDelayMs) {
+  const delay = baseDelayMs * Math.pow(2, attempt);
+  return Math.min(delay, maxDelayMs);
+}
 function scopesOverlap(a, b) {
   if (!a?.length || !b?.length) return false;
   for (const pa of a) {
@@ -16,6 +61,54 @@ function scopesOverlap(a, b) {
   }
   return false;
 }
+function computePatternInfo(pattern) {
+  const base = pattern.split("*")[0];
+  const isFile = !base.endsWith("/");
+  const dir = isFile ? dirname(base) : "";
+  return { raw: pattern, base, isFile, dir };
+}
+var ScopeIndex = class {
+  entries;
+  constructor(scopes) {
+    this.entries = [];
+    for (const scope of scopes) {
+      if (scope?.length) {
+        for (const p of scope) {
+          this.entries.push(computePatternInfo(p));
+        }
+      }
+    }
+  }
+  /** Returns true if the given scope overlaps with any pattern in the index. */
+  overlapsAny(scope) {
+    if (!scope?.length || this.entries.length === 0) return false;
+    for (const raw of scope) {
+      const info = computePatternInfo(raw);
+      for (const entry of this.entries) {
+        if (patternsOverlapInfo(info, entry)) return true;
+      }
+    }
+    return false;
+  }
+  /** Add patterns to the index (e.g. from an approved candidate). */
+  add(scope) {
+    if (!scope?.length) return;
+    for (const p of scope) {
+      this.entries.push(computePatternInfo(p));
+    }
+  }
+  get size() {
+    return this.entries.length;
+  }
+};
+function patternsOverlapInfo(a, b) {
+  if (a.raw === b.raw) return true;
+  if (a.base.startsWith(b.base) || b.base.startsWith(a.base)) return true;
+  if (a.isFile && b.isFile) {
+    return a.dir === b.dir && a.dir !== ".";
+  }
+  return false;
+}
 function patternsOverlap(a, b) {
   if (a === b) return true;
   const aBase = a.split("*")[0];
@@ -28,29 +121,37 @@ function patternsOverlap(a, b) {
   }
   return false;
 }
+var acquireMutex = Promise.resolve();
 async function acquireLock(lockPath) {
-  const bakPath = lockPath + ".bak";
+  let release;
+  const gate = new Promise((r) => {
+    release = r;
+  });
+  const prev = acquireMutex;
+  acquireMutex = gate;
+  await prev;
+  try {
+    return await doAcquire(lockPath);
+  } finally {
+    release();
+  }
+}
+async function doAcquire(lockPath) {
   const existing = await readLockPid(lockPath);
   if (existing !== null) {
     if (isProcessAlive(existing)) {
       return { acquired: false, pid: existing };
     }
-    try {
-      await fs.rename(lockPath, bakPath);
-    } catch {
-    }
+    await fs.unlink(lockPath).catch(() => {
+    });
   }
   try {
     const fd = await fs.open(lockPath, "wx");
     await fd.writeFile(String(process.pid), "utf-8");
     await fd.close();
-    await fs.unlink(bakPath).catch(() => {
-    });
     return { acquired: true, pid: process.pid };
   } catch (err) {
     if (err.code === "EEXIST") {
-      await fs.rename(bakPath, lockPath).catch(() => {
-      });
       const pid = await readLockPid(lockPath);
       return { acquired: false, pid: pid ?? void 0 };
     }
@@ -87,7 +188,7 @@ var CachedTaskStore = class {
   }
   cache = /* @__PURE__ */ new Map();
   async list(filter) {
-    const key = filter?.status ?? "__all__";
+    const key = filter ? `${filter.status ?? ""}:${filter.goalId ?? ""}` : "__all__";
     if (this.cache.has(key)) {
       return this.cache.get(key);
     }
@@ -115,6 +216,7 @@ var CachedAgentStore = class {
     this.inner = inner;
   }
   listCache = null;
+  nameCache = /* @__PURE__ */ new Map();
   async list() {
     if (this.listCache) {
       return this.listCache;
@@ -127,18 +229,26 @@ var CachedAgentStore = class {
     return this.inner.get(id);
   }
   async getByName(name) {
-    return this.inner.getByName(name);
+    if (this.nameCache.has(name)) {
+      return this.nameCache.get(name) ?? null;
+    }
+    const result = await this.inner.getByName(name);
+    this.nameCache.set(name, result);
+    return result;
   }
   async save(agent) {
     await this.inner.save(agent);
     this.listCache = null;
+    this.nameCache.clear();
   }
   async delete(id) {
     await this.inner.delete(id);
     this.listCache = null;
+    this.nameCache.clear();
   }
   invalidate() {
     this.listCache = null;
+    this.nameCache.clear();
   }
 };
 var CachedGoalStore = class {
@@ -446,7 +556,7 @@ var Orchestrator = class {
           await this.deps.agentService.setStatus(entry.agent_id, "idle");
         }
         this.state.running = {};
-        this.state.claimed = [];
+        this.state.claimed = /* @__PURE__ */ new Set();
         this.state.pid = void 0;
         this.state.started_at = void 0;
         await this.saveState();
@@ -594,8 +704,13 @@ var Orchestrator = class {
   async reconcile() {
     const state = this.state;
     const now = Date.now();
-    for (const [taskId, entry] of Object.entries(state.running)) {
-      const taskData = await this.deps.taskStore.get(taskId);
+    const runningEntries = Object.entries(state.running);
+    const runningTaskData = await Promise.all(
+      runningEntries.map(([taskId]) => this.deps.taskStore.get(taskId))
+    );
+    for (let i = 0; i < runningEntries.length; i++) {
+      const [taskId, entry] = runningEntries[i];
+      const taskData = runningTaskData[i];
       if (!taskData || isTerminal(taskData.status)) {
         this.abortControllers.delete(taskId);
         delete state.running[taskId];
@@ -664,12 +779,16 @@ var Orchestrator = class {
         });
       }
     }
-    for (let i = state.retry_queue.length - 1; i >= 0; i--) {
-      const retry = state.retry_queue[i];
+    const dueRetries = [];
+    state.retry_queue = state.retry_queue.filter((retry) => {
       if (now >= new Date(retry.due_at).getTime()) {
-        state.retry_queue.splice(i, 1);
-        await this.dispatchTask(retry.task_id);
+        dueRetries.push(retry.task_id);
+        return false;
       }
+      return true;
+    });
+    for (const taskId of dueRetries) {
+      await this.dispatchTask(taskId);
     }
     await this.saveState();
   }
@@ -714,7 +833,8 @@ Agent role: ${role}` : `Autonomous work cycle. Agent role: ${role}`;
           description,
           assignee: agent.id,
           labels: [AUTONOMOUS_LABEL],
-          priority: 3
+          priority: 3,
+          goalId: goal?.id
         });
         anyCreated = true;
       } catch (err) {
@@ -738,8 +858,9 @@ Agent role: ${role}` : `Autonomous work cycle. Agent role: ${role}`;
     const availableSlots = maxConcurrent - currentRunning;
     if (availableSlots <= 0) return;
     const allTasks = await this.cachedTaskStore.list();
+    const taskMap = new Map(allTasks.map((t) => [t.id, t]));
     const candidates = allTasks.filter(
-      (t) => isDispatchable(t.status) && !isBlocked(t, allTasks) && !state.running[t.id] && !state.claimed.includes(t.id)
+      (t) => isDispatchable(t.status) && !isBlocked(t, taskMap) && !state.running[t.id] && !state.claimed.has(t.id)
     ).sort((a, b) => {
       const bTime = b.updated_at ?? "";
       const aTime = a.updated_at ?? "";
@@ -747,25 +868,21 @@ Agent role: ${role}` : `Autonomous work cycle. Agent role: ${role}`;
     }).slice(0, availableSlots);
     const blockedIds = /* @__PURE__ */ new Set();
     const inProgressScoped = allTasks.filter((t) => t.status === "in_progress" && t.scope?.length);
-    for (let i = 0; i < candidates.length; i++) {
-      const candidate = candidates[i];
+    const scopeIndex = new ScopeIndex(inProgressScoped.map((t) => t.scope));
+    for (const candidate of candidates) {
       if (!candidate.scope?.length) continue;
-      const approvedPeers = candidates.slice(0, i).filter((c) => !blockedIds.has(c.id));
-      const compareTo = [...inProgressScoped, ...approvedPeers];
-      let overlapping = false;
-      for (const other of compareTo) {
-        if (scopesOverlap(candidate.scope, other.scope)) {
-          this.deps.eventBus.emit({
-            type: "task:scope_overlap",
-            taskId: candidate.id,
-            overlappingTaskId: other.id,
-            patterns: candidate.scope
-          });
-          overlapping = true;
-          break;
-        }
+      if (scopeIndex.overlapsAny(candidate.scope)) {
+        const overlapper = inProgressScoped.find((t) => scopesOverlap(candidate.scope, t.scope));
+        this.deps.eventBus.emit({
+          type: "task:scope_overlap",
+          taskId: candidate.id,
+          overlappingTaskId: overlapper?.id ?? candidate.id,
+          patterns: candidate.scope
+        });
+        blockedIds.add(candidate.id);
+      } else {
+        scopeIndex.add(candidate.scope);
       }
-      if (overlapping) blockedIds.add(candidate.id);
     }
     for (const task of candidates) {
       if (blockedIds.has(task.id)) continue;
@@ -802,13 +919,13 @@ Agent role: ${role}` : `Autonomous work cycle. Agent role: ${role}`;
       throw new TaskAlreadyRunningError(taskId, entry.run_id, entry.agent_id);
     }
     const task = await this.deps.taskService.get(taskId);
-    state.claimed.push(taskId);
+    state.claimed.add(taskId);
     await this.saveState();
     try {
+      const allAgents = await this.cachedAgentStore.list();
       const agent = await this.deps.agentService.findBestAgent(task);
       if (!agent) {
-        const allAgents2 = await this.cachedAgentStore.list();
-        if (allAgents2.length === 0) {
+        if (allAgents.length === 0) {
           throw new NoAgentsError();
         }
         this.unclaim(taskId);
@@ -821,7 +938,6 @@ Agent role: ${role}` : `Autonomous work cycle. Agent role: ${role}`;
         this.deps.config
       );
       const template = this.deps.config.prompt?.template ?? DEFAULT_PROMPT_TEMPLATE;
-      const allAgents = await this.cachedAgentStore.list();
       const attempt = task.attempts + 1;
       let retryContext;
       if (attempt > 1) {
@@ -833,15 +949,35 @@ Agent role: ${role}` : `Autonomous work cycle. Agent role: ${role}`;
           };
         }
       }
-      const sharedContext = this.deps.contextStore ? await this.deps.contextStore.getAll() : void 0;
-      const pendingMessages = this.deps.messageService ? await this.deps.messageService.drainMailbox(agent.id, task.id) : [];
+      const goalId = task.goalId;
+      const [sharedContext, pendingMessages, goalRaw] = await Promise.all([
+        this.deps.contextStore?.getAll(),
+        this.deps.messageService ? this.deps.messageService.drainMailbox(agent.id, task.id) : [],
+        goalId && this.cachedGoalStore ? this.cachedGoalStore.get(goalId).catch(() => null) : null
+      ]);
+      let goalContext;
+      if (goalRaw) {
+        const allTasks = await this.cachedTaskStore.list();
+        const goalTasks = allTasks.filter((t) => t.goalId === goalId);
+        const progressEntry = await this.deps.contextStore?.get(`${goalId}-progress`);
+        const MAX_GOAL_TASK_NAMES = 30;
+        const taskNames = goalTasks.map((t) => `[${t.status}] ${t.title}`);
+        goalContext = {
+          id: goalRaw.id,
+          title: goalRaw.title,
+          description: goalRaw.description,
+          status: goalRaw.status,
+          task_names: taskNames.length > MAX_GOAL_TASK_NAMES ? [...taskNames.slice(0, MAX_GOAL_TASK_NAMES), `... and ${taskNames.length - MAX_GOAL_TASK_NAMES} more`] : taskNames,
+          progress: progressEntry?.value
+        };
+      }
       const context = buildPromptContext(
         task,
         agent,
         attempt,
         workspacePath,
         this.deps.config,
-        { allAgents, retryContext, sharedContext, feedback: task.feedback, messages: pendingMessages.length ? pendingMessages : void 0 }
+        { allAgents, retryContext, sharedContext, feedback: task.feedback, messages: pendingMessages.length ? pendingMessages : void 0, goal: goalContext }
       );
       const prompt = await this.deps.templateEngine.render(template, context);
       const run = await this.deps.runService.create({
@@ -1018,7 +1154,7 @@ Agent role: ${role}` : `Autonomous work cycle. Agent role: ${role}`;
     const agent = await this.deps.agentStore.get(agentId);
     const isAutonomousTask = task.labels?.includes(AUTONOMOUS_LABEL);
     const autoApprove = isAutonomousTask || agent?.config.approval_policy === "auto";
-    const newStatus = resolveCompletionStatus(task, true, autoApprove);
+    const newStatus = resolveCompletionStatus();
     await this.deps.runService.finish(runId, "succeeded", tokens);
     const runningEntry = state.running[taskId];
     const successRuntimeMs = runningEntry ? Date.now() - new Date(runningEntry.started_at).getTime() : 0;
@@ -1251,8 +1387,7 @@ ${task.proof?.agent_summary ?? ""}`.slice(0, 2e3),
     await this.saveState();
   }
   unclaim(taskId) {
-    const idx = this.state.claimed.indexOf(taskId);
-    if (idx !== -1) this.state.claimed.splice(idx, 1);
+    this.state.claimed.delete(taskId);
   }
   /**
    * Throw if this instance doesn't own the lock (read-only session).
@@ -1317,4 +1452,6 @@ function serializeEventData(data, maxLen) {
   return str.length > maxLen ? str.slice(0, maxLen) + "\u2026" : str;
 }
 
-export { Orchestrator };
+export { Orchestrator, canTransition, isBlocked, isDispatchable, isTerminal, resolveFailureStatus };
+//# sourceMappingURL=chunk-2UC4SVJB.js.map
+//# sourceMappingURL=chunk-2UC4SVJB.js.map