@h-rig/supervisor-plugin 0.0.6-alpha.155 → 0.0.6-alpha.156

package/dist/src/cli.js

@@ -37,6 +37,261 @@ async function awaitTerminalRun(options) {
   }
 }
 
+// packages/supervisor-plugin/src/loop.ts
+import { computeTaskDependencyBadges, toTaskDependencyProjection } from "@rig/contracts";
+import { rankReadyTasks, selectRankedReadyTasks } from "@rig/dependency-graph-plugin";
+
+// packages/supervisor-plugin/src/journal.ts
+import { Schema } from "effect";
+import {
+  SupervisorEvent
+} from "@rig/contracts";
+function reduceSupervisorJournal(events) {
+  let processed = 0;
+  let succeeded = 0;
+  let failed = 0;
+  let skipped = 0;
+  let current = null;
+  let idleReason = null;
+  let stopReason = null;
+  let status = "running";
+  let plannedOrder = [];
+  let selectionPolicy = null;
+  const concurrency = null;
+  const closures = [];
+  const anomalies = [];
+  for (const event of events) {
+    switch (event.kind) {
+      case "supervisor.started":
+        status = "running";
+        break;
+      case "supervisor.selection-planned":
+        plannedOrder = [...event.taskIds];
+        selectionPolicy = event.policy;
+        break;
+      case "supervisor.dispatch-started":
+        break;
+      case "supervisor.dispatch-confirmed":
+        current = { taskId: event.taskId, runId: event.runId };
+        break;
+      case "supervisor.dispatch":
+        current = { taskId: event.taskId, runId: event.runId };
+        break;
+      case "supervisor.outcome":
+        processed += 1;
+        if (event.failed) {
+          failed += 1;
+        } else {
+          succeeded += 1;
+        }
+        if (event.closure) {
+          closures.push(event.closure);
+        }
+        if (current?.runId === event.runId) {
+          current = null;
+        } else if (current !== null) {
+          anomalies.push(`outcome for ${event.runId} did not match current ${current.runId}`);
+        }
+        break;
+      case "supervisor.skipped":
+        processed += 1;
+        skipped += 1;
+        break;
+      case "supervisor.idle":
+        status = "idle";
+        idleReason = event.reason;
+        break;
+      case "supervisor.stopped":
+        status = "stopped";
+        stopReason = event.reason;
+        current = null;
+        break;
+      case "supervisor.finished":
+        status = "finished";
+        processed = event.processed;
+        succeeded = event.succeeded;
+        failed = event.failed;
+        skipped = event.skipped ?? skipped;
+        idleReason = event.idleReason;
+        current = null;
+        break;
+    }
+  }
+  return { status, processed, succeeded, failed, skipped, current, plannedOrder, selectionPolicy, concurrency, idleReason, stopReason, closures, anomalies };
+}
+
+// packages/supervisor-plugin/src/loop.ts
+import { classifyTasks, isHumanBlockerClass } from "@rig/blocker-classifier-plugin";
+function selectionMode(policy) {
+  return policy === "blocking-only" || policy === "max-unblock" ? policy : "all-ready";
+}
+function at(deps) {
+  return deps.now ? deps.now() : new Date().toISOString();
+}
+function activeTaskIds(runs) {
+  const terminal = new Set(["completed", "failed", "stopped", "stale"]);
+  return new Set(runs.filter((run) => run.taskId && run.live && !run.stale && !terminal.has(run.status)).map((run) => run.taskId));
+}
+function stopReasonForNoCandidates(tasks, runs) {
+  if (tasks.length === 0)
+    return "all-done";
+  const classifications = classifyTasks(tasks, runs).classifications;
+  const nonTerminal = tasks.map(toTaskDependencyProjection).filter((task) => task.status !== "closed" && task.status !== "completed" && task.status !== "cancelled");
+  if (nonTerminal.length > 0 && nonTerminal.every((task) => {
+    const classification = classifications.find((entry) => entry.taskId === task.id);
+    return classification ? isHumanBlockerClass(classification.blockerClass) : false;
+  }))
+    return "all-human-blocked";
+  return "all-done";
+}
+async function planSupervisorLoop(projectRoot, deps, options = {}) {
+  const [tasks, runs] = await Promise.all([
+    deps.listTasks(projectRoot),
+    deps.listRuns ? deps.listRuns(projectRoot) : Promise.resolve([])
+  ]);
+  const projected = tasks.map(toTaskDependencyProjection);
+  const excluded = new Set(options.excludeTaskIds ?? []);
+  const candidates = options.candidateTaskIds ? new Set(options.candidateTaskIds) : null;
+  const ranked = rankReadyTasks(projected, {
+    activeTaskIds: activeTaskIds(runs),
+    excludeTaskIds: excluded,
+    ...candidates ? { filter: (task) => candidates.has(task.id) } : {},
+    selection: selectionMode(options.selectionPolicy)
+  });
+  const limit = Math.max(0, options.maxTasks ?? ranked.length);
+  const selected = selectRankedReadyTasks(projected, {
+    activeTaskIds: activeTaskIds(runs),
+    excludeTaskIds: excluded,
+    ...candidates ? { filter: (task) => candidates.has(task.id) } : {},
+    selection: selectionMode(options.selectionPolicy),
+    requireDisjointScopes: (options.concurrency ?? 1) > 1,
+    limit
+  });
+  const plannedOrder = selected.map((task) => task.id);
+  return {
+    plannedOrder,
+    ranked: ranked.filter((entry) => plannedOrder.includes(entry.task.id)),
+    idleReason: plannedOrder.length === 0 ? stopReasonForNoCandidates(tasks, runs) : null
+  };
+}
+function failedOutcome(outcome) {
+  if (typeof outcome.failed === "boolean")
+    return outcome.failed;
+  return outcome.status === "failed" || outcome.status === "stopped" || outcome.status === "needs-attention" || outcome.status === "waiting-approval" || outcome.status === "waiting-user-input";
+}
+function runStatus(value) {
+  switch (value) {
+    case "created":
+    case "queued":
+    case "preparing":
+    case "running":
+    case "waiting-approval":
+    case "waiting-user-input":
+    case "paused":
+    case "validating":
+    case "reviewing":
+    case "closing-out":
+    case "needs-attention":
+    case "completed":
+    case "failed":
+    case "stopped":
+      return value;
+    default:
+      return "failed";
+  }
+}
+async function runSupervisorLoop(projectRoot, deps, options = {}) {
+  const events = [{ kind: "supervisor.started", at: at(deps), options }];
+  const maxTasks = Math.max(0, options.maxTasks ?? Number.POSITIVE_INFINITY);
+  const concurrency = Math.max(1, options.concurrency ?? 1);
+  let processed = 0;
+  let succeeded = 0;
+  let failed = 0;
+  let skipped = 0;
+  const plannedAll = [];
+  const dispatchedTaskIds = new Set(options.excludeTaskIds ?? []);
+  while (processed < maxTasks) {
+    const plan = await planSupervisorLoop(projectRoot, deps, { ...options, excludeTaskIds: dispatchedTaskIds, maxTasks: Math.min(concurrency, maxTasks - processed) });
+    if (plan.plannedOrder.length === 0) {
+      events.push({ kind: "supervisor.idle", at: at(deps), reason: plan.idleReason ?? "all-done" });
+      break;
+    }
+    events.push({ kind: "supervisor.selection-planned", at: at(deps), taskIds: plan.plannedOrder, policy: options.selectionPolicy ?? "rank" });
+    plannedAll.push(...plan.plannedOrder);
+    if (options.dryRun)
+      break;
+    const dispatchTask = deps.dispatch ?? deps.dispatchRun;
+    if (!dispatchTask)
+      throw new Error("runSupervisorLoop requires dispatch when dryRun is false.");
+    if (!deps.awaitRunTerminal)
+      throw new Error("runSupervisorLoop requires awaitRunTerminal when dryRun is false.");
+    for (const entry of plan.ranked) {
+      const taskId = entry.task.id;
+      events.push({ kind: "supervisor.dispatch-started", at: at(deps), taskId, score: entry.score });
+      const dispatch = await dispatchTask({
+        projectRoot,
+        taskId: entry.task.id,
+        ...entry.task.title !== undefined ? { title: entry.task.title } : {},
+        ...options.model !== undefined ? { model: options.model } : {},
+        ...options.force !== undefined ? { force: options.force } : {}
+      });
+      dispatchedTaskIds.add(entry.task.id);
+      const runId = dispatch.runId;
+      events.push({ kind: "supervisor.dispatch-confirmed", at: at(deps), taskId, runId });
+      const outcome = await deps.awaitRunTerminal(projectRoot, dispatch.runId, entry.task.id);
+      const outcomeFailed = failedOutcome(outcome);
+      if (outcomeFailed)
+        failed += 1;
+      else
+        succeeded += 1;
+      processed += 1;
+      events.push({
+        kind: "supervisor.outcome",
+        at: at(deps),
+        taskId,
+        runId,
+        status: runStatus(outcome.status),
+        failed: outcomeFailed,
+        unblockedTaskIds: [...outcome.unblockedTaskIds ?? []]
+      });
+      if (options.failFast && outcomeFailed || options.pauseOnAttention && outcomeFailed) {
+        events.push({ kind: "supervisor.idle", at: at(deps), reason: outcome.status === "needs-attention" || outcome.status === "waiting-approval" || outcome.status === "waiting-user-input" ? "judge-stop" : "source-error" });
+        processed = maxTasks;
+        break;
+      }
+      if (processed >= maxTasks)
+        break;
+    }
+  }
+  const projectionBeforeFinish = reduceSupervisorJournal(events);
+  const idleReason = projectionBeforeFinish.idleReason ?? (processed >= maxTasks && Number.isFinite(maxTasks) ? "max-tasks" : null);
+  events.push({ kind: "supervisor.finished", at: at(deps), processed, succeeded, failed, skipped, idleReason });
+  const projection = reduceSupervisorJournal(events);
+  return { ok: failed === 0, dryRun: options.dryRun === true, plannedOrder: plannedAll, events, projection };
+}
+function collectBlockingClosure(taskId, badges) {
+  const closure = new Set;
+  const visit = (currentTaskId) => {
+    for (const blockerId of badges.get(currentTaskId)?.blockedBy ?? []) {
+      if (closure.has(blockerId))
+        continue;
+      closure.add(blockerId);
+      visit(blockerId);
+    }
+  };
+  visit(taskId);
+  return closure;
+}
+async function unblockTask(projectRoot, taskId, deps, options = {}) {
+  if (taskId === null)
+    return runSupervisorLoop(projectRoot, deps, { ...options, selectionPolicy: "max-unblock", maxTasks: 1 });
+  const tasks = await deps.listTasks(projectRoot);
+  const projected = tasks.map(toTaskDependencyProjection);
+  const badges = computeTaskDependencyBadges(projected);
+  const blockers = collectBlockingClosure(taskId, badges);
+  return runSupervisorLoop(projectRoot, deps, { ...options, candidateTaskIds: blockers, selectionPolicy: "rank", maxTasks: 1 });
+}
+
 // packages/supervisor-plugin/src/cli.ts
 var SUPERVISOR_LOOP_CLI_ID = "supervisor.loop";
 var SUPERVISOR_UNBLOCK_CLI_ID = "supervisor.unblock";
