@h-rig/supervisor-plugin 0.0.6-alpha.157 → 0.0.6-alpha.159

package/dist/src/cli.js

@@ -1,45 +1,455 @@
 // @bun
-var __require = import.meta.require;
-
-// packages/supervisor-plugin/src/awaiter.ts
-var TERMINAL_RUN_STATUSES = {
-  created: false,
-  queued: false,
-  preparing: false,
-  running: false,
-  "waiting-approval": false,
-  "waiting-user-input": false,
-  paused: false,
-  validating: false,
-  reviewing: false,
-  "closing-out": false,
-  "needs-attention": true,
-  completed: true,
-  failed: true,
-  stopped: true
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
 };
-async function awaitTerminalRun(options) {
-  const startedAt = Date.now();
-  const pollMs = Math.max(0, Math.floor(options.pollMs ?? 5000));
-  while (true) {
-    const snapshot = await options.readStatus(options.runId);
-    if (snapshot && TERMINAL_RUN_STATUSES[snapshot.status]) {
-      return {
-        runId: options.runId,
-        status: snapshot.status,
-        failed: snapshot.status !== "completed"
-      };
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// packages/supervisor-plugin/src/run-status.ts
+function coerceRunStatus(value, fallback) {
+  return KNOWN_RUN_STATUS.has(value) ? value : fallback;
+}
+var KNOWN_RUN_STATUS;
+var init_run_status = __esm(() => {
+  KNOWN_RUN_STATUS = new Set([
+    "created",
+    "queued",
+    "preparing",
+    "running",
+    "validating",
+    "reviewing",
+    "closing-out",
+    "completed",
+    "failed",
+    "stopped"
+  ]);
+});
+
+// packages/supervisor-plugin/src/analysis/taskGraphPrimitives.ts
+import {
+  OPERATOR_INACTIVE_RUN_STATUSES
+} from "@rig/contracts";
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readStringList(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.length > 0) : [];
+}
+function unique(values) {
+  return Array.from(new Set(values));
+}
+function readTaskMetadataStringList(task, key) {
+  const taskRecord = task;
+  const topLevel = readStringList(taskRecord[key]);
+  if (topLevel.length > 0)
+    return topLevel;
+  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
+  const metadataList = readStringList(metadata?.[key]);
+  if (metadataList.length > 0)
+    return metadataList;
+  if (key === "dependencies") {
+    return readStringList(metadata?.deps);
+  }
+  return [];
+}
+function readTaskBlockingDependencyRefs(task) {
+  return readTaskMetadataStringList(task, "dependencies");
+}
+function readTaskSourceIssueId(task) {
+  if (typeof task.sourceIssueId === "string" && task.sourceIssueId.length > 0) {
+    return task.sourceIssueId;
+  }
+  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
+  if (typeof metadata?.sourceIssueId === "string" && metadata.sourceIssueId.length > 0) {
+    return metadata.sourceIssueId;
+  }
+  const rigMetadata = isObjectRecord(metadata?._rig) ? metadata._rig : null;
+  return typeof rigMetadata?.sourceIssueId === "string" && rigMetadata.sourceIssueId.length > 0 ? rigMetadata.sourceIssueId : null;
+}
+function readTaskScope(task) {
+  const taskRecord = task;
+  const topLevel = readStringList(taskRecord.scope);
+  if (topLevel.length > 0)
+    return unique(topLevel.map((entry) => entry.trim()).filter((entry) => entry.length > 0));
+  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
+  const metadataScope = readStringList(metadata?.scope);
+  if (metadataScope.length > 0)
+    return unique(metadataScope.map((entry) => entry.trim()).filter((entry) => entry.length > 0));
+  return unique([
+    ...readStringList(metadata?.files),
+    ...readStringList(metadata?.paths)
+  ].map((entry) => entry.trim()).filter((entry) => entry.length > 0));
+}
+function resolveTaskReference(ref, tasksById, taskIdByExternalRef, taskIdBySourceIssueId) {
+  if (tasksById.has(ref))
+    return ref;
+  return taskIdBySourceIssueId.get(ref) ?? taskIdByExternalRef.get(ref) ?? null;
+}
+function buildTaskReferenceIndex(tasks) {
+  return {
+    tasksById: new Map(tasks.map((task) => [task.id, task])),
+    taskIdByExternalRef: new Map(tasks.flatMap((task) => task.externalId ? [[task.externalId, task.id]] : [])),
+    taskIdBySourceIssueId: new Map(tasks.flatMap((task) => {
+      const sourceIssueId = readTaskSourceIssueId(task);
+      return sourceIssueId ? [[sourceIssueId, task.id]] : [];
+    }))
+  };
+}
+function computeTaskBlockingDepths(tasks) {
+  const { tasksById, taskIdByExternalRef, taskIdBySourceIssueId } = buildTaskReferenceIndex(tasks);
+  const memo = new Map;
+  const visit = (taskId, stack) => {
+    const cached = memo.get(taskId);
+    if (cached !== undefined)
+      return cached;
+    if (stack.has(taskId))
+      return 0;
+    const task = tasksById.get(taskId);
+    if (!task)
+      return 0;
+    stack.add(taskId);
+    const blockers = readTaskBlockingDependencyRefs(task).map((ref) => resolveTaskReference(ref, tasksById, taskIdByExternalRef, taskIdBySourceIssueId)).filter((ref) => ref !== null && ref !== taskId);
+    const depth = blockers.length === 0 ? 0 : Math.max(...blockers.map((blockerId) => visit(blockerId, stack) + 1));
+    stack.delete(taskId);
+    memo.set(taskId, depth);
+    return depth;
+  };
+  for (const task of tasks) {
+    visit(task.id, new Set);
+  }
+  return memo;
+}
+function isTaskTerminalStatus(status) {
+  switch (status) {
+    case "closed":
+    case "completed":
+    case "done":
+    case "cancelled":
+    case "canceled":
+      return true;
+    default:
+      return false;
+  }
+}
+function isTaskBlockedStatus(status) {
+  return status === "blocked";
+}
+function isTaskRunnableStatus(status) {
+  if (status === null || status === undefined || status === "")
+    return true;
+  if (isTaskTerminalStatus(status) || isTaskBlockedStatus(status))
+    return false;
+  switch (status) {
+    case "ready":
+    case "open":
+    case "failed":
+      return true;
+    default:
+      return false;
+  }
+}
+function computeTaskDependencyBadges(tasks) {
+  const index = buildTaskReferenceIndex(tasks);
+  const blockingDepths = computeTaskBlockingDepths(tasks);
+  const dependencyIdsByTask = new Map;
+  const unresolvedRefsByTask = new Map;
+  const blocksByTask = new Map;
+  for (const task of tasks) {
+    const dependencyIds = [];
+    const unresolvedRefs = [];
+    for (const ref of readTaskBlockingDependencyRefs(task)) {
+      const dependencyId = resolveTaskReference(ref, index.tasksById, index.taskIdByExternalRef, index.taskIdBySourceIssueId);
+      if (dependencyId && dependencyId !== task.id) {
+        dependencyIds.push(dependencyId);
+        const blocks = blocksByTask.get(dependencyId);
+        if (blocks) {
+          blocks.push(task.id);
+        } else {
+          blocksByTask.set(dependencyId, [task.id]);
+        }
+      } else {
+        unresolvedRefs.push(ref);
+      }
     }
-    if (options.timeoutMs !== undefined && Date.now() - startedAt >= options.timeoutMs) {
-      return { runId: options.runId, status: "needs-attention", failed: true };
+    dependencyIdsByTask.set(task.id, unique(dependencyIds));
+    unresolvedRefsByTask.set(task.id, unique(unresolvedRefs));
+  }
+  const summaries = new Map;
+  for (const task of tasks) {
+    const dependencyIds = dependencyIdsByTask.get(task.id) ?? [];
+    const unresolvedDependencyRefs = unresolvedRefsByTask.get(task.id) ?? [];
+    const blockedBy = dependencyIds.filter((dependencyId) => {
+      const dependency = index.tasksById.get(dependencyId);
+      return dependency ? !isTaskTerminalStatus(dependency.status) : false;
+    });
+    const blocks = unique(blocksByTask.get(task.id) ?? []);
+    const blocked = isTaskBlockedStatus(task.status) || blockedBy.length > 0;
+    const ready = isTaskRunnableStatus(task.status) && !blocked;
+    const badges = [];
+    if (blocked) {
+      badges.push({
+        kind: "blocked",
+        label: blockedBy.length > 0 ? `blocked \xD7${blockedBy.length}` : "blocked",
+        description: blockedBy.length > 0 ? `Waiting on ${blockedBy.join(", ")}.` : "Task source marks this task blocked.",
+        ...blockedBy.length > 0 ? { count: blockedBy.length } : {},
+        taskIds: blockedBy
+      });
+    } else if (ready) {
+      badges.push({
+        kind: "ready",
+        label: "ready",
+        description: "No open dependencies block this task."
+      });
     }
-    await options.waitForChange(pollMs);
+    if (dependencyIds.length > 0 || blocks.length > 0 || unresolvedDependencyRefs.length > 0) {
+      badges.push({
+        kind: "dependency",
+        label: `deps ${dependencyIds.length}/${blocks.length}`,
+        description: [
+          dependencyIds.length > 0 ? `Depends on ${dependencyIds.join(", ")}.` : null,
+          blocks.length > 0 ? `Blocks ${blocks.join(", ")}.` : null,
+          unresolvedDependencyRefs.length > 0 ? `Unresolved refs: ${unresolvedDependencyRefs.join(", ")}.` : null
+        ].filter((part) => part !== null).join(" "),
+        count: dependencyIds.length + blocks.length,
+        taskIds: unique([...dependencyIds, ...blocks])
+      });
+    }
+    summaries.set(task.id, {
+      taskId: task.id,
+      blockingDepth: blockingDepths.get(task.id) ?? 0,
+      dependencyIds,
+      unresolvedDependencyRefs,
+      blockedBy,
+      blocks,
+      blocked,
+      ready,
+      dependencyCount: dependencyIds.length,
+      dependentCount: blocks.length,
+      badges
+    });
   }
+  return summaries;
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.trim().length > 0).map((entry) => entry.trim()) : [];
+}
+function numberOrNull(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : null;
+}
+function metadataOf(task) {
+  return isObjectRecord(task.metadata) ? task.metadata : {};
 }
+function normalizeTaskStatus(status) {
+  const token = typeof status === "string" ? status.trim().toLowerCase() : "";
+  if (token === "done")
+    return "completed";
+  if (token === "canceled")
+    return "cancelled";
+  return TASK_STATUSES.has(token) ? token : "unknown";
+}
+function toTaskDependencyProjection(task) {
+  const metadata = metadataOf(task);
+  return {
+    id: String(task.id),
+    title: stringValue(task.title),
+    status: normalizeTaskStatus(task.status),
+    priority: numberOrNull(task.priority),
+    metadata,
+    externalId: stringValue(task.externalId),
+    sourceIssueId: stringValue(task.sourceIssueId),
+    dependencies: stringArray(task.dependencies),
+    parentChildDeps: stringArray(task.parentChildDeps),
+    createdAt: stringValue(task.createdAt) ?? "",
+    updatedAt: stringValue(task.updatedAt) ?? "",
+    role: stringValue(task.role),
+    scope: stringArray(task.scope),
+    validationKeys: stringArray(task.validationKeys),
+    labels: stringArray(task.labels),
+    assignees: task.assignees ?? null,
+    assignedTo: task.assignedTo ?? null
+  };
+}
+function latestRunByTaskId(runs) {
+  const byTask = new Map;
+  const stamp = (run) => Date.parse(run.updatedAt ?? run.startedAt ?? "") || 0;
+  for (const run of runs) {
+    if (!run.taskId)
+      continue;
+    const current = byTask.get(run.taskId);
+    if (!current || stamp(run) >= stamp(current))
+      byTask.set(run.taskId, run);
+  }
+  return byTask;
+}
+var TASK_STATUSES;
+var init_taskGraphPrimitives = __esm(() => {
+  TASK_STATUSES = new Set([
+    "draft",
+    "open",
+    "ready",
+    "queued",
+    "running",
+    "in_progress",
+    "under_review",
+    "blocked",
+    "unknown",
+    "completed",
+    "failed",
+    "cancelled",
+    "closed"
+  ]);
+});
 
-// packages/supervisor-plugin/src/loop.ts
-import { computeTaskDependencyBadges, toTaskDependencyProjection } from "@rig/contracts";
-import { rankReadyTasks, selectRankedReadyTasks } from "@rig/dependency-graph-plugin";
+// packages/supervisor-plugin/src/analysis/taskScore.ts
+function finiteNumber(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function scoreTask(input) {
+  const priority = finiteNumber(input.priority, 3);
+  const unblockCount = Math.max(0, finiteNumber(input.unblockCount, 0));
+  const roleWeight = input.role ? ROLE_WEIGHT[input.role] ?? 0 : 0;
+  const criticalityWeight = input.criticality ? CRITICALITY_WEIGHT[input.criticality] ?? 0 : 0;
+  const validationWeight = (input.validation ?? []).some((entry) => entry.includes("test-contract") || entry.includes("test-boundary")) ? 8 : 0;
+  const queueWeight = finiteNumber(input.queueWeight, 0);
+  return unblockCount * 100 + (10 - priority) + roleWeight + criticalityWeight + validationWeight + queueWeight;
+}
+function rankTasks(tasks, scoreInput, idOf) {
+  return tasks.map((task) => {
+    const input = scoreInput(task);
+    return {
+      task,
+      score: scoreTask(input),
+      priority: finiteNumber(input.priority, 3),
+      unblockCount: Math.max(0, finiteNumber(input.unblockCount, 0))
+    };
+  }).toSorted((left, right) => {
+    const scoreDelta = right.score - left.score;
+    if (scoreDelta !== 0)
+      return scoreDelta;
+    const unblockDelta = right.unblockCount - left.unblockCount;
+    if (unblockDelta !== 0)
+      return unblockDelta;
+    const priorityDelta = left.priority - right.priority;
+    if (priorityDelta !== 0)
+      return priorityDelta;
+    return idOf(left.task).localeCompare(idOf(right.task));
+  });
+}
+var ROLE_WEIGHT, CRITICALITY_WEIGHT;
+var init_taskScore = __esm(() => {
+  ROLE_WEIGHT = {
+    architect: 25,
+    extractor: 10
+  };
+  CRITICALITY_WEIGHT = {
+    core: 20,
+    high: 10,
+    normal: 0
+  };
+});
+
+// packages/supervisor-plugin/src/analysis/taskRanking.ts
+function isObjectRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readStringList2(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.length > 0) : [];
+}
+function readTaskRole(task) {
+  if (typeof task.role === "string" && task.role.trim())
+    return task.role.trim();
+  const metadata = isObjectRecord2(task.metadata) ? task.metadata : null;
+  return typeof metadata?.role === "string" && metadata.role.trim() ? metadata.role.trim() : null;
+}
+function readTaskCriticality(task) {
+  const metadata = isObjectRecord2(task.metadata) ? task.metadata : null;
+  return typeof metadata?.criticality === "string" && metadata.criticality.trim() ? metadata.criticality.trim() : null;
+}
+function readTaskValidationKeys(task) {
+  const taskRecord = task;
+  const topLevel = readStringList2(taskRecord.validationKeys);
+  if (topLevel.length > 0)
+    return topLevel;
+  const metadata = isObjectRecord2(task.metadata) ? task.metadata : null;
+  return readStringList2(metadata?.validation);
+}
+function readTaskQueueWeight(task) {
+  const metadata = isObjectRecord2(task.metadata) ? task.metadata : null;
+  const queueWeight = metadata?.queueWeight ?? metadata?.queue_weight;
+  return typeof queueWeight === "number" && Number.isFinite(queueWeight) ? queueWeight : 0;
+}
+function scoreInputForTask(task, unblockCount) {
+  return {
+    priority: task.priority,
+    unblockCount,
+    role: readTaskRole(task),
+    criticality: readTaskCriticality(task),
+    validation: readTaskValidationKeys(task),
+    queueWeight: readTaskQueueWeight(task)
+  };
+}
+function rankReadyTasks(tasks, options = {}) {
+  const excluded = new Set(options.excludeTaskIds ?? []);
+  const activeTaskIds = new Set(options.activeTaskIds ?? []);
+  const badges = computeTaskDependencyBadges(tasks);
+  const tasksById = new Map(tasks.map((task) => [String(task.id), task]));
+  const openBlockCount = (task) => (badges.get(task.id)?.blocks ?? []).filter((blockedTaskId) => {
+    const blockedTask = tasksById.get(blockedTaskId);
+    return blockedTask ? !isTaskTerminalStatus(blockedTask.status) : false;
+  }).length;
+  const readyTasks = tasks.filter((task) => !excluded.has(task.id)).filter((task) => !activeTaskIds.has(task.id)).filter((task) => options.filter?.(task) ?? true).filter((task) => badges.get(task.id)?.ready === true);
+  const maxUnblockCount = Math.max(0, ...readyTasks.map(openBlockCount));
+  const selectedByMode = readyTasks.filter((task) => {
+    const unblockCount = openBlockCount(task);
+    if (options.selection === "blocking-only")
+      return unblockCount > 0;
+    if (options.selection === "max-unblock")
+      return maxUnblockCount > 0 && unblockCount === maxUnblockCount;
+    return true;
+  });
+  return rankTasks(selectedByMode, (task) => scoreInputForTask(task, openBlockCount(task)), (task) => task.id).map((entry) => ({
+    task: entry.task,
+    score: entry.score,
+    priority: entry.priority,
+    unblockCount: entry.unblockCount,
+    scope: readTaskScope(entry.task)
+  }));
+}
+function selectRankedReadyTasks(tasks, options = {}) {
+  const ranked = rankReadyTasks(tasks, options);
+  if (options.requireDisjointScopes !== true && !options.disjointWithScopes) {
+    return ranked.slice(0, options.limit).map((entry) => entry.task);
+  }
+  const occupiedScopes = new Set(options.disjointWithScopes ?? []);
+  const selected = [];
+  for (const entry of ranked) {
+    if (entry.scope.some((scope) => occupiedScopes.has(scope)))
+      continue;
+    selected.push(entry.task);
+    for (const scope of entry.scope)
+      occupiedScopes.add(scope);
+    if (options.limit !== undefined && selected.length >= options.limit)
+      break;
+  }
+  return selected;
+}
+var init_taskRanking = __esm(() => {
+  init_taskGraphPrimitives();
+  init_taskScore();
+});
 
 // packages/supervisor-plugin/src/journal.ts
 import { Schema } from "effect";
@@ -119,9 +529,100 @@ function reduceSupervisorJournal(events) {
   }
   return { status, processed, succeeded, failed, skipped, current, plannedOrder, selectionPolicy, concurrency, idleReason, stopReason, closures, anomalies };
 }
+var init_journal = () => {};
+
+// packages/supervisor-plugin/src/analysis/blockers.ts
+function labelsFor(task) {
+  return readTaskMetadataStringList(task, "labels").map((label) => label.toLowerCase());
+}
+function configuredTier(task, labels) {
+  const metadata = task.metadata && typeof task.metadata === "object" && !Array.isArray(task.metadata) ? task.metadata : {};
+  const tier = metadata.riskTier ?? metadata.actionRiskTier;
+  if (tier === "t1-read" || tier === "t2-reversible" || tier === "t3-external" || tier === "t4-irreversible")
+    return tier;
+  if (labels.some((label) => /prod|deploy|migration|billing|delete|irreversible/.test(label)))
+    return "t4-irreversible";
+  if (labels.some((label) => /customer|vendor|external|secret|credential|approval|decision/.test(label)))
+    return "t3-external";
+  const scopes = task.scope ?? [];
+  if (scopes.some((scope) => /docs|readme|test|spec/.test(scope.toLowerCase())))
+    return "t1-read";
+  return "t2-reversible";
+}
+function tierOf(task, labels = []) {
+  const projection = "metadata" in task && "id" in task && typeof task.id === "string" ? toTaskDependencyProjection(task) : task;
+  return configuredTier(projection, labels.length > 0 ? labels : labelsFor(projection)) ?? "t2-reversible";
+}
+function baseClassification(task, blockerClass, source, rationale, labels) {
+  return {
+    taskId: task.id,
+    blockerClass,
+    actionRiskTier: tierOf(task, labels),
+    rationale,
+    source,
+    autoApplied: source === "llm"
+  };
+}
+function normalizeRunStatus(status) {
+  if (status === "waiting-approval" || status === "waiting-user-input" || status === "needs-attention" || status === "completed" || status === "failed" || status === "stopped" || status === "running")
+    return status;
+  return null;
+}
+function isHumanBlockerClass(blockerClass) {
+  return HUMAN_BLOCKERS.has(blockerClass);
+}
+function classifyBlocker(input) {
+  const labels = input.labels ?? labelsFor(input.task);
+  const runStatus = normalizeRunStatus(input.run?.status);
+  if (runStatus === "waiting-approval")
+    return baseClassification(input.task, "human-approval", "status", "run awaiting approval", labels);
+  if (runStatus === "waiting-user-input")
+    return baseClassification(input.task, "external-input", "status", "run awaiting user input", labels);
+  if (input.task.status !== "blocked")
+    return baseClassification(input.task, "not-blocked", "elimination", "task is not blocked", labels);
+  const incomplete = (input.badges.get(input.task.id)?.blockedBy ?? []).filter((dependencyId) => {
+    const dependency = input.tasksById.get(dependencyId);
+    return dependency ? !isTaskTerminalStatus(dependency.status) : false;
+  });
+  if (incomplete.length > 0)
+    return baseClassification(input.task, "task-blocked", "elimination", `blocked by ${incomplete.length} incomplete task(s)`, labels);
+  if (labels.includes("needs-decision"))
+    return baseClassification(input.task, "human-decision", "label", "needs-decision label", labels);
+  if (labels.some((label) => /^waiting-on-/.test(label)))
+    return baseClassification(input.task, "external-input", "label", "waiting-on-* label", labels);
+  if (input.config?.llm)
+    return baseClassification(input.task, "human-decision", "llm", "LLM residue classifier marked this as human-gated", labels);
+  return baseClassification(input.task, "human-decision", "elimination", "blocked, all task dependencies terminal; non-task gate remains", labels);
+}
+function classifyTasks(tasks, runs = [], options = {}) {
+  const projected = tasks.map(toTaskDependencyProjection);
+  const badges = computeTaskDependencyBadges(projected);
+  const tasksById = new Map(projected.map((task) => [task.id, task]));
+  const runByTask = latestRunByTaskId(runs);
+  const classifier = options.classifier ?? classifyBlocker;
+  const classifications = projected.map((task) => classifier({ task, badges, tasksById, run: runByTask.get(task.id) ?? null, labels: labelsFor(task) })).filter((classification) => options.humanOnly !== true || isHumanBlockerClass(classification.blockerClass));
+  return {
+    classifications,
+    byTaskId: new Map(classifications.map((classification) => [classification.taskId, classification])),
+    human: classifications.filter((classification) => isHumanBlockerClass(classification.blockerClass)),
+    machine: classifications.filter((classification) => !isHumanBlockerClass(classification.blockerClass)),
+    generatedAt: options.generatedAt ?? new Date().toISOString()
+  };
+}
+var HUMAN_BLOCKERS;
+var init_blockers = __esm(() => {
+  init_taskGraphPrimitives();
+  HUMAN_BLOCKERS = new Set(["human-decision", "human-approval", "external-input"]);
+});
 
 // packages/supervisor-plugin/src/loop.ts
-import { classifyTasks, isHumanBlockerClass } from "@rig/blocker-classifier-plugin";
+var exports_loop = {};
+__export(exports_loop, {
+  unblockTask: () => unblockTask,
+  runSupervisorLoop: () => runSupervisorLoop,
+  planSupervisorLoop: () => planSupervisorLoop,
+  controlSupervisorRun: () => controlSupervisorRun
+});
 function selectionMode(policy) {
   return policy === "blocking-only" || policy === "max-unblock" ? policy : "all-ready";
 }
@@ -180,25 +681,7 @@ function failedOutcome(outcome) {
   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";
-  }
+  return coerceRunStatus(value, "failed");
 }
 async function runSupervisorLoop(projectRoot, deps, options = {}) {
   const events = [{ kind: "supervisor.started", at: at(deps), options }];
@@ -269,6 +752,10 @@ async function runSupervisorLoop(projectRoot, deps, options = {}) {
   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) => {
@@ -291,10 +778,60 @@ async function unblockTask(projectRoot, taskId, deps, options = {}) {
   const blockers = collectBlockingClosure(taskId, badges);
   return runSupervisorLoop(projectRoot, deps, { ...options, candidateTaskIds: blockers, selectionPolicy: "rank", maxTasks: 1 });
 }
+var init_loop = __esm(() => {
+  init_taskGraphPrimitives();
+  init_taskRanking();
+  init_journal();
+  init_run_status();
+  init_blockers();
+});
 
 // packages/supervisor-plugin/src/cli.ts
+import { RUN_DISPATCH, RUN_READ_MODEL, TASK_IO_SERVICE_CAPABILITY } from "@rig/contracts";
+import { defineCapability } from "@rig/core/capability";
+import { requireCapabilityForRoot } from "@rig/core/capability-loaders";
+
+// packages/supervisor-plugin/src/awaiter.ts
+var TERMINAL_RUN_STATUSES = {
+  created: false,
+  queued: false,
+  preparing: false,
+  running: false,
+  "waiting-approval": false,
+  "waiting-user-input": false,
+  paused: false,
+  validating: false,
+  reviewing: false,
+  "closing-out": false,
+  "needs-attention": true,
+  completed: true,
+  failed: true,
+  stopped: true
+};
+async function awaitTerminalRun(options) {
+  const startedAt = Date.now();
+  const pollMs = Math.max(0, Math.floor(options.pollMs ?? 5000));
+  while (true) {
+    const snapshot = await options.readStatus(options.runId);
+    if (snapshot && TERMINAL_RUN_STATUSES[snapshot.status]) {
+      return {
+        runId: options.runId,
+        status: snapshot.status,
+        failed: snapshot.status !== "completed"
+      };
+    }
+    if (options.timeoutMs !== undefined && Date.now() - startedAt >= options.timeoutMs) {
+      return { runId: options.runId, status: "needs-attention", failed: true };
+    }
+    await options.waitForChange(pollMs);
+  }
+}
+
+// packages/supervisor-plugin/src/cli.ts
+init_run_status();
 var SUPERVISOR_LOOP_CLI_ID = "supervisor.loop";
 var SUPERVISOR_UNBLOCK_CLI_ID = "supervisor.unblock";
+var RunReadModelCap = defineCapability(RUN_READ_MODEL);
 function printJson(value) {
   console.log(JSON.stringify(value, null, 2));
 }
@@ -331,55 +868,36 @@ function parsePositiveInt(value, flag, fallback) {
   }
   return parsed;
 }
-function parseCsv(value) {
-  return value?.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0) ?? [];
-}
 function asRunStatus(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 "needs-attention";
-  }
+  return coerceRunStatus(value, "needs-attention");
 }
 function delay(ms) {
   const { promise, resolve } = Promise.withResolvers();
   setTimeout(resolve, ms);
   return promise;
 }
