@h-rig/blocker-classifier-plugin 0.0.6-alpha.155 → 0.0.6-alpha.157

package/dist/src/blockers.d.ts

@@ -0,0 +1,36 @@
+import type { TaskLike } from "@rig/core/task-io";
+import type { ClientTaskProjection, TaskDependencyBadgeSummary } from "@rig/contracts";
+import type { BlockerClass, BlockerClassification, ActionRiskTier, RunRecord } from "@rig/contracts";
+export type BlockerClassifier = (input: BlockerClassifierInput) => BlockerClassification;
+export interface BlockerClassifierInput {
+    readonly task: ClientTaskProjection;
+    readonly badges: ReadonlyMap<string, TaskDependencyBadgeSummary>;
+    readonly tasksById: ReadonlyMap<string, ClientTaskProjection>;
+    readonly run?: Pick<RunRecord, "status"> | null;
+    readonly labels?: readonly string[];
+    readonly config?: {
+        readonly llm?: boolean;
+    };
+}
+export interface WorkspaceBlockers {
+    readonly classifications: readonly BlockerClassification[];
+    readonly byTaskId: ReadonlyMap<string, BlockerClassification>;
+    readonly human: readonly BlockerClassification[];
+    readonly machine: readonly BlockerClassification[];
+    readonly generatedAt: string;
+}
+export declare function tierOf(task: ClientTaskProjection | TaskLike, labels?: readonly string[]): ActionRiskTier;
+export declare function isHumanBlockerClass(blockerClass: BlockerClass): boolean;
+export declare function classifyBlocker(input: BlockerClassifierInput): BlockerClassification;
+export declare function classifyTasks(tasks: readonly TaskLike[], runs?: readonly Pick<RunRecord, "taskId" | "status" | "updatedAt" | "startedAt">[], options?: {
+    readonly classifier?: BlockerClassifier;
+    readonly generatedAt?: string;
+    readonly humanOnly?: boolean;
+}): WorkspaceBlockers;
+export declare function classifyWorkspaceBlockers(projectRoot: string, deps: {
+    readonly listTasks: (projectRoot: string) => Promise<readonly TaskLike[]>;
+    readonly listRuns?: (projectRoot: string) => Promise<readonly RunRecord[]>;
+    readonly classifier?: BlockerClassifier;
+    readonly humanOnly?: boolean;
+    readonly generatedAt?: string;
+}): Promise<WorkspaceBlockers>;

package/dist/src/blockers.js

@@ -0,0 +1,101 @@
+// @bun
+// packages/blocker-classifier-plugin/src/blockers.ts
+import {
+  computeTaskDependencyBadges,
+  isTaskTerminalStatus,
+  latestRunByTaskId,
+  readTaskMetadataStringList,
+  toTaskDependencyProjection
+} from "@rig/contracts";
+var HUMAN_BLOCKERS = new Set(["human-decision", "human-approval", "external-input"]);
+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()
+  };
+}
+async function classifyWorkspaceBlockers(projectRoot, deps) {
+  const [tasks, runs] = await Promise.all([
+    deps.listTasks(projectRoot),
+    deps.listRuns ? deps.listRuns(projectRoot) : Promise.resolve([])
+  ]);
+  return classifyTasks(tasks, runs, deps);
+}
+export {
+  tierOf,
+  isHumanBlockerClass,
+  classifyWorkspaceBlockers,
+  classifyTasks,
+  classifyBlocker
+};

package/dist/src/index.d.ts

@@ -1 +1,2 @@
+export * from "./blockers";
 export * from "./plugin";

package/dist/src/index.js

@@ -1,6 +1,99 @@
 // @bun
 var __require = import.meta.require;
 
+// packages/blocker-classifier-plugin/src/blockers.ts
+import {
+  computeTaskDependencyBadges,
+  isTaskTerminalStatus,
+  latestRunByTaskId,
+  readTaskMetadataStringList,
+  toTaskDependencyProjection
+} from "@rig/contracts";
+var HUMAN_BLOCKERS = new Set(["human-decision", "human-approval", "external-input"]);
+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()
+  };
+}
+async function classifyWorkspaceBlockers(projectRoot, deps) {
+  const [tasks, runs] = await Promise.all([
+    deps.listTasks(projectRoot),
+    deps.listRuns ? deps.listRuns(projectRoot) : Promise.resolve([])
+  ]);
+  return classifyTasks(tasks, runs, deps);
+}
 // packages/blocker-classifier-plugin/src/plugin.ts
 import { definePlugin } from "@rig/core/config";
 var BLOCKER_CLASSIFIER_PLUGIN_NAME = "@rig/blocker-classifier-plugin";
