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

package/dist/src/plugin.js

@@ -2,6 +2,7 @@
 var __require = import.meta.require;
 
 // packages/supervisor-plugin/src/plugin.ts
+import { RIG_CAPABILITY_PANEL_SLOT, RIG_SUPERVISOR_PANEL_ID } from "@rig/contracts";
 import { definePlugin } from "@rig/core/config";
 
 // packages/supervisor-plugin/src/closureStage.ts
@@ -36,17 +37,18 @@ 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
 };
 
 // packages/supervisor-plugin/src/awaiter.ts
@@ -85,6 +87,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";
@@ -154,7 +411,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 {
@@ -197,8 +459,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] } : {},
@@ -219,8 +480,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);
@@ -250,6 +510,26 @@ var supervisorCliCommands = [
   }
 ];
 
+// packages/supervisor-plugin/src/panel.ts
+import { RIG_RUN_STOP_PANEL_ACTION } from "@rig/contracts";
+function buildSupervisorPanelPayload(context) {
+  const status = context.folded.status ?? "unknown";
+  const taskId = context.folded.record.taskId ?? context.taskIdAtStart;
+  const operatorActive = status === "running" || status === "validating" || status === "closing-out" || status === "needs-attention";
+  return {
+    status,
+    currentTask: taskId ? { id: taskId, title: context.runDisplayTitle } : null,
+    processed: context.folded.closeoutPhases.length,
+    succeeded: context.folded.closeoutPhases.filter((phase) => phase.outcome === "completed").length,
+    failed: context.folded.closeoutPhases.filter((phase) => phase.outcome === "failed").length,
+    skipped: 0,
+    plannedOrder: taskId ? [{ id: taskId, title: context.runDisplayTitle, status }] : [],
+    idleReason: operatorActive ? null : status,
+    stopActionId: operatorActive ? RIG_RUN_STOP_PANEL_ACTION : null,
+    closures: []
+  };
+}
+
 // packages/supervisor-plugin/src/plugin.ts
 var SUPERVISOR_PLUGIN_NAME = "@rig/supervisor-plugin";
 var supervisorPlugin = definePlugin({
@@ -262,16 +542,20 @@ var supervisorPlugin = definePlugin({
       { id: "supervisor.loop", title: "Supervisor loop", commandId: SUPERVISOR_LOOP_CLI_ID },
       { id: "supervisor.unblock", title: "Supervisor unblock", commandId: SUPERVISOR_UNBLOCK_CLI_ID }
     ],
-    cliCommands: supervisorCliCommands.map(({ run: _run, ...metadata }) => metadata),
-    stageMutations: [supervisorClosureStageMutation]
+    cliCommands: supervisorCliCommands,
+    panels: [
+      {
+        id: RIG_SUPERVISOR_PANEL_ID,
+        slot: RIG_CAPABILITY_PANEL_SLOT,
+        title: "Supervisor",
+        capabilityId: "run.supervisor",
+        description: "Live run status, closeout progress, and operator stop control.",
+        produce: (context) => buildSupervisorPanelPayload(context)
+      }
+    ],
+    stageMutations: [supervisorClosureStageMutation],
+    stages: [{ ...supervisorClosureStage, run: createDefaultSupervisorClosureStage() }]
   }
-}, {
-  stages: { [SUPERVISOR_CLOSURE_STAGE_ID]: createDefaultSupervisorClosureStage() },
-  featureCapabilities: [
-    { id: "supervisor.loop", title: "Supervisor loop", commandId: SUPERVISOR_LOOP_CLI_ID },
-    { id: "supervisor.unblock", title: "Supervisor unblock", commandId: SUPERVISOR_UNBLOCK_CLI_ID }
-  ],
-  cliCommands: supervisorCliCommands
 });
 function createSupervisorPlugin() {
   return supervisorPlugin;

package/dist/src/supervisor.d.ts

@@ -1,5 +1,5 @@
 import type { BlockerClassification, RunId, RunStatus, SupervisorEvent, SupervisorSelectionPolicy, SupervisorStopReason, TaskClosureSummary, TaskSummary } from "@rig/contracts";
-import { type TaskDependencyBadgeSummary } from "@rig/core/task-graph";
+import { type TaskDependencyBadgeSummary } from "@rig/contracts";
 export interface SupervisorActiveRun {
     readonly taskId: TaskSummary["id"];
     readonly runId: RunId;

package/dist/src/supervisor.js

@@ -4,9 +4,9 @@ import {
   computeTaskDependencyBadges,
   disjointScope,
   isTaskTerminalStatus,
-  rankReadyTasks,
   readTaskScope
-} from "@rig/core/task-graph";
+} from "@rig/contracts";
+import { rankReadyTasks } from "@rig/dependency-graph-plugin";
 var DEFAULT_STOP_WHEN = new Set(["all-done", "all-human-blocked", "source-error"]);
 var HUMAN_BLOCKER_CLASS = {
   "not-blocked": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@h-rig/supervisor-plugin",
-  "version": "0.0.6-alpha.154",
+  "version": "0.0.6-alpha.156",
   "type": "module",
   "description": "First-party autonomous supervisor loop plugin for Rig.",
   "license": "UNLICENSED",
@@ -41,9 +41,12 @@
   "module": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",
   "dependencies": {
-    "@rig/client": "npm:@h-rig/client@0.0.6-alpha.154",
-    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.154",
-    "@rig/core": "npm:@h-rig/core@0.0.6-alpha.154",
+    "@rig/blocker-classifier-plugin": "npm:@h-rig/blocker-classifier-plugin@0.0.6-alpha.156",
+    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.156",
+    "@rig/runtime": "npm:@h-rig/runtime@0.0.6-alpha.156",
+    "@rig/core": "npm:@h-rig/core@0.0.6-alpha.156",
+    "@rig/dependency-graph-plugin": "npm:@h-rig/dependency-graph-plugin@0.0.6-alpha.156",
+    "@rig/run-worker": "npm:@h-rig/run-worker@0.0.6-alpha.156",
     "effect": "4.0.0-beta.90"
   }
 }