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

package/dist/src/index.js

@@ -81,18 +81,329 @@ 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/loop.ts
+import { computeTaskDependencyBadges, toTaskDependencyProjection } from "@rig/contracts";
+import { rankReadyTasks, selectRankedReadyTasks } from "@rig/dependency-graph-plugin";
+
+// packages/supervisor-plugin/src/journal.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { dirname } from "path";
+import { Schema } from "effect";
+import {
+  SupervisorEvent
+} from "@rig/contracts";
+var NEWLINE = `
+`;
+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 };
+}
+function createFileSupervisorJournal(path) {
+  return {
+    async append(line) {
+      await mkdir(dirname(path), { recursive: true });
+      await writeFile(path, `${line}${NEWLINE}`, { flag: "a" });
+    },
+    async read() {
+      try {
+        return await readFile(path, "utf8");
+      } catch (error) {
+        const code = typeof error === "object" && error !== null && "code" in error ? error.code : undefined;
+        if (code === "ENOENT")
+          return "";
+        throw error;
+      }
+    }
+  };
+}
+function createInMemorySupervisorJournalStore(seed = []) {
+  const lines = seed.map((event) => JSON.stringify(event));
+  return {
+    async append(line) {
+      lines.push(line);
+    },
+    async read() {
+      return lines.join(NEWLINE);
+    }
+  };
+}
+function parseSupervisorJournal(text) {
+  return text.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line.length > 0).map((line, index) => {
+    try {
+      return Schema.decodeUnknownSync(SupervisorEvent)(JSON.parse(line));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Invalid supervisor journal line ${index + 1}: ${message}`);
+    }
+  });
+}
+function createSupervisorJournal(store) {
+  const append = async (event) => {
+    await store.append(JSON.stringify(Schema.decodeUnknownSync(SupervisorEvent)(event)));
+  };
+  const readEvents = async () => parseSupervisorJournal(await store.read());
+  const readProjection = async () => reduceSupervisorJournal(await readEvents());
+  return { append, readEvents, readProjection };
+}
+
+// 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 };
+}
+async function controlSupervisorRun(projectRoot, runId, control, deps) {
+  await deps.deliverRunControl(projectRoot, runId, control);
+  return { ok: true, runId, control: control.kind };
+}
+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";
@@ -162,7 +473,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 {
@@ -205,8 +521,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] } : {},
@@ -227,8 +542,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);
@@ -257,65 +571,31 @@ var supervisorCliCommands = [
     run: executeUnblock
   }
 ];
-// packages/supervisor-plugin/src/journal.ts
-import { mkdir, readFile, writeFile } from "fs/promises";
-import { dirname } from "path";
-import { Schema } from "effect";
-import {
-  SupervisorEvent,
-  reduceSupervisorJournal
-} from "@rig/contracts";
-var NEWLINE = `
-`;
-function createFileSupervisorJournal(path) {
-  return {
-    async append(line) {
-      await mkdir(dirname(path), { recursive: true });
-      await writeFile(path, `${line}${NEWLINE}`, { flag: "a" });
-    },
-    async read() {
-      try {
-        return await readFile(path, "utf8");
-      } catch (error) {
-        const code = typeof error === "object" && error !== null && "code" in error ? error.code : undefined;
-        if (code === "ENOENT")
-          return "";
-        throw error;
-      }
-    }
-  };
-}
-function createInMemorySupervisorJournalStore(seed = []) {
-  const lines = seed.map((event) => JSON.stringify(event));
+// 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/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 {
-    async append(line) {
-      lines.push(line);
-    },
-    async read() {
-      return lines.join(NEWLINE);
-    }
+    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: []
   };
 }
-function parseSupervisorJournal(text) {
-  return text.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line.length > 0).map((line, index) => {
-    try {
-      return Schema.decodeUnknownSync(SupervisorEvent)(JSON.parse(line));
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      throw new Error(`Invalid supervisor journal line ${index + 1}: ${message}`);
-    }
-  });
-}
-function createSupervisorJournal(store) {
-  const append = async (event) => {
-    await store.append(JSON.stringify(Schema.decodeUnknownSync(SupervisorEvent)(event)));
-  };
-  const readEvents = async () => parseSupervisorJournal(await store.read());
-  const readProjection = async () => reduceSupervisorJournal(await readEvents());
-  return { append, readEvents, readProjection };
-}
+
 // packages/supervisor-plugin/src/plugin.ts
-import { definePlugin } from "@rig/core/config";
 var SUPERVISOR_PLUGIN_NAME = "@rig/supervisor-plugin";
 var supervisorPlugin = definePlugin({
   name: SUPERVISOR_PLUGIN_NAME,
@@ -327,28 +607,32 @@ 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;
 }
 // packages/supervisor-plugin/src/supervisor.ts
 import {
-  computeTaskDependencyBadges,
+  computeTaskDependencyBadges as computeTaskDependencyBadges2,
   disjointScope,
   isTaskTerminalStatus,
-  rankReadyTasks,
   readTaskScope
-} from "@rig/core/task-graph";
+} from "@rig/contracts";
+import { rankReadyTasks as rankReadyTasks2 } 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,
@@ -370,7 +654,7 @@ function normalizeOptions(options = {}) {
     pollMs: Math.max(0, Math.floor(options.pollMs ?? 5000))
   };
 }
-function selectionMode(policy) {
+function selectionMode2(policy) {
   if (policy === "blocking-only")
     return "blocking-only";
   if (policy === "max-unblock")
@@ -431,15 +715,15 @@ async function runSupervisor(ctx, options = {}) {
       break;
     }
     const snapshot = await ctx.readTasks();
-    const badges = computeTaskDependencyBadges(snapshot.tasks);
+    const badges = computeTaskDependencyBadges2(snapshot.tasks);
     const activeRuns = snapshot.activeRuns ?? [];
-    const activeTaskIds = activeRuns.map((run) => run.taskId);
+    const activeTaskIds2 = activeRuns.map((run) => run.taskId);
     const remainingSlots = normalized.maxTasks === null ? normalized.concurrency : Math.min(normalized.concurrency, normalized.maxTasks - processed);
-    const ranked = rankReadyTasks(snapshot.tasks, {
+    const ranked = rankReadyTasks2(snapshot.tasks, {
       excludeTaskIds: completedTaskIds,
-      activeTaskIds,
+      activeTaskIds: activeTaskIds2,
       filter: (task) => filterTask(task, normalized.filter),
-      selection: selectionMode(normalized.selectionPolicy)
+      selection: selectionMode2(normalized.selectionPolicy)
     });
     const selected = [];
     const occupiedScopes = activeRuns.flatMap((run) => {
@@ -474,18 +758,18 @@ async function runSupervisor(ctx, options = {}) {
         ...handle.dispatchHandle === undefined ? {} : { dispatchHandle: handle.dispatchHandle }
       });
       const outcome = await ctx.awaitTerminal(handle.runId, entry.task);
-      const failedOutcome = terminalFailed(outcome);
+      const failedOutcome2 = terminalFailed(outcome);
       await emit({
         kind: "supervisor.outcome",
         at: now(),
         taskId: entry.task.id,
         runId: outcome.runId,
         status: outcome.status,
-        failed: failedOutcome,
+        failed: failedOutcome2,
         unblockedTaskIds: outcome.closure?.unblockedTaskIds ?? [],
         ...outcome.closure ? { closure: outcome.closure } : {}
       });
-      return { taskId: entry.task.id, status: outcome.status, failed: failedOutcome };
+      return { taskId: entry.task.id, status: outcome.status, failed: failedOutcome2 };
     }));
     for (const outcome of outcomes) {
       completedTaskIds.add(outcome.taskId);
@@ -510,10 +794,15 @@ async function runSupervisor(ctx, options = {}) {
   return { processed, succeeded, failed, skipped, idleReason };
 }
 export {
+  unblockTask,
   supervisorPlugin,
   supervisorClosureStageMutation,
+  supervisorClosureStage,
   supervisorCliCommands,
+  runSupervisorLoop,
   runSupervisor,
+  reduceSupervisorJournal,
+  planSupervisorLoop,
   parseSupervisorJournal,
   executeUnblock,
   executeLoop,
@@ -524,6 +813,7 @@ export {
   createFileSupervisorJournal,
   createDefaultSupervisorClosureStage,
   createClosureStage,
+  controlSupervisorRun,
   awaitTerminalRun,
   SUPERVISOR_UNBLOCK_CLI_ID,
   SUPERVISOR_PLUGIN_NAME,

package/dist/src/journal.d.ts

@@ -1,4 +1,12 @@
 import { SupervisorEvent, type SupervisorProjection } from "@rig/contracts";
+/**
+ * Fold a supervisor event journal into the current supervisor projection.
+ *
+ * Behavioral reducer owned by the supervisor plugin (the only consumer of the
+ * supervisor loop's read-model). `@rig/contracts` keeps the `SupervisorEvent` /
+ * `SupervisorProjection` schemas; the fold over them lives here.
+ */
+export declare function reduceSupervisorJournal(events: readonly SupervisorEvent[]): SupervisorProjection;
 export interface SupervisorJournalStore {
     append(line: string): Promise<void>;
     read(): Promise<string>;

package/dist/src/journal.js

@@ -4,11 +4,83 @@ import { mkdir, readFile, writeFile } from "fs/promises";
 import { dirname } from "path";
 import { Schema } from "effect";
 import {
-  SupervisorEvent,
-  reduceSupervisorJournal
+  SupervisorEvent
 } from "@rig/contracts";
 var NEWLINE = `
 `;
+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 };
+}
 function createFileSupervisorJournal(path) {
   return {
     async append(line) {
@@ -57,6 +129,7 @@ function createSupervisorJournal(store) {
   return { append, readEvents, readProjection };
 }
 export {
+  reduceSupervisorJournal,
   parseSupervisorJournal,
   createSupervisorJournal,
   createInMemorySupervisorJournalStore,