@@ -13,8 +106,10 @@ function isRecord(value) {
 function panelProjectRoot(context) {
   return isRecord(context) && typeof context.projectRoot === "string" && context.projectRoot.length > 0 ? context.projectRoot : null;
 }
-async function loadBlockerClient() {
-  return await import("@rig/client");
+async function loadBlockerClientIo() {
+  const { listTasks } = await import("@rig/core/task-io");
+  const { listRuns } = await import("@rig/run-worker/runs");
+  return { listRuns, listTasks };
 }
 function taskEpicKey(task) {
   const direct = typeof task?.epicKey === "string" ? task.epicKey : null;
@@ -27,15 +122,15 @@ async function produceHumanBlockersPanel(context) {
   const projectRoot = panelProjectRoot(context);
   if (!projectRoot)
     return;
-  const { classifyWorkspaceBlockers, listRuns, listTasks } = await loadBlockerClient();
-  const [tasks, blockers] = await Promise.all([
+  const { listRuns, listTasks } = await loadBlockerClientIo();
+  const [tasks, blockers2] = await Promise.all([
     listTasks(projectRoot),
     classifyWorkspaceBlockers(projectRoot, { listTasks, listRuns, humanOnly: true })
   ]);
   const tasksById = new Map(tasks.map((task) => [task.id, task]));
   return {
     humanOnly: true,
-    items: blockers.classifications.map((classification) => {
+    items: blockers2.classifications.map((classification) => {
       const task = tasksById.get(classification.taskId);
       return {
         taskId: classification.taskId,
@@ -72,7 +167,7 @@ async function executeBlockers(context, args) {
   const json = takeFlag(args, "--json");
   const humanOnly = takeFlag(json.rest, "--human-only");
   requireNoExtraArgs(humanOnly.rest, "rig blockers [--human-only] [--json]");
-  const { classifyWorkspaceBlockers, listRuns, listTasks } = await loadBlockerClient();
+  const { listRuns, listTasks } = await loadBlockerClientIo();
   const result = await classifyWorkspaceBlockers(context.projectRoot, { listTasks, listRuns, humanOnly: humanOnly.value });
   const details = { classifications: result.classifications, human: result.human, machine: result.machine, generatedAt: result.generatedAt };
   if (context.outputMode === "text") {
@@ -103,41 +198,34 @@ var blockerClassifierPlugin = definePlugin({
       { id: "workspace.blockers", title: "Workspace blocker classification", commandId: BLOCKERS_CLI_ID, panelId: HUMAN_BLOCKERS_PANEL_ID }
     ],
     blockerClassifiers: [
-      { id: DEFAULT_BLOCKER_CLASSIFIER_ID, description: "Default deterministic Rig blocker classifier.", priority: 0 }
+      {
+        id: DEFAULT_BLOCKER_CLASSIFIER_ID,
+        description: "Default deterministic Rig blocker classifier.",
+        priority: 0,
+        async classify(input) {
+          if (!isBlockerClassifierInput(input))
+            throw new Error("blocker classifier input must include task, badges, and tasksById.");
+          return classifyBlocker(input);
+        }
+      }
     ],
     panels: [
-      { id: HUMAN_BLOCKERS_PANEL_ID, slot: "capability", title: "Human blockers", capabilityId: "workspace.blockers" }
+      { id: HUMAN_BLOCKERS_PANEL_ID, slot: "capability", title: "Human blockers", capabilityId: "workspace.blockers", produce: produceHumanBlockersPanel }
     ],
-    cliCommands: blockerClassifierCliCommands.map(({ run: _run, ...metadata }) => metadata)
+    cliCommands: blockerClassifierCliCommands
   }
-}, {
-  featureCapabilities: [
-    { id: "workspace.blockers", title: "Workspace blocker classification", commandId: BLOCKERS_CLI_ID, panelId: HUMAN_BLOCKERS_PANEL_ID }
-  ],
-  panels: [
-    { id: HUMAN_BLOCKERS_PANEL_ID, slot: "capability", title: "Human blockers", capabilityId: "workspace.blockers", produce: produceHumanBlockersPanel }
-  ],
-  blockerClassifiers: [
-    {
-      id: DEFAULT_BLOCKER_CLASSIFIER_ID,
-      description: "Default deterministic Rig blocker classifier.",
-      priority: 0,
-      async classify(input) {
-        if (!isBlockerClassifierInput(input))
-          throw new Error("blocker classifier input must include task, badges, and tasksById.");
-        const { classifyBlocker } = await loadBlockerClient();
-        return classifyBlocker(input);
-      }
-    }
-  ],
-  cliCommands: blockerClassifierCliCommands
 });
 function createBlockerClassifierPlugin() {
   return blockerClassifierPlugin;
 }
 export {
+  tierOf,
+  isHumanBlockerClass,
   executeBlockers,
   createBlockerClassifierPlugin,
+  classifyWorkspaceBlockers,
+  classifyTasks,
+  classifyBlocker,
   blockerClassifierPlugin,
   blockerClassifierCliCommands,
   HUMAN_BLOCKERS_PANEL_ID,

package/dist/src/plugin.d.ts

@@ -1,4 +1,5 @@
 import { type RuntimeCliContext } from "@rig/core/config";
+export * from "./blockers";
 export declare const BLOCKER_CLASSIFIER_PLUGIN_NAME = "@rig/blocker-classifier-plugin";
 export declare const BLOCKERS_CLI_ID = "blocker-classifier.blockers";
 export declare const DEFAULT_BLOCKER_CLASSIFIER_ID = "blocker-classifier.default";
@@ -19,6 +20,6 @@ export declare const blockerClassifierCliCommands: readonly [{
     readonly projectRequired: true;
     readonly run: typeof executeBlockers;
 }];
-export declare const blockerClassifierPlugin: import("@rig/core").RigPluginWithRuntime;
-export declare function createBlockerClassifierPlugin(): import("@rig/core").RigPluginWithRuntime;
+export declare const blockerClassifierPlugin: import("@rig/core/config").RigPlugin;
+export declare function createBlockerClassifierPlugin(): import("@rig/core/config").RigPlugin;
 export default blockerClassifierPlugin;

package/dist/src/plugin.js

@@ -3,6 +3,102 @@ var __require = import.meta.require;
 
 // packages/blocker-classifier-plugin/src/plugin.ts
 import { definePlugin } from "@rig/core/config";
+
+// packages/blocker-classifier-plugin/src/blockers.ts
+import {
+  computeTaskDependencyBadges,
+  isTaskTerminalStatus,
+  latestRunByTaskId,
+  readTaskMetadataStringList,
+  toTaskDependencyProjection
+} from "@rig/contracts";
+var HUMAN_BLOCKERS = new Set(["human-decision", "human-approval", "external-input"]);
+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()
+  };
+}
+async function classifyWorkspaceBlockers(projectRoot, deps) {
+  const [tasks, runs] = await Promise.all([
+    deps.listTasks(projectRoot),
+    deps.listRuns ? deps.listRuns(projectRoot) : Promise.resolve([])
+  ]);
+  return classifyTasks(tasks, runs, deps);
+}
+
+// packages/blocker-classifier-plugin/src/plugin.ts
 var BLOCKER_CLASSIFIER_PLUGIN_NAME = "@rig/blocker-classifier-plugin";
 var BLOCKERS_CLI_ID = "blocker-classifier.blockers";
 var DEFAULT_BLOCKER_CLASSIFIER_ID = "blocker-classifier.default";
@@ -13,8 +109,10 @@ function isRecord(value) {
 function panelProjectRoot(context) {
   return isRecord(context) && typeof context.projectRoot === "string" && context.projectRoot.length > 0 ? context.projectRoot : null;
 }
-async function loadBlockerClient() {
-  return await import("@rig/client");
+async function loadBlockerClientIo() {
+  const { listTasks } = await import("@rig/core/task-io");
+  const { listRuns } = await import("@rig/run-worker/runs");
+  return { listRuns, listTasks };
 }
 function taskEpicKey(task) {
   const direct = typeof task?.epicKey === "string" ? task.epicKey : null;
@@ -27,15 +125,15 @@ async function produceHumanBlockersPanel(context) {
   const projectRoot = panelProjectRoot(context);
   if (!projectRoot)
     return;
-  const { classifyWorkspaceBlockers, listRuns, listTasks } = await loadBlockerClient();
-  const [tasks, blockers] = await Promise.all([
+  const { listRuns, listTasks } = await loadBlockerClientIo();
+  const [tasks, blockers2] = await Promise.all([
     listTasks(projectRoot),
     classifyWorkspaceBlockers(projectRoot, { listTasks, listRuns, humanOnly: true })
   ]);
   const tasksById = new Map(tasks.map((task) => [task.id, task]));
   return {
     humanOnly: true,
-    items: blockers.classifications.map((classification) => {
+    items: blockers2.classifications.map((classification) => {
       const task = tasksById.get(classification.taskId);
       return {
         taskId: classification.taskId,
@@ -72,7 +170,7 @@ async function executeBlockers(context, args) {
   const json = takeFlag(args, "--json");
   const humanOnly = takeFlag(json.rest, "--human-only");
   requireNoExtraArgs(humanOnly.rest, "rig blockers [--human-only] [--json]");
-  const { classifyWorkspaceBlockers, listRuns, listTasks } = await loadBlockerClient();
+  const { listRuns, listTasks } = await loadBlockerClientIo();
   const result = await classifyWorkspaceBlockers(context.projectRoot, { listTasks, listRuns, humanOnly: humanOnly.value });
   const details = { classifications: result.classifications, human: result.human, machine: result.machine, generatedAt: result.generatedAt };
   if (context.outputMode === "text") {
@@ -103,43 +201,36 @@ var blockerClassifierPlugin = definePlugin({
       { id: "workspace.blockers", title: "Workspace blocker classification", commandId: BLOCKERS_CLI_ID, panelId: HUMAN_BLOCKERS_PANEL_ID }
     ],
     blockerClassifiers: [
-      { id: DEFAULT_BLOCKER_CLASSIFIER_ID, description: "Default deterministic Rig blocker classifier.", priority: 0 }
+      {
+        id: DEFAULT_BLOCKER_CLASSIFIER_ID,
+        description: "Default deterministic Rig blocker classifier.",
+        priority: 0,
+        async classify(input) {
+          if (!isBlockerClassifierInput(input))
+            throw new Error("blocker classifier input must include task, badges, and tasksById.");
+          return classifyBlocker(input);
+        }
+      }
     ],
     panels: [
-      { id: HUMAN_BLOCKERS_PANEL_ID, slot: "capability", title: "Human blockers", capabilityId: "workspace.blockers" }
+      { id: HUMAN_BLOCKERS_PANEL_ID, slot: "capability", title: "Human blockers", capabilityId: "workspace.blockers", produce: produceHumanBlockersPanel }
     ],
-    cliCommands: blockerClassifierCliCommands.map(({ run: _run, ...metadata }) => metadata)
+    cliCommands: blockerClassifierCliCommands
   }
-}, {
-  featureCapabilities: [
-    { id: "workspace.blockers", title: "Workspace blocker classification", commandId: BLOCKERS_CLI_ID, panelId: HUMAN_BLOCKERS_PANEL_ID }
-  ],
-  panels: [
-    { id: HUMAN_BLOCKERS_PANEL_ID, slot: "capability", title: "Human blockers", capabilityId: "workspace.blockers", produce: produceHumanBlockersPanel }
-  ],
-  blockerClassifiers: [
-    {
-      id: DEFAULT_BLOCKER_CLASSIFIER_ID,
-      description: "Default deterministic Rig blocker classifier.",
-      priority: 0,
-      async classify(input) {
-        if (!isBlockerClassifierInput(input))
-          throw new Error("blocker classifier input must include task, badges, and tasksById.");
-        const { classifyBlocker } = await loadBlockerClient();
-        return classifyBlocker(input);
-      }
-    }
-  ],
-  cliCommands: blockerClassifierCliCommands
 });
 function createBlockerClassifierPlugin() {
   return blockerClassifierPlugin;
 }
 var plugin_default = blockerClassifierPlugin;
 export {
+  tierOf,
+  isHumanBlockerClass,
   executeBlockers,
   plugin_default as default,
   createBlockerClassifierPlugin,
+  classifyWorkspaceBlockers,
+  classifyTasks,
+  classifyBlocker,
   blockerClassifierPlugin,
   blockerClassifierCliCommands,
   HUMAN_BLOCKERS_PANEL_ID,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@h-rig/blocker-classifier-plugin",
-  "version": "0.0.6-alpha.155",
+  "version": "0.0.6-alpha.157",
   "type": "module",
   "description": "First-party blocker classifier capability plugin for Rig.",
   "license": "UNLICENSED",
@@ -25,8 +25,8 @@
   "module": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",
   "dependencies": {
-    "@rig/client": "npm:@h-rig/client@0.0.6-alpha.155",
-    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.155",
-    "@rig/core": "npm:@h-rig/core@0.0.6-alpha.155"
+    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.157",
+    "@rig/run-worker": "npm:@h-rig/run-worker@0.0.6-alpha.157",
+    "@rig/core": "npm:@h-rig/core@0.0.6-alpha.157"
   }
 }