@oxgeneral/orch 0.2.0

package/dist/orchestrator-VGYKSOZJ.js

@@ -0,0 +1,1292 @@
+#!/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, TaskAlreadyRunningError, NoAgentsError } from './chunk-O5AO5QIR.js';
+import { dirname } from 'path';
+import fs from 'fs/promises';
+import { execFile } from 'child_process';
+
+function scopesOverlap(a, b) {
+  if (!a?.length || !b?.length) return false;
+  for (const pa of a) {
+    for (const pb of b) {
+      if (patternsOverlap(pa, pb)) return true;
+    }
+  }
+  return false;
+}
+function patternsOverlap(a, b) {
+  if (a === b) return true;
+  const aBase = a.split("*")[0];
+  const bBase = b.split("*")[0];
+  if (aBase.startsWith(bBase) || bBase.startsWith(aBase)) return true;
+  if (!aBase.endsWith("/") && !bBase.endsWith("/")) {
+    const aDir = dirname(aBase);
+    const bDir = dirname(bBase);
+    return aDir === bDir && aDir !== ".";
+  }
+  return false;
+}
+async function acquireLock(lockPath) {
+  const bakPath = lockPath + ".bak";
+  const existing = await readLockPid(lockPath);
+  if (existing !== null) {
+    if (isProcessAlive(existing)) {
+      return { acquired: false, pid: existing };
+    }
+    try {
+      await fs.rename(lockPath, bakPath);
+    } 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 };
+    }
+    throw err;
+  }
+}
+async function releaseLock(lockPath) {
+  await fs.unlink(lockPath).catch(() => {
+  });
+}
+async function readLockPid(lockPath) {
+  try {
+    const content = await fs.readFile(lockPath, "utf-8");
+    const pid = parseInt(content.trim(), 10);
+    return isNaN(pid) ? null : pid;
+  } catch {
+    return null;
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    if (err.code === "EPERM") return true;
+    return false;
+  }
+}
+
+// src/infrastructure/storage/cached-stores.ts
+var CachedTaskStore = class {
+  constructor(inner) {
+    this.inner = inner;
+  }
+  cache = /* @__PURE__ */ new Map();
+  async list(filter) {
+    const key = filter?.status ?? "__all__";
+    if (this.cache.has(key)) {
+      return this.cache.get(key);
+    }
+    const result = await this.inner.list(filter);
+    this.cache.set(key, result);
+    return result;
+  }
+  async get(id) {
+    return this.inner.get(id);
+  }
+  async save(task) {
+    await this.inner.save(task);
+    this.cache.clear();
+  }
+  async delete(id) {
+    await this.inner.delete(id);
+    this.cache.clear();
+  }
+  invalidate() {
+    this.cache.clear();
+  }
+};
+var CachedAgentStore = class {
+  constructor(inner) {
+    this.inner = inner;
+  }
+  listCache = null;
+  async list() {
+    if (this.listCache) {
+      return this.listCache;
+    }
+    const result = await this.inner.list();
+    this.listCache = result;
+    return result;
+  }
+  async get(id) {
+    return this.inner.get(id);
+  }
+  async getByName(name) {
+    return this.inner.getByName(name);
+  }
+  async save(agent) {
+    await this.inner.save(agent);
+    this.listCache = null;
+  }
+  async delete(id) {
+    await this.inner.delete(id);
+    this.listCache = null;
+  }
+  invalidate() {
+    this.listCache = null;
+  }
+};
+var CachedGoalStore = class {
+  constructor(inner) {
+    this.inner = inner;
+  }
+  cache = /* @__PURE__ */ new Map();
+  async list(filter) {
+    const key = filter?.status ?? "__all__";
+    if (this.cache.has(key)) return this.cache.get(key);
+    const result = await this.inner.list(filter);
+    this.cache.set(key, result);
+    return result;
+  }
+  async get(id) {
+    return this.inner.get(id);
+  }
+  async save(goal) {
+    await this.inner.save(goal);
+    this.cache.clear();
+  }
+  async delete(id) {
+    await this.inner.delete(id);
+    this.cache.clear();
+  }
+  invalidate() {
+    this.cache.clear();
+  }
+};
+var CRITERION_COMMANDS = {
+  test_pass: { cmd: "npm", args: ["test"] },
+  typecheck: { cmd: "npx", args: ["tsc", "--noEmit"] },
+  lint: { cmd: "npm", args: ["run", "lint"] }
+};
+var ReviewRunner = class {
+  cwd;
+  timeoutMs;
+  constructor(options) {
+    this.cwd = options.cwd;
+    this.timeoutMs = options.timeout_ms ?? 12e4;
+  }
+  /**
+   * Run all criteria and return results.
+   * Continues running even if one criterion fails.
+   */
+  async runAll(criteria) {
+    const results = [];
+    for (const criterion of criteria) {
+      const result = await this.runCriterion(criterion);
+      results.push(result);
+    }
+    return results;
+  }
+  /**
+   * Check if all results passed.
+   */
+  static allPassed(results) {
+    return results.length > 0 && results.every((r) => r.passed);
+  }
+  /**
+   * Format results into a human-readable report.
+   */
+  static formatReport(results) {
+    const lines = results.map((r) => {
+      const icon = r.passed ? "\u2713" : "\u2717";
+      const truncated = r.output.slice(0, 500);
+      return `${icon} ${r.criterion}: ${r.passed ? "PASSED" : "FAILED"}
+  ${truncated}`;
+    });
+    return lines.join("\n\n");
+  }
+  runCriterion(criterion) {
+    const { cmd, args } = CRITERION_COMMANDS[criterion];
+    return new Promise((resolve) => {
+      execFile(
+        cmd,
+        args,
+        { cwd: this.cwd, timeout: this.timeoutMs, maxBuffer: 1024 * 1024 },
+        (error, stdout, stderr) => {
+          const output = (stdout + "\n" + stderr).trim();
+          resolve({
+            criterion,
+            passed: !error,
+            output: output.slice(0, 2e3)
+          });
+        }
+      );
+    });
+  }
+};
+
+// src/application/orchestrator.ts
+var MAX_EVENT_DATA_LEN = 8192;
+var MAX_BUS_DATA_LEN = 4096;
+var Orchestrator = class {
+  constructor(deps) {
+    this.deps = deps;
+    this.cachedTaskStore = new CachedTaskStore(deps.taskStore);
+    this.cachedAgentStore = new CachedAgentStore(deps.agentStore);
+    this.cachedGoalStore = deps.goalStore ? new CachedGoalStore(deps.goalStore) : null;
+  }
+  intervalId = null;
+  shuttingDown = false;
+  state = null;
+  abortControllers = /* @__PURE__ */ new Map();
+  cachedTaskStore;
+  cachedAgentStore;
+  cachedGoalStore;
+  saveStateTimer = null;
+  saveStateDirty = false;
+  lockAcquired = false;
+  consecutiveTickFailures = 0;
+  maxConsecutiveTickFailures = 5;
+  maxRetryQueueSize = 100;
+  signalHandlers = [];
+  immediateDispatchTimer = null;
+  taskCreatedUnsub = null;
+  tickInProgress = false;
+  /** Promise-chain mutex to serialize critical state mutations. */
+  stateMutex = Promise.resolve();
+  /**
+   * Check if this instance owns the lock (can mutate state).
+   */
+  get isOwner() {
+    return this.lockAcquired;
+  }
+  /**
+   * Serialize access to state mutations via a Promise-chain mutex.
+   * Prevents concurrent tick/stop/reconcile from reading stale state.
+   */
+  withStateLock(fn) {
+    let release;
+    const next = new Promise((resolve) => {
+      release = resolve;
+    });
+    const prev = this.stateMutex;
+    this.stateMutex = next;
+    return prev.then(async () => {
+      try {
+        return await fn();
+      } finally {
+        release();
+      }
+    });
+  }
+  /**
+   * Run a single task by ID. Acquires lock for the duration of the run.
+   */
+  async runTask(taskId) {
+    await this.withTemporaryLock(async () => {
+      await this.loadState();
+      await this.dispatchTask(taskId);
+    });
+  }
+  /**
+   * Run all dispatchable tasks. Acquires lock for the duration of the run.
+   */
+  async runAll() {
+    await this.withTemporaryLock(async () => {
+      await this.loadState();
+      await this.dispatchAll();
+    });
+  }
+  /**
+   * Acquire lock, run fn, then release lock.
+   * Used by single-shot commands (runTask, runAll) that don't go through startWatch.
+   */
+  async withTemporaryLock(fn) {
+    const lockResult = await acquireLock(this.deps.lockPath);
+    if (!lockResult.acquired) {
+      throw new LockConflictError(lockResult.pid);
+    }
+    this.lockAcquired = true;
+    try {
+      await fn();
+    } finally {
+      this.lockAcquired = false;
+      await releaseLock(this.deps.lockPath);
+    }
+  }
+  /**
+   * Start watch mode — continuous tick loop.
+   * Acquires a PID lock to prevent multiple orchestrators.
+   */
+  async startWatch() {
+    const lockResult = await acquireLock(this.deps.lockPath);
+    if (!lockResult.acquired) {
+      throw new LockConflictError(lockResult.pid);
+    }
+    this.lockAcquired = true;
+    await this.loadState();
+    this.state.pid = process.pid;
+    this.state.started_at = (/* @__PURE__ */ new Date()).toISOString();
+    await this.saveState();
+    this.registerSignalHandlers();
+    this.taskCreatedUnsub = this.deps.eventBus.on("task:created", () => {
+      this.scheduleImmediateDispatch();
+    });
+    await this.tick();
+    this.intervalId = setInterval(
+      () => this.tick().then(
+        () => {
+          this.consecutiveTickFailures = 0;
+        },
+        (err) => {
+          this.consecutiveTickFailures++;
+          const error = err instanceof Error ? err.message : String(err);
+          this.deps.eventBus.emit({
+            type: "orchestrator:error",
+            error,
+            context: "tick",
+            fatal: this.consecutiveTickFailures >= this.maxConsecutiveTickFailures
+          });
+          if (this.consecutiveTickFailures >= this.maxConsecutiveTickFailures) {
+            this.deps.eventBus.emit({
+              type: "orchestrator:shutdown",
+              reason: `${this.consecutiveTickFailures} consecutive tick failures`
+            });
+            this.stop().catch((err2) => {
+              this.deps.eventBus.emit({ type: "orchestrator:error", error: err2 instanceof Error ? err2.message : String(err2), context: "stop after consecutive tick failures", fatal: false });
+            });
+          }
+        }
+      ),
+      this.deps.config.scheduling.poll_interval_ms
+    );
+  }
+  /**
+   * Register SIGINT/SIGTERM handlers for graceful shutdown.
+   */
+  registerSignalHandlers() {
+    const handler = (signal) => {
+      this.deps.eventBus.emit({
+        type: "orchestrator:shutdown",
+        reason: `Received ${signal}`
+      });
+      this.stop().catch((err) => {
+        this.deps.eventBus.emit({ type: "orchestrator:error", error: err instanceof Error ? err.message : String(err), context: `stop after ${signal} signal`, fatal: false });
+      });
+    };
+    for (const sig of ["SIGINT", "SIGTERM"]) {
+      const bound = () => handler(sig);
+      this.signalHandlers.push([sig, bound]);
+      process.on(sig, bound);
+    }
+  }
+  /**
+   * Remove signal handlers to avoid listener leaks.
+   */
+  removeSignalHandlers() {
+    for (const [sig, handler] of this.signalHandlers) {
+      process.removeListener(sig, handler);
+    }
+    this.signalHandlers = [];
+  }
+  /**
+   * Stop the watch loop and clean up.
+   */
+  async stop() {
+    if (this.shuttingDown) return;
+    this.shuttingDown = true;
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    if (this.taskCreatedUnsub) {
+      this.taskCreatedUnsub();
+      this.taskCreatedUnsub = null;
+    }
+    if (this.immediateDispatchTimer) {
+      clearTimeout(this.immediateDispatchTimer);
+      this.immediateDispatchTimer = null;
+    }
+    await this.flushStateLazy();
+    await this.withStateLock(async () => {
+      if (this.state) {
+        for (const [taskId, entry] of Object.entries(this.state.running)) {
+          this.abortControllers.get(taskId)?.abort();
+          this.abortControllers.delete(taskId);
+          await this.deps.processManager.killWithGrace(entry.pid);
+          await this.deps.runService.finish(entry.run_id, "cancelled");
+          const task = await this.deps.taskStore.get(taskId);
+          if (task) {
+            await this.deps.taskService.updateStatus(taskId, resolveFailureStatus(task));
+          }
+          await this.deps.agentService.setStatus(entry.agent_id, "idle");
+        }
+        this.state.running = {};
+        this.state.claimed = [];
+        this.state.pid = void 0;
+        this.state.started_at = void 0;
+        await this.saveState();
+      }
+    });
+    if (this.lockAcquired) {
+      await releaseLock(this.deps.lockPath);
+      this.lockAcquired = false;
+    }
+    this.removeSignalHandlers();
+  }
+  /**
+   * Cancel a running task: kill agent process, clean state, mark cancelled.
+   * Acquires lock if not already owned (standalone CLI invocation).
+   */
+  async cancelTask(taskId) {
+    if (!this.lockAcquired) {
+      return this.withTemporaryLock(() => this.cancelTask(taskId));
+    }
+    await this.withStateLock(async () => {
+      await this.loadState();
+      const state = this.state;
+      const entry = state.running[taskId];
+      if (entry) {
+        this.abortControllers.get(taskId)?.abort();
+        this.abortControllers.delete(taskId);
+        await this.deps.processManager.killWithGrace(entry.pid, 3e3).catch((err) => {
+          this.deps.eventBus.emit({ type: "orchestrator:error", error: err instanceof Error ? err.message : String(err), context: `cancelTask kill process ${entry.pid} for task ${taskId}`, fatal: false });
+        });
+        await this.deps.runService.finish(entry.run_id, "cancelled").catch((err) => {
+          this.deps.eventBus.emit({ type: "orchestrator:error", error: err instanceof Error ? err.message : String(err), context: `cancelTask finish run ${entry.run_id}`, fatal: false });
+        });
+        await this.deps.agentService.setStatus(entry.agent_id, "idle").catch((err) => {
+          this.deps.eventBus.emit({ type: "orchestrator:error", error: err instanceof Error ? err.message : String(err), context: `cancelTask setStatus idle for agent ${entry.agent_id}`, fatal: false });
+        });
+        delete state.running[taskId];
+        await this.saveState();
+      }
+      state.retry_queue = state.retry_queue.filter((r) => r.task_id !== taskId);
+      try {
+        await this.deps.taskService.cancel(taskId);
+      } catch {
+        try {
+          await this.deps.taskService.updateStatus(taskId, "cancelled");
+        } catch {
+        }
+      }
+      await this.saveState();
+    });
+  }
+  /**
+   * Force-stop a specific agent: kill process, clean state, release agent.
+   * Acquires lock if not already owned (standalone CLI invocation).
+   */
+  async forceStopAgent(agentId) {
+    if (!this.lockAcquired) {
+      return this.withTemporaryLock(() => this.forceStopAgent(agentId));
+    }
+    await this.withStateLock(async () => {
+      await this.loadState();
+      const state = this.state;
+      for (const [taskId, entry] of Object.entries(state.running)) {
+        if (entry.agent_id === agentId) {
+          this.abortControllers.get(taskId)?.abort();
+          this.abortControllers.delete(taskId);
+          await this.deps.processManager.killWithGrace(entry.pid, 3e3);
+          await this.deps.runService.finish(entry.run_id, "cancelled");
+          try {
+            await this.deps.taskService.updateStatus(taskId, "failed");
+          } catch {
+          }
+          delete state.running[taskId];
+        }
+      }
+      await this.deps.agentService.setStatus(agentId, "idle");
+      await this.saveState();
+    });
+  }
+  /**
+   * Single tick: Reconcile → Dispatch → Collect
+   * Serialized via mutex to prevent concurrent ticks from racing on state.
+   */
+  async tick() {
+    if (this.shuttingDown) return;
+    this.tickInProgress = true;
+    try {
+      await this.withStateLock(async () => {
+        if (this.shuttingDown) return;
+        this.cachedTaskStore.invalidate();
+        this.cachedAgentStore.invalidate();
+        this.cachedGoalStore?.invalidate();
+        await this.loadState();
+        await this.reconcile();
+        await this.seedAutonomousTasks();
+        await this.dispatchAll();
+        const tasks = await this.cachedTaskStore.list();
+        const running = Object.keys(this.state.running).length;
+        const queued = tasks.filter((t) => isDispatchable(t.status)).length;
+        this.deps.eventBus.emit({
+          type: "orchestrator:tick",
+          running,
+          queued
+        });
+      });
+    } finally {
+      this.tickInProgress = false;
+    }
+  }
+  /**
+   * Schedule an immediate dispatch with 500ms debounce.
+   * Called on task:created to avoid waiting for the next 30s tick.
+   */
+  scheduleImmediateDispatch() {
+    if (this.shuttingDown) return;
+    if (this.immediateDispatchTimer) return;
+    this.immediateDispatchTimer = setTimeout(() => {
+      this.immediateDispatchTimer = null;
+      if (this.shuttingDown || this.tickInProgress) return;
+      this.immediateDispatch().catch((err) => {
+        this.deps.eventBus.emit({
+          type: "orchestrator:error",
+          error: err instanceof Error ? err.message : String(err),
+          context: "immediate dispatch on task:created",
+          fatal: false
+        });
+      });
+    }, 500);
+  }
+  /**
+   * Mini-tick: invalidate caches → loadState → dispatchAll → saveState.
+   * Skips reconcile/collect — only dispatches new tasks immediately.
+   */
+  async immediateDispatch() {
+    if (this.shuttingDown) return;
+    await this.withStateLock(async () => {
+      if (this.shuttingDown) return;
+      this.cachedTaskStore.invalidate();
+      this.cachedAgentStore.invalidate();
+      await this.loadState();
+      await this.dispatchAll();
+      await this.saveState();
+    });
+  }
+  /**
+   * Reconcile: check PID liveness, detect stalls, process retry queue.
+   */
+  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);
+      if (!taskData || isTerminal(taskData.status)) {
+        this.abortControllers.delete(taskId);
+        delete state.running[taskId];
+        await this.deps.agentService.setStatus(entry.agent_id, "idle").catch((err) => {
+          this.deps.eventBus.emit({ type: "orchestrator:error", error: err instanceof Error ? err.message : String(err), context: `reconcile setStatus idle for stale agent ${entry.agent_id} (task ${taskId})`, fatal: false });
+        });
+        continue;
+      }
+      if (!this.deps.processManager.isAlive(entry.pid)) {
+        try {
+          await this._handleRunFailure(taskId, entry, "Process crashed unexpectedly");
+        } catch {
+          delete state.running[taskId];
+          await this.deps.agentService.setStatus(entry.agent_id, "idle").catch((err) => {
+            this.deps.eventBus.emit({ type: "orchestrator:error", error: err instanceof Error ? err.message : String(err), context: `reconcile crash fallback setStatus idle for agent ${entry.agent_id} (task ${taskId})`, fatal: false });
+          });
+        }
+        continue;
+      }
+      const lastEventAt = new Date(entry.last_event_at).getTime();
+      const stallTimeout = this.deps.config.defaults.agent.stall_timeout_ms;
+      if (now - lastEventAt > stallTimeout) {
+        this.deps.eventBus.emit({
+          type: "orchestrator:stall_detected",
+          runId: entry.run_id
+        });
+        this.abortControllers.get(taskId)?.abort();
+        await this.deps.processManager.killWithGrace(entry.pid, 5e3);
+        try {
+          await this._handleRunFailure(taskId, entry, "Agent stalled (no events)");
+        } catch {
+          delete state.running[taskId];
+          await this.deps.agentService.setStatus(entry.agent_id, "idle").catch((err) => {
+            this.deps.eventBus.emit({ type: "orchestrator:error", error: err instanceof Error ? err.message : String(err), context: `reconcile stall fallback setStatus idle for agent ${entry.agent_id} (task ${taskId})`, fatal: false });
+          });
+        }
+      }
+    }
+    const runningAgentIds = new Set(Object.values(state.running).map((e) => e.agent_id));
+    const allAgents = await this.cachedAgentStore.list();
+    for (const agent of allAgents) {
+      if (agent.status === "running" && !runningAgentIds.has(agent.id)) {
+        await this.deps.agentService.setStatus(agent.id, "idle");
+      }
+    }
+    const allTasks = await this.cachedTaskStore.list();
+    for (const task of allTasks) {
+      if (task.status === "in_progress" && !state.running[task.id]) {
+        try {
+          await this.deps.taskService.updateStatus(task.id, "failed");
+        } catch {
+          task.status = "failed";
+          task.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+          await this.deps.taskStore.save(task).catch((err) => {
+            this.deps.eventBus.emit({
+              type: "orchestrator:error",
+              error: err instanceof Error ? err.message : String(err),
+              context: `force-write orphaned task ${task.id}`,
+              fatal: false
+            });
+          });
+        }
+        this.deps.eventBus.emit({
+          type: "task:orphaned",
+          taskId: task.id
+        });
+      }
+    }
+    for (let i = state.retry_queue.length - 1; i >= 0; i--) {
+      const retry = state.retry_queue[i];
+      if (now >= new Date(retry.due_at).getTime()) {
+        state.retry_queue.splice(i, 1);
+        await this.dispatchTask(retry.task_id);
+      }
+    }
+    await this.saveState();
+  }
+  /**
+   * Create tasks for autonomous agents that have no active work.
+   *
+   * Priority: active Goals assigned to the agent come first.
+   * If no goals, falls back to role-based autonomous work.
+   */
+  async seedAutonomousTasks() {
+    const agents = await this.cachedAgentStore.list();
+    const autonomousAgents = agents.filter(
+      (a) => a.autonomous && a.status === "idle"
+    );
+    if (autonomousAgents.length === 0) return;
+    const allTasks = await this.cachedTaskStore.list();
+    const activeGoals = this.cachedGoalStore ? await this.cachedGoalStore.list({ status: "active" }) : [];
+    let anyCreated = false;
+    const claimedGoalIds = /* @__PURE__ */ new Set();
+    for (const agent of autonomousAgents) {
+      const hasActiveTask = allTasks.some(
+        (t) => t.assignee === agent.id && !isTerminal(t.status)
+      );
+      if (hasActiveTask) continue;
+      const goal = activeGoals.find(
+        (g) => g.assignee === agent.id && !claimedGoalIds.has(g.id)
+      ) ?? activeGoals.find(
+        (g) => !g.assignee && !claimedGoalIds.has(g.id)
+      );
+      if (goal) claimedGoalIds.add(goal.id);
+      const role = agent.role ?? "general assistant";
+      const title = goal ? `[auto] ${agent.name}: ${goal.title.slice(0, 60)}` : `[auto] ${agent.name}: ${role.slice(0, 60)}`;
+      const description = goal ? `## GOAL (highest priority)
+
+${goal.description || goal.title}
+
+---
+Agent role: ${role}` : `Autonomous work cycle. Agent role: ${role}`;
+      try {
+        await this.deps.taskService.create({
+          title,
+          description,
+          assignee: agent.id,
+          labels: [AUTONOMOUS_LABEL],
+          priority: 3
+        });
+        anyCreated = true;
+      } catch (err) {
+        this.deps.eventBus.emit({
+          type: "orchestrator:error",
+          error: err instanceof Error ? err.message : String(err),
+          context: `autonomous task for agent ${agent.id}`,
+          fatal: false
+        });
+      }
+    }
+    if (anyCreated) this.cachedTaskStore.invalidate();
+  }
+  /**
+   * Dispatch all dispatchable tasks up to max_concurrent_agents.
+   */
+  async dispatchAll() {
+    const state = this.state;
+    const maxConcurrent = this.deps.config.scheduling.max_concurrent_agents;
+    const currentRunning = Object.keys(state.running).length;
+    const availableSlots = maxConcurrent - currentRunning;
+    if (availableSlots <= 0) return;
+    const allTasks = await this.cachedTaskStore.list();
+    const candidates = allTasks.filter(
+      (t) => isDispatchable(t.status) && !isBlocked(t, allTasks) && !state.running[t.id] && !state.claimed.includes(t.id)
+    ).sort((a, b) => {
+      const bTime = b.updated_at ?? "";
+      const aTime = a.updated_at ?? "";
+      return bTime < aTime ? -1 : bTime > aTime ? 1 : 0;
+    }).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];
+      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 (overlapping) blockedIds.add(candidate.id);
+    }
+    for (const task of candidates) {
+      if (blockedIds.has(task.id)) continue;
+      try {
+        await this.dispatchTask(task.id);
+      } catch (err) {
+        this.deps.eventBus.emit({
+          type: "orchestrator:error",
+          error: err instanceof Error ? err.message : String(err),
+          context: `dispatch task ${task.id}`,
+          fatal: false
+        });
+      }
+    }
+  }
+  /**
+   * Dispatch a single task: claim → assign → execute.
+   */
+  async dispatchTask(taskId) {
+    const state = this.state;
+    if (state.running[taskId]) {
+      const entry = state.running[taskId];
+      throw new TaskAlreadyRunningError(taskId, entry.run_id, entry.agent_id);
+    }
+    const task = await this.deps.taskService.get(taskId);
+    state.claimed.push(taskId);
+    await this.saveState();
+    try {
+      const agent = await this.deps.agentService.findBestAgent(task);
+      if (!agent) {
+        const allAgents2 = await this.cachedAgentStore.list();
+        if (allAgents2.length === 0) {
+          throw new NoAgentsError();
+        }
+        this.unclaim(taskId);
+        await this.saveState();
+        return;
+      }
+      const { path: workspacePath, branch: worktreeBranch } = await this.deps.workspaceManager.prepare(
+        task,
+        agent,
+        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) {
+        const failedData = await this.deps.runService.getLastFailedRunContext(task.id);
+        if (failedData) {
+          retryContext = {
+            previous_error: failedData.error,
+            previous_output: failedData.output
+          };
+        }
+      }
+      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 context = buildPromptContext(
+        task,
+        agent,
+        attempt,
+        workspacePath,
+        this.deps.config,
+        { allAgents, retryContext, sharedContext, feedback: task.feedback, messages: pendingMessages.length ? pendingMessages : void 0 }
+      );
+      const prompt = await this.deps.templateEngine.render(template, context);
+      const run = await this.deps.runService.create({
+        taskId: task.id,
+        agentId: agent.id,
+        attempt,
+        prompt,
+        workspacePath
+      });
+      if (task.status === "failed" || task.status === "cancelled") {
+        await this.deps.taskService.retry(taskId);
+        task.status = "todo";
+        task.attempts = 0;
+      }
+      await this.deps.taskService.updateStatus(taskId, "in_progress");
+      await this.deps.taskService.assign(taskId, agent.id);
+      await this.deps.taskService.incrementAttempts(taskId);
+      if (worktreeBranch) {
+        task.proof = { ...task.proof ?? { files_changed: [] }, branch: worktreeBranch };
+        task.workspace = workspacePath;
+        await this.deps.taskStore.save(task);
+      }
+      await this.deps.agentService.setStatus(agent.id, "running");
+      const agentData = await this.deps.agentService.get(agent.id);
+      agentData.current_task = taskId;
+      await this.deps.agentStore.save(agentData);
+      const adapter = this.deps.adapterRegistry.require(agent.adapter);
+      const abortController = new AbortController();
+      this.abortControllers.set(taskId, abortController);
+      const handle = adapter.execute({
+        prompt,
+        workspace: workspacePath,
+        env: {
+          ...agent.config.env,
+          ORCH_AGENT_ID: agent.id,
+          ORCH_AGENT_NAME: agent.name,
+          ORCH_TASK_ID: task.id
+        },
+        config: agentData.config,
+        signal: abortController.signal
+      });
+      const agentPid = handle.pid;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      await this.deps.runService.start(run.id, agentPid);
+      this.unclaim(taskId);
+      state.running[taskId] = {
+        run_id: run.id,
+        agent_id: agent.id,
+        task_id: taskId,
+        pid: agentPid,
+        started_at: now,
+        last_event_at: now
+      };
+      await this.saveState();
+      this.collectEvents(
+        handle.events,
+        run.id,
+        taskId,
+        agent.id
+      ).catch((err) => {
+        this.deps.eventBus.emit({
+          type: "orchestrator:error",
+          error: err instanceof Error ? err.message : String(err),
+          context: `adapter execution for ${taskId}`,
+          fatal: false
+        });
+      });
+    } catch (err) {
+      this.unclaim(taskId);
+      await this.saveState();
+      throw err;
+    }
+  }
+  /**
+   * Collect events from an adapter's async generator.
+   */
+  async collectEvents(generator, runId, taskId, agentId) {
+    let collectedTokens;
+    let resultText;
+    let lastAgentMessage;
+    const filesChangedSet = /* @__PURE__ */ new Set();
+    try {
+      for await (const event of generator) {
+        if (this.shuttingDown) break;
+        if (event.type === "done") {
+          if (event.tokens) collectedTokens = event.tokens;
+          const data = event.data;
+          if (data && typeof data.result === "string") {
+            resultText = data.result;
+          }
+        }
+        if (event.type === "output") {
+          const data = event.data;
+          if (data) {
+            const text = typeof data.text === "string" ? data.text : typeof data.message === "string" ? data.message : void 0;
+            if (text?.trim()) lastAgentMessage = text;
+          }
+        }
+        if (event.type === "file_change") {
+          const data = event.data;
+          if (data && Array.isArray(data.paths)) {
+            for (const p of data.paths) {
+              if (typeof p === "string") filesChangedSet.add(p);
+            }
+          } else {
+            const filePath = data && typeof data.path === "string" ? data.path : typeof event.data === "string" ? event.data : String(event.data);
+            filesChangedSet.add(filePath);
+          }
+        }
+        const eventTimestamp = isValidISOTimestamp(event.timestamp) ? event.timestamp : (/* @__PURE__ */ new Date()).toISOString();
+        const serialized = serializeEventData(event.data, MAX_EVENT_DATA_LEN);
+        event.data = void 0;
+        const runEvent = {
+          timestamp: eventTimestamp,
+          type: event.type === "output" ? "agent_output" : event.type === "file_change" ? "file_changed" : event.type === "command" ? "command_run" : event.type === "tool_call" ? "tool_call" : event.type === "error" ? "error" : "done",
+          data: serialized
+        };
+        await this.deps.runService.appendEvent(runId, runEvent);
+        if (this.state?.running[taskId]) {
+          this.state.running[taskId].last_event_at = eventTimestamp;
+          this.saveStateLazy();
+        }
+        const busData = serializeEventData(serialized, MAX_BUS_DATA_LEN);
+        if (event.type === "output" || event.type === "tool_call") {
+          this.deps.eventBus.emit({
+            type: "agent:output",
+            runId,
+            agentId,
+            data: busData
+          });
+        } else if (event.type === "file_change") {
+          this.deps.eventBus.emit({
+            type: "agent:file_changed",
+            runId,
+            agentId,
+            path: typeof event.data === "string" ? event.data : String(event.data)
+          });
+        } else if (event.type === "error") {
+          this.deps.eventBus.emit({
+            type: "agent:error",
+            runId,
+            agentId,
+            error: busData
+          });
+        }
+      }
+      const finalResult = resultText ?? lastAgentMessage;
+      await this.handleRunSuccess(taskId, runId, agentId, collectedTokens, finalResult, [...filesChangedSet]);
+    } catch (err) {
+      const error = err instanceof Error ? err.message : String(err);
+      const entry = this.state?.running[taskId];
+      if (entry) {
+        await this.handleRunFailure(taskId, entry, error);
+      }
+    }
+  }
+  async handleRunSuccess(taskId, runId, agentId, tokens, resultText, filesChanged) {
+    return this.withStateLock(() => this._handleRunSuccess(taskId, runId, agentId, tokens, resultText, filesChanged));
+  }
+  async _handleRunSuccess(taskId, runId, agentId, tokens, resultText, filesChanged) {
+    await this.flushStateLazy();
+    this.abortControllers.delete(taskId);
+    const state = this.state;
+    if (!state.running[taskId]) return;
+    const task = await this.deps.taskStore.get(taskId);
+    if (!task) return;
+    task.proof = {
+      ...task.proof,
+      agent_summary: resultText?.slice(0, 2e3) ?? task.proof?.agent_summary,
+      files_changed: filesChanged?.length ? filesChanged : task.proof?.files_changed ?? []
+    };
+    delete task.feedback;
+    await this.deps.taskStore.save(task);
+    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);
+    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;
+    if (runningEntry) {
+      state.stats.total_runtime_ms += successRuntimeMs;
+    }
+    delete state.running[taskId];
+    const statsUpdate = {
+      tasks_completed: (agent?.stats.tasks_completed ?? 0) + 1,
+      total_runs: (agent?.stats.total_runs ?? 0) + 1,
+      total_runtime_ms: (agent?.stats.total_runtime_ms ?? 0) + successRuntimeMs
+    };
+    if (tokens) {
+      statsUpdate.tokens_used = (agent?.stats.tokens_used ?? 0) + tokens.total;
+    }
+    await this.deps.agentService.updateStats(agentId, statsUpdate).catch((err) => {
+      this.deps.eventBus.emit({
+        type: "orchestrator:error",
+        error: err instanceof Error ? err.message : String(err),
+        context: `agent stats update for ${agentId}`,
+        fatal: false
+      });
+    });
+    state.stats.total_tasks_completed++;
+    state.stats.total_runs++;
+    if (tokens) {
+      state.stats.total_tokens.input += tokens.input;
+      state.stats.total_tokens.output += tokens.output;
+      state.stats.total_tokens.total = state.stats.total_tokens.input + state.stats.total_tokens.output;
+    }
+    if (task.proof?.branch) {
+      try {
+        const mergeResult = await this.deps.workspaceManager.mergeBack(task.proof.branch);
+        if (mergeResult.success) {
+          this.deps.eventBus.emit({
+            type: "workspace:merge_succeeded",
+            taskId,
+            branch: task.proof.branch
+          });
+          await this.deps.workspaceManager.cleanup(taskId).catch((err) => {
+            this.deps.eventBus.emit({
+              type: "orchestrator:error",
+              error: err instanceof Error ? err.message : String(err),
+              context: `workspace cleanup for ${taskId}`,
+              fatal: false
+            });
+          });
+        } else {
+          this.deps.eventBus.emit({
+            type: "workspace:merge_conflict",
+            taskId,
+            branch: task.proof.branch,
+            conflictInfo: mergeResult.conflictInfo
+          });
+          await this.forceTaskToReview(task, agentId, `MERGE CONFLICT: ${mergeResult.conflictInfo}`);
+          return;
+        }
+      } catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        await this.forceTaskToReview(task, agentId, `MERGE ERROR: ${error}`);
+        return;
+      }
+    }
+    try {
+      await this.deps.taskService.updateStatus(taskId, newStatus);
+    } catch (validationErr) {
+      const error = validationErr instanceof Error ? validationErr.message : String(validationErr);
+      this.deps.eventBus.emit({
+        type: "orchestrator:error",
+        error,
+        context: `state machine validation failed for task ${taskId} -> ${newStatus}, force-writing`,
+        fatal: false
+      });
+      task.status = newStatus;
+      task.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+      await this.deps.taskStore.save(task).catch((saveErr) => {
+        this.deps.eventBus.emit({
+          type: "orchestrator:error",
+          error: saveErr instanceof Error ? saveErr.message : String(saveErr),
+          context: `force-write task ${taskId} to store failed`,
+          fatal: false
+        });
+      });
+    }
+    await this.deps.agentService.setStatus(agentId, "idle").catch((err) => {
+      this.deps.eventBus.emit({ type: "orchestrator:error", error: err instanceof Error ? err.message : String(err), context: `_handleRunSuccess setStatus idle for agent ${agentId}`, fatal: false });
+    });
+    const agentAfter = await this.deps.agentStore.get(agentId);
+    if (agentAfter) {
+      agentAfter.current_task = void 0;
+      await this.deps.agentStore.save(agentAfter);
+    }
+    if (newStatus === "review" && task.review_criteria?.length) {
+      await this.runAutoReview(taskId, task.review_criteria, task.workspace ?? this.deps.projectRoot);
+    } else if (newStatus === "review" && autoApprove) {
+      await this.deps.taskService.updateStatus(taskId, "done");
+    }
+    await this.saveState();
+    this.scheduleImmediateDispatch();
+  }
+  async handleRunFailure(taskId, entry, error) {
+    return this.withStateLock(() => this._handleRunFailure(taskId, entry, error));
+  }
+  async _handleRunFailure(taskId, entry, error) {
+    await this.flushStateLazy();
+    this.abortControllers.delete(taskId);
+    const state = this.state;
+    const task = await this.deps.taskStore.get(taskId);
+    if (!task) return;
+    await this.deps.runService.finish(entry.run_id, "failed", void 0, error);
+    await this.deps.agentService.setStatus(entry.agent_id, "idle");
+    const agentAfterIdle = await this.deps.agentStore.get(entry.agent_id);
+    if (agentAfterIdle) {
+      agentAfterIdle.current_task = void 0;
+      await this.deps.agentStore.save(agentAfterIdle);
+    }
+    const agent = await this.deps.agentStore.get(entry.agent_id);
+    const runtimeMs = Date.now() - new Date(entry.started_at).getTime();
+    await this.deps.agentService.updateStats(entry.agent_id, {
+      tasks_failed: (agent?.stats.tasks_failed ?? 0) + 1,
+      total_runs: (agent?.stats.total_runs ?? 0) + 1,
+      total_runtime_ms: (agent?.stats.total_runtime_ms ?? 0) + runtimeMs
+    });
+    const failureStatus = resolveFailureStatus(task);
+    await this.deps.taskService.updateStatus(taskId, failureStatus);
+    if (failureStatus === "retrying") {
+      const delay = calculateRetryDelay(
+        task.attempts - 1,
+        this.deps.config.scheduling.retry_base_delay_ms,
+        this.deps.config.scheduling.retry_max_delay_ms
+      );
+      const alreadyQueued = state.retry_queue.some((r) => r.task_id === taskId);
+      if (!alreadyQueued) {
+        if (state.retry_queue.length >= this.maxRetryQueueSize) {
+          state.retry_queue.shift();
+        }
+        state.retry_queue.push({
+          task_id: taskId,
+          attempt: task.attempts + 1,
+          due_at: new Date(Date.now() + delay).toISOString(),
+          error
+        });
+      }
+      this.deps.eventBus.emit({
+        type: "run:retry",
+        runId: entry.run_id,
+        attempt: task.attempts + 1,
+        delay_ms: delay
+      });
+    } else {
+      state.stats.total_tasks_failed++;
+    }
+    state.stats.total_runtime_ms += runtimeMs;
+    delete state.running[taskId];
+    state.stats.total_runs++;
+    await this.saveState();
+    this.scheduleImmediateDispatch();
+  }
+  /**
+   * Run automatic review criteria on a task in 'review' status.
+   * If all criteria pass, transition review → done.
+   * If any fail, stay in review with results attached.
+   */
+  async runAutoReview(taskId, criteria, cwd) {
+    const runner = new ReviewRunner({ cwd });
+    const results = await runner.runAll(criteria);
+    const allPassed = ReviewRunner.allPassed(results);
+    const task = await this.deps.taskStore.get(taskId);
+    if (!task) return;
+    task.review_results = results;
+    task.proof = {
+      ...task.proof,
+      test_results: ReviewRunner.formatReport(results),
+      files_changed: task.proof?.files_changed ?? []
+    };
+    await this.deps.taskStore.save(task);
+    this.deps.eventBus.emit({
+      type: "task:auto_reviewed",
+      taskId,
+      passed: allPassed,
+      results
+    });
+    if (allPassed) {
+      try {
+        await this.deps.taskService.updateStatus(taskId, "done");
+      } catch (validationErr) {
+        const error = validationErr instanceof Error ? validationErr.message : String(validationErr);
+        this.deps.eventBus.emit({
+          type: "orchestrator:error",
+          error,
+          context: `auto-review transition failed for task ${taskId} -> done, force-writing`,
+          fatal: false
+        });
+        task.status = "done";
+        task.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+        await this.deps.taskStore.save(task).catch((saveErr) => {
+          this.deps.eventBus.emit({
+            type: "orchestrator:error",
+            error: saveErr instanceof Error ? saveErr.message : String(saveErr),
+            context: `force-write task ${taskId} to store failed (auto-review)`,
+            fatal: false
+          });
+        });
+      }
+    }
+  }
+  /**
+   * Force a task to 'review' status with a summary prefix.
+   * Used when merge-back fails (conflict or infrastructure error).
+   */
+  async forceTaskToReview(task, agentId, summaryPrefix) {
+    task.proof = {
+      ...task.proof,
+      agent_summary: `${summaryPrefix}
+
+${task.proof?.agent_summary ?? ""}`.slice(0, 2e3),
+      files_changed: task.proof?.files_changed ?? []
+    };
+    task.status = "review";
+    task.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+    await this.deps.taskStore.save(task);
+    await this.deps.agentService.setStatus(agentId, "idle").catch((err) => {
+      this.deps.eventBus.emit({ type: "orchestrator:error", error: err instanceof Error ? err.message : String(err), context: `forceTaskToReview setStatus idle for agent ${agentId}`, fatal: false });
+    });
+    const agentAfter = await this.deps.agentStore.get(agentId);
+    if (agentAfter) {
+      agentAfter.current_task = void 0;
+      await this.deps.agentStore.save(agentAfter);
+    }
+    await this.saveState();
+  }
+  unclaim(taskId) {
+    const idx = this.state.claimed.indexOf(taskId);
+    if (idx !== -1) this.state.claimed.splice(idx, 1);
+  }
+  /**
+   * Throw if this instance doesn't own the lock (read-only session).
+   */
+  requireOwnership() {
+    if (!this.lockAcquired) {
+      throw new LockConflictError(0);
+    }
+  }
+  async loadState() {
+    this.state = await this.deps.stateStore.read();
+  }
+  async saveState() {
+    if (this.state) {
+      await this.deps.stateStore.write(this.state);
+    }
+  }
+  /**
+   * Debounced saveState — batches rapid writes within 500ms window.
+   * Used for non-critical updates like last_event_at in collectEvents.
+   */
+  saveStateLazy() {
+    this.saveStateDirty = true;
+    if (this.saveStateTimer) return;
+    this.saveStateTimer = setTimeout(() => {
+      this.saveStateTimer = null;
+      if (this.saveStateDirty) {
+        this.saveStateDirty = false;
+        this.saveState().catch((err) => {
+          this.deps.eventBus.emit({
+            type: "orchestrator:error",
+            error: err instanceof Error ? err.message : String(err),
+            context: "debounced state save",
+            fatal: false
+          });
+        });
+      }
+    }, 500);
+  }
+  /**
+   * Flush any pending debounced saveState immediately.
+   * Call before critical transitions to ensure state is persisted.
+   */
+  async flushStateLazy() {
+    if (this.saveStateTimer) {
+      clearTimeout(this.saveStateTimer);
+      this.saveStateTimer = null;
+    }
+    if (this.saveStateDirty) {
+      this.saveStateDirty = false;
+      await this.saveState();
+    }
+  }
+};
+function isValidISOTimestamp(value) {
+  if (typeof value !== "string") return false;
+  const d = new Date(value);
+  return !isNaN(d.getTime()) && d.toISOString() === value;
+}
+function serializeEventData(data, maxLen) {
+  const str = typeof data === "string" ? data : JSON.stringify(data);
+  return str.length > maxLen ? str.slice(0, maxLen) + "\u2026" : str;
+}
+
+export { Orchestrator };