-async function loadSupervisorClient() {
-  const [taskIo, runIo, dispatchIo] = await Promise.all([
-    import("@rig/core/task-io"),
-    import("@rig/run-worker/runs"),
-    import("@rig/runtime/control-plane/dispatch")
+async function loadSupervisorClient(projectRoot) {
+  const [taskIo, runReadModel] = await Promise.all([
+    requireCapabilityForRoot(projectRoot, defineCapability(TASK_IO_SERVICE_CAPABILITY), "No task-sources plugin provides task IO for this project root."),
+    requireCapabilityForRoot(projectRoot, RunReadModelCap, "No run-worker plugin provides run read-model for this project root.")
   ]);
-  return { listTasks: taskIo.listTasks, listRuns: runIo.listRuns, dispatchRun: dispatchIo.dispatchRun };
+  return { listTasks: taskIo.listTasks, listRuns: (root) => runReadModel.listRuns({ projectRoot: root }) };
 }
 function supervisorDeps(timeoutMs) {
   return {
-    listTasks: async (projectRoot) => (await loadSupervisorClient()).listTasks(projectRoot),
-    listRuns: async (projectRoot) => (await loadSupervisorClient()).listRuns(projectRoot),
-    dispatchRun: async (...args) => (await loadSupervisorClient()).dispatchRun(...args),
+    listTasks: async (projectRoot) => (await loadSupervisorClient(projectRoot)).listTasks(projectRoot),
+    listRuns: async (projectRoot) => (await loadSupervisorClient(projectRoot)).listRuns(projectRoot),
+    dispatchRun: async (input) => {
+      const service = await requireCapabilityForRoot(input.projectRoot, defineCapability(RUN_DISPATCH), "No transport plugin provides run dispatch for this project root.");
+      return service.dispatchRun(input);
+    },
     awaitRunTerminal: async (projectRoot, runId) => {
       const awaitedRunId = runId;
       return awaitTerminalRun({
         runId: awaitedRunId,
         timeoutMs,
         readStatus: async (id) => {
-          const { listRuns } = await loadSupervisorClient();
+          const { listRuns } = await loadSupervisorClient(projectRoot);
           const run = (await listRuns(projectRoot)).find((candidate) => candidate.runId === id);
           return run ? { runId: id, status: asRunStatus(run.status), ...run.errorSummary ? { diagnostic: run.errorSummary } : {} } : null;
         },
@@ -409,13 +927,14 @@ 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 result = await runSupervisorLoop(context.projectRoot, supervisorDeps(parsePositiveInt(timeout.value, "--timeout-ms", 30 * 60 * 1000)), {
+  const { runSupervisorLoop: runSupervisorLoop2 } = await Promise.resolve().then(() => (init_loop(), exports_loop));
+  const result = await runSupervisorLoop2(context.projectRoot, supervisorDeps(parsePositiveInt(timeout.value, "--timeout-ms", 1800000)), {
     maxTasks: parsePositiveInt(maxTasks.value, "--max-tasks", 1),
     concurrency: parsePositiveInt(concurrency.value, "--concurrency", 1),
     ...task.value ? { candidateTaskIds: [task.value] } : {},
-    dryRun: dry.value || context.dryRun
+    dryRun: Boolean(dry.value || context.dryRun)
   });
-  const details = { ...result, stopWhen: parseCsv(stopWhen.value) };
+  const details = { ...result, stopWhen: stopWhen.value?.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0) ?? [] };
   if (context.outputMode === "text") {
     if (json.value)
       printJson(details);
@@ -430,7 +949,8 @@ 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 result = await unblockTask(context.projectRoot, taskId ?? null, supervisorDeps(parsePositiveInt(timeout.value, "--timeout-ms", 30 * 60 * 1000)), { dryRun: dry.value || context.dryRun });
+  const { unblockTask: unblockTask2 } = await Promise.resolve().then(() => (init_loop(), exports_loop));
+  const result = await unblockTask2(context.projectRoot, taskId ?? null, supervisorDeps(parsePositiveInt(timeout.value, "--timeout-ms", 1800000)), { dryRun: Boolean(dry.value || context.dryRun) });
   if (context.outputMode === "text") {
     if (json.value)
       printJson(result);