@@ -106,7 +361,12 @@ function delay(ms) {
   return promise;
 }
 async function loadSupervisorClient() {
-  return await import("@rig/client");
+  const [taskIo, runIo, dispatchIo] = await Promise.all([
+    import("@rig/core/task-io"),
+    import("@rig/run-worker/runs"),
+    import("@rig/runtime/control-plane/dispatch")
+  ]);
+  return { listTasks: taskIo.listTasks, listRuns: runIo.listRuns, dispatchRun: dispatchIo.dispatchRun };
 }
 function supervisorDeps(timeoutMs) {
   return {
@@ -149,8 +409,7 @@ async function executeLoop(context, args) {
   const stopWhen = takeOption(task.rest, "--stop-when");
   const timeout = takeOption(stopWhen.rest, "--timeout-ms");
   requireNoExtraArgs(timeout.rest, "rig loop [--task <id>] [--max-tasks <n>] [--concurrency <n>] [--stop-when <csv>] [--dry-run] [--json]");
-  const { runSupervisorLoop } = await loadSupervisorClient();
-  const result = await runSupervisorLoop(context.projectRoot, supervisorDeps(parsePositiveInt(timeout.value, "--timeout-ms", 1800000)), {
+  const result = await runSupervisorLoop(context.projectRoot, supervisorDeps(parsePositiveInt(timeout.value, "--timeout-ms", 30 * 60 * 1000)), {
     maxTasks: parsePositiveInt(maxTasks.value, "--max-tasks", 1),
     concurrency: parsePositiveInt(concurrency.value, "--concurrency", 1),
     ...task.value ? { candidateTaskIds: [task.value] } : {},
@@ -171,8 +430,7 @@ async function executeUnblock(context, args) {
   const timeout = takeOption(json.rest, "--timeout-ms");
   const taskId = timeout.rest[0]?.startsWith("-") ? undefined : timeout.rest[0];
   requireNoExtraArgs(taskId ? timeout.rest.slice(1) : timeout.rest, "rig unblock [task-id] [--dry-run] [--json]");
-  const { unblockTask } = await loadSupervisorClient();
-  const result = await unblockTask(context.projectRoot, taskId ?? null, supervisorDeps(parsePositiveInt(timeout.value, "--timeout-ms", 1800000)), { dryRun: dry.value || context.dryRun });
+  const result = await unblockTask(context.projectRoot, taskId ?? null, supervisorDeps(parsePositiveInt(timeout.value, "--timeout-ms", 30 * 60 * 1000)), { dryRun: dry.value || context.dryRun });
   if (context.outputMode === "text") {
     if (json.value)
       printJson(result);

package/dist/src/closureStage.d.ts

@@ -1,4 +1,4 @@
-import type { StageContext, StageMutation, StageResult, StageRun, TaskClosureSummary } from "@rig/contracts";
+import type { Stage, StageContext, StageMutation, StageResult, StageRun, TaskClosureSummary } from "@rig/contracts";
 export declare const SUPERVISOR_CLOSURE_STAGE_ID = "supervisor-closure-observer";
 export interface ClosureSummaryPort {
     summarize(ctx: StageContext): Promise<TaskClosureSummary | null> | TaskClosureSummary | null;
@@ -19,4 +19,5 @@ export declare function createSupervisorClosureStage(): StageRun;
  * supervisor projection's `closures` are populated by real closeouts.
  */
 export declare function createDefaultSupervisorClosureStage(): StageRun;
+export declare const supervisorClosureStage: Stage;
 export declare const supervisorClosureStageMutation: StageMutation;

package/dist/src/closureStage.js

@@ -46,20 +46,22 @@ function createDefaultSupervisorClosureStage() {
     return { kind: "continue", ctx };
   };
 }
+var supervisorClosureStage = {
+  id: SUPERVISOR_CLOSURE_STAGE_ID,
+  kind: "observe",
+  after: ["source-closeout"],
+  before: ["journal-append"],
+  priority: 0,
+  protected: false
+};
 var supervisorClosureStageMutation = {
   op: "insert",
   contributedBy: "@rig/supervisor-plugin",
-  stage: {
-    id: SUPERVISOR_CLOSURE_STAGE_ID,
-    kind: "observe",
-    after: ["source-closeout"],
-    before: ["journal-append"],
-    priority: 0,
-    protected: false
-  }
+  stage: supervisorClosureStage
 };
 export {
   supervisorClosureStageMutation,
+  supervisorClosureStage,
   createSupervisorClosureStage,
   createDefaultSupervisorClosureStage,
   createClosureStage,

package/dist/src/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./awaiter";
 export * from "./closureStage";
 export * from "./cli";
+export * from "./loop";
 export * from "./journal";
 export * from "./plugin";
 export * from "./supervisor";