@h-rig/blocker-classifier-plugin 0.0.6-alpha.134 → 0.0.6-alpha.137

package/dist/src/index.d.ts

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

package/dist/src/index.js

@@ -1,163 +1,145 @@
 // @bun
-// packages/blocker-classifier-plugin/src/classifier.ts
-import { Schema } from "effect";
-import { BlockerClassification } from "@rig/contracts";
-import { isTaskTerminalStatus, readTaskMetadataStringList } from "@rig/core/task-graph";
-var HUMAN_DECISION_LABEL = {
-  "human-decision": true,
-  "needs-decision": true,
-  decision: true,
-  "blocked:decision": true
-};
-var HUMAN_APPROVAL_LABEL = {
-  "human-approval": true,
-  "needs-approval": true,
-  approval: true,
-  "blocked:approval": true,
-  "review-blocked": true
-};
-var EXTERNAL_INPUT_LABEL = {
-  "external-input": true,
-  external: true,
-  vendor: true,
-  customer: true,
-  "blocked:external": true
-};
-var MACHINE_BLOCKED_LABEL = {
-  "task-blocked": true,
-  "blocked:task": true,
-  "dependency-blocked": true
-};
-function tierOf(blockerClass) {
-  if (blockerClass === "human-decision")
-    return "t2-reversible";
-  if (blockerClass === "human-approval")
-    return "t3-external";
-  if (blockerClass === "external-input")
-    return "t3-external";
-  if (blockerClass === "unknown")
-    return "t4-irreversible";
-  return null;
-}
-function classification(task, blockerClass, rationale, source, autoApplied) {
-  return { taskId: task.id, blockerClass, actionRiskTier: tierOf(blockerClass), rationale, source, autoApplied };
+// packages/blocker-classifier-plugin/src/plugin.ts
+import { definePlugin } from "@rig/core";
+import {
+  classifyBlocker,
+  classifyWorkspaceBlockers,
+  listRuns,
+  listTasks
+} from "@rig/client";
+var BLOCKER_CLASSIFIER_PLUGIN_NAME = "@rig/blocker-classifier-plugin";
+var BLOCKERS_CLI_ID = "blocker-classifier.blockers";
+var DEFAULT_BLOCKER_CLASSIFIER_ID = "blocker-classifier.default";
+var HUMAN_BLOCKERS_PANEL_ID = "human-blockers";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function normalizedLabels(task) {
-  return readTaskMetadataStringList(task, "labels").map((label) => label.trim().toLowerCase()).filter((label) => label.length > 0);
+function panelProjectRoot(context) {
+  return isRecord(context) && typeof context.projectRoot === "string" && context.projectRoot.length > 0 ? context.projectRoot : null;
 }
-function classifyFromLabels(task) {
-  const labels = normalizedLabels(task);
-  if (labels.some((label) => HUMAN_DECISION_LABEL[label]))
-    return classification(task, "human-decision", "Task carries a human-decision blocker label.", "label", true);
-  if (labels.some((label) => HUMAN_APPROVAL_LABEL[label]))
-    return classification(task, "human-approval", "Task carries a human-approval blocker label.", "label", true);
-  if (labels.some((label) => EXTERNAL_INPUT_LABEL[label]))
-    return classification(task, "external-input", "Task carries an external-input blocker label.", "label", true);
-  if (labels.some((label) => MACHINE_BLOCKED_LABEL[label]))
-    return classification(task, "task-blocked", "Task carries a task/dependency blocker label.", "label", true);
-  return null;
+function taskEpicKey(task) {
+  const direct = typeof task?.epicKey === "string" ? task.epicKey : null;
+  if (direct)
+    return direct;
+  const metadata = isRecord(task?.metadata) ? task.metadata : {};
+  return typeof metadata.epicKey === "string" ? metadata.epicKey : typeof metadata.epic === "string" ? metadata.epic : null;
 }
-function residue(task) {
-  return `${task.title}
-${task.description}`.toLowerCase();
+async function produceHumanBlockersPanel(context) {
+  const projectRoot = panelProjectRoot(context);
+  if (!projectRoot)
+    return;
+  const [tasks, blockers] = 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) => {
+      const task = tasksById.get(classification.taskId);
+      return {
+        taskId: classification.taskId,
+        title: task?.title ?? classification.taskId,
+        blockerClass: classification.blockerClass,
+        rationale: classification.rationale,
+        riskTier: classification.actionRiskTier,
+        epicKey: taskEpicKey(task),
+        autoApplied: classification.autoApplied
+      };
+    })
+  };
 }
-function classifyFromResidue(task) {
-  const text = residue(task);
-  if (/\b(approval|approve|review required|sign[ -]?off)\b/u.test(text))
-    return classification(task, "human-approval", "Task text asks for approval or sign-off.", "status", true);
-  if (/\b(decide|decision|choose|clarify|question)\b/u.test(text))
-    return classification(task, "human-decision", "Task text asks for a human decision or clarification.", "status", true);
-  if (/\b(vendor|customer|external|third[- ]party|credential|account)\b/u.test(text))
-    return classification(task, "external-input", "Task text depends on an external party or account input.", "status", true);
-  return null;
+function printJson(value) {
+  console.log(JSON.stringify(value, null, 2));
 }
-function dependencyClassification(task, badge, options) {
-  if (options.activeRunStatus === "waiting-approval")
-    return classification(task, "human-approval", "Active run is waiting for approval.", "status", true);
-  if (options.activeRunStatus === "waiting-user-input" || options.activeRunStatus === "needs-attention") {
-    return classification(task, "human-decision", "Active run is waiting for operator input or attention.", "status", true);
-  }
-  if (!badge?.blocked)
-    return null;
-  if (!options.tasksById)
-    return classification(task, "task-blocked", "Task is blocked by incomplete dependency tasks.", "elimination", true);
-  const dependencyTasks = badge.blockedBy.map((taskId) => options.tasksById?.get(taskId)).filter((value) => value !== undefined);
-  if (dependencyTasks.some((dependency) => !isTaskTerminalStatus(dependency.status))) {
-    return classification(task, "task-blocked", "Task is blocked by at least one incomplete dependency task.", "elimination", true);
-  }
-  return classification(task, "human-decision", "Task is marked blocked even though known dependencies are terminal.", "elimination", false);
+function takeFlag(args, flag) {
+  const rest = [...args];
+  const index = rest.indexOf(flag);
+  if (index < 0)
+    return { value: false, rest };
+  rest.splice(index, 1);
+  return { value: true, rest };
 }
-async function classifyResidueWithLlm(task, badge, port) {
-  const decoded = Schema.decodeUnknownSync(BlockerClassification)(await port.classify({ task, badge, residue: residue(task) }));
-  return { ...decoded, taskId: task.id, actionRiskTier: decoded.actionRiskTier ?? tierOf(decoded.blockerClass), source: "llm", autoApplied: false };
+function requireNoExtraArgs(args, usage) {
+  if (args.length > 0)
+    throw new Error(`Unexpected argument: ${args[0]}
+Usage: ${usage}`);
 }
-async function classifyBlocker(task, badges, options = {}) {
-  const badge = badges.get(task.id) ?? null;
-  const dependencyBlocked = dependencyClassification(task, badge, options);
-  if (dependencyBlocked?.blockerClass === "human-approval")
-    return dependencyBlocked;
-  const labelClassification = classifyFromLabels(task);
-  if (labelClassification)
-    return labelClassification;
-  const residueClassification = classifyFromResidue(task);
-  if (residueClassification)
-    return residueClassification;
-  if (dependencyBlocked)
-    return dependencyBlocked;
-  if (task.status === "blocked" && options.llm)
-    return classifyResidueWithLlm(task, badge, options.llm);
-  if (task.status === "blocked")
-    return classification(task, "unknown", "Task is blocked but no deterministic blocker class matched.", "elimination", false);
-  return classification(task, "not-blocked", "Task has no blocked status, dependency blocker, or blocker label.", "elimination", true);
+function isBlockerClassifierInput(input) {
+  return typeof input === "object" && input !== null && "task" in input && "badges" in input && "tasksById" in input;
 }
-function classifyBlockerSync(task, badges, options = {}) {
-  const badge = badges.get(task.id) ?? null;
-  const dependencyBlocked = dependencyClassification(task, badge, options);
-  if (dependencyBlocked?.blockerClass === "human-approval")
-    return dependencyBlocked;
-  const labelClassification = classifyFromLabels(task);
-  if (labelClassification)
-    return labelClassification;
-  const residueClassification = classifyFromResidue(task);
-  if (residueClassification)
-    return residueClassification;
-  if (dependencyBlocked)
-    return dependencyBlocked;
-  if (task.status === "blocked")
-    return classification(task, "unknown", "Task is blocked but no deterministic blocker class matched.", "elimination", false);
-  return classification(task, "not-blocked", "Task has no blocked status, dependency blocker, or blocker label.", "elimination", true);
+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 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") {
+    if (json.value)
+      printJson(details);
+    else
+      console.log(result.classifications.length === 0 ? "No blockers classified." : result.classifications.map((entry) => `${entry.taskId}	${entry.blockerClass}	${entry.actionRiskTier ?? "\u2014"}	${entry.rationale}`).join(`
+`));
+  }
+  return { ok: true, group: "blockers", command: "show", details };
 }
-// packages/blocker-classifier-plugin/src/plugin.ts
-import { definePlugin } from "@rig/core";
-var BLOCKER_CLASSIFIER_PLUGIN_NAME = "@rig/blocker-classifier-plugin";
-var BLOCKER_RECLASSIFY_STAGE_ID = "blocker-reclassify";
-var blockerReclassifyStageMutation = {
-  op: "insert",
-  contributedBy: BLOCKER_CLASSIFIER_PLUGIN_NAME,
-  stage: {
-    id: BLOCKER_RECLASSIFY_STAGE_ID,
-    kind: "observe",
-    after: ["journal-append"],
-    priority: 0,
-    protected: false
+var blockerClassifierCliCommands = [
+  {
+    id: BLOCKERS_CLI_ID,
+    family: "blockers",
+    command: "rig blockers [--human-only] [--json]",
+    description: "Classify task blockers from dependency and run state.",
+    usage: "rig blockers [--human-only] [--json]",
+    projectRequired: true,
+    run: executeBlockers
   }
-};
+];
 var blockerClassifierPlugin = definePlugin({
   name: BLOCKER_CLASSIFIER_PLUGIN_NAME,
   version: "0.0.0-alpha.1",
-  provides: [],
-  requires: [],
   contributes: {
-    stageMutations: [blockerReclassifyStageMutation]
+    capabilities: [
+      { 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 }
+    ],
+    panels: [
+      { id: HUMAN_BLOCKERS_PANEL_ID, slot: "capability", title: "Human blockers", capabilityId: "workspace.blockers" }
+    ],
+    cliCommands: blockerClassifierCliCommands.map(({ run: _run, ...metadata }) => metadata)
   }
+}, {
+  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,
+      classify(input) {
+        if (!isBlockerClassifierInput(input))
+          throw new Error("blocker classifier input must include task, badges, and tasksById.");
+        return classifyBlocker(input);
+      }
+    }
+  ],
+  cliCommands: blockerClassifierCliCommands
 });
+function createBlockerClassifierPlugin() {
+  return blockerClassifierPlugin;
+}
 export {
-  tierOf,
-  classifyResidueWithLlm,
-  classifyBlockerSync,
-  classifyBlocker,
-  blockerReclassifyStageMutation,
+  executeBlockers,
+  createBlockerClassifierPlugin,
   blockerClassifierPlugin,
-  BLOCKER_RECLASSIFY_STAGE_ID,
-  BLOCKER_CLASSIFIER_PLUGIN_NAME
+  blockerClassifierCliCommands,
+  HUMAN_BLOCKERS_PANEL_ID,
+  DEFAULT_BLOCKER_CLASSIFIER_ID,
+  BLOCKER_CLASSIFIER_PLUGIN_NAME,
+  BLOCKERS_CLI_ID
 };

package/dist/src/plugin.d.ts

@@ -1,6 +1,24 @@
-import type { StageMutation } from "@rig/contracts";
+import { type RuntimeCliContext } from "@rig/core";
 export declare const BLOCKER_CLASSIFIER_PLUGIN_NAME = "@rig/blocker-classifier-plugin";
-export declare const BLOCKER_RECLASSIFY_STAGE_ID = "blocker-reclassify";
-export declare const blockerReclassifyStageMutation: StageMutation;
+export declare const BLOCKERS_CLI_ID = "blocker-classifier.blockers";
+export declare const DEFAULT_BLOCKER_CLASSIFIER_ID = "blocker-classifier.default";
+export declare const HUMAN_BLOCKERS_PANEL_ID = "human-blockers";
+type CommandOutcome = {
+    readonly ok: boolean;
+    readonly group: string;
+    readonly command: string;
+    readonly details?: Record<string, unknown>;
+};
+export declare function executeBlockers(context: RuntimeCliContext, args: readonly string[]): Promise<CommandOutcome>;
+export declare const blockerClassifierCliCommands: readonly [{
+    readonly id: "blocker-classifier.blockers";
+    readonly family: "blockers";
+    readonly command: "rig blockers [--human-only] [--json]";
+    readonly description: "Classify task blockers from dependency and run state.";
+    readonly usage: "rig blockers [--human-only] [--json]";
+    readonly projectRequired: true;
+    readonly run: typeof executeBlockers;
+}];
 export declare const blockerClassifierPlugin: import("@rig/core").RigPluginWithRuntime;
+export declare function createBlockerClassifierPlugin(): import("@rig/core").RigPluginWithRuntime;
 export default blockerClassifierPlugin;

package/dist/src/plugin.js

@@ -1,33 +1,147 @@
 // @bun
 // packages/blocker-classifier-plugin/src/plugin.ts
 import { definePlugin } from "@rig/core";
+import {
+  classifyBlocker,
+  classifyWorkspaceBlockers,
+  listRuns,
+  listTasks
+} from "@rig/client";
 var BLOCKER_CLASSIFIER_PLUGIN_NAME = "@rig/blocker-classifier-plugin";
-var BLOCKER_RECLASSIFY_STAGE_ID = "blocker-reclassify";
-var blockerReclassifyStageMutation = {
-  op: "insert",
-  contributedBy: BLOCKER_CLASSIFIER_PLUGIN_NAME,
-  stage: {
-    id: BLOCKER_RECLASSIFY_STAGE_ID,
-    kind: "observe",
-    after: ["journal-append"],
-    priority: 0,
-    protected: false
+var BLOCKERS_CLI_ID = "blocker-classifier.blockers";
+var DEFAULT_BLOCKER_CLASSIFIER_ID = "blocker-classifier.default";
+var HUMAN_BLOCKERS_PANEL_ID = "human-blockers";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function panelProjectRoot(context) {
+  return isRecord(context) && typeof context.projectRoot === "string" && context.projectRoot.length > 0 ? context.projectRoot : null;
+}
+function taskEpicKey(task) {
+  const direct = typeof task?.epicKey === "string" ? task.epicKey : null;
+  if (direct)
+    return direct;
+  const metadata = isRecord(task?.metadata) ? task.metadata : {};
+  return typeof metadata.epicKey === "string" ? metadata.epicKey : typeof metadata.epic === "string" ? metadata.epic : null;
+}
+async function produceHumanBlockersPanel(context) {
+  const projectRoot = panelProjectRoot(context);
+  if (!projectRoot)
+    return;
+  const [tasks, blockers] = 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) => {
+      const task = tasksById.get(classification.taskId);
+      return {
+        taskId: classification.taskId,
+        title: task?.title ?? classification.taskId,
+        blockerClass: classification.blockerClass,
+        rationale: classification.rationale,
+        riskTier: classification.actionRiskTier,
+        epicKey: taskEpicKey(task),
+        autoApplied: classification.autoApplied
+      };
+    })
+  };
+}
+function printJson(value) {
+  console.log(JSON.stringify(value, null, 2));
+}
+function takeFlag(args, flag) {
+  const rest = [...args];
+  const index = rest.indexOf(flag);
+  if (index < 0)
+    return { value: false, rest };
+  rest.splice(index, 1);
+  return { value: true, rest };
+}
+function requireNoExtraArgs(args, usage) {
+  if (args.length > 0)
+    throw new Error(`Unexpected argument: ${args[0]}
+Usage: ${usage}`);
+}
+function isBlockerClassifierInput(input) {
+  return typeof input === "object" && input !== null && "task" in input && "badges" in input && "tasksById" in input;
+}
+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 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") {
+    if (json.value)
+      printJson(details);
+    else
+      console.log(result.classifications.length === 0 ? "No blockers classified." : result.classifications.map((entry) => `${entry.taskId}	${entry.blockerClass}	${entry.actionRiskTier ?? "\u2014"}	${entry.rationale}`).join(`
+`));
   }
-};
+  return { ok: true, group: "blockers", command: "show", details };
+}
+var blockerClassifierCliCommands = [
+  {
+    id: BLOCKERS_CLI_ID,
+    family: "blockers",
+    command: "rig blockers [--human-only] [--json]",
+    description: "Classify task blockers from dependency and run state.",
+    usage: "rig blockers [--human-only] [--json]",
+    projectRequired: true,
+    run: executeBlockers
+  }
+];
 var blockerClassifierPlugin = definePlugin({
   name: BLOCKER_CLASSIFIER_PLUGIN_NAME,
   version: "0.0.0-alpha.1",
-  provides: [],
-  requires: [],
   contributes: {
-    stageMutations: [blockerReclassifyStageMutation]
+    capabilities: [
+      { 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 }
+    ],
+    panels: [
+      { id: HUMAN_BLOCKERS_PANEL_ID, slot: "capability", title: "Human blockers", capabilityId: "workspace.blockers" }
+    ],
+    cliCommands: blockerClassifierCliCommands.map(({ run: _run, ...metadata }) => metadata)
   }
+}, {
+  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,
+      classify(input) {
+        if (!isBlockerClassifierInput(input))
+          throw new Error("blocker classifier input must include task, badges, and tasksById.");
+        return classifyBlocker(input);
+      }
+    }
+  ],
+  cliCommands: blockerClassifierCliCommands
 });
+function createBlockerClassifierPlugin() {
+  return blockerClassifierPlugin;
+}
 var plugin_default = blockerClassifierPlugin;
 export {
+  executeBlockers,
   plugin_default as default,
-  blockerReclassifyStageMutation,
+  createBlockerClassifierPlugin,
   blockerClassifierPlugin,
-  BLOCKER_RECLASSIFY_STAGE_ID,
-  BLOCKER_CLASSIFIER_PLUGIN_NAME
+  blockerClassifierCliCommands,
+  HUMAN_BLOCKERS_PANEL_ID,
+  DEFAULT_BLOCKER_CLASSIFIER_ID,
+  BLOCKER_CLASSIFIER_PLUGIN_NAME,
+  BLOCKERS_CLI_ID
 };

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@h-rig/blocker-classifier-plugin",
-  "version": "0.0.6-alpha.134",
+  "version": "0.0.6-alpha.137",
   "type": "module",
-  "description": "First-party human-vs-machine blocker classifier plugin for Rig.",
+  "description": "First-party blocker classifier capability plugin for Rig.",
   "license": "UNLICENSED",
   "files": [
     "dist",
@@ -13,10 +13,6 @@
       "types": "./dist/src/index.d.ts",
       "import": "./dist/src/index.js"
     },
-    "./classifier": {
-      "types": "./dist/src/classifier.d.ts",
-      "import": "./dist/src/classifier.js"
-    },
     "./plugin": {
       "types": "./dist/src/plugin.d.ts",
       "import": "./dist/src/plugin.js"
@@ -29,8 +25,8 @@
   "module": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",
   "dependencies": {
-    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.134",
-    "@rig/core": "npm:@h-rig/core@0.0.6-alpha.134",
-    "effect": "4.0.0-beta.78"
+    "@rig/client": "npm:@h-rig/client@0.0.6-alpha.137",
+    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.137",
+    "@rig/core": "npm:@h-rig/core@0.0.6-alpha.137"
   }
 }

package/dist/src/classifier.d.ts

@@ -1,19 +0,0 @@
-import { BlockerClassification, type BlockerClass, type RunStatus, type TaskSummary } from "@rig/contracts";
-import { type TaskDependencyBadgeSummary } from "@rig/core/task-graph";
-export interface ResidueClassifierPrompt {
-    readonly task: TaskSummary;
-    readonly badge: TaskDependencyBadgeSummary | null;
-    readonly residue: string;
-}
-export interface LlmResidueClassifierPort {
-    classify(prompt: ResidueClassifierPrompt): Promise<unknown> | unknown;
-}
-export interface ClassifyBlockerOptions {
-    readonly activeRunStatus?: RunStatus;
-    readonly tasksById?: ReadonlyMap<string, TaskSummary>;
-    readonly llm?: LlmResidueClassifierPort;
-}
-export declare function tierOf(blockerClass: BlockerClass): BlockerClassification["actionRiskTier"];
-export declare function classifyResidueWithLlm(task: TaskSummary, badge: TaskDependencyBadgeSummary | null, port: LlmResidueClassifierPort): Promise<BlockerClassification>;
-export declare function classifyBlocker(task: TaskSummary, badges: ReadonlyMap<string, TaskDependencyBadgeSummary>, options?: ClassifyBlockerOptions): Promise<BlockerClassification>;
-export declare function classifyBlockerSync(task: TaskSummary, badges: ReadonlyMap<string, TaskDependencyBadgeSummary>, options?: Omit<ClassifyBlockerOptions, "llm">): BlockerClassification;

package/dist/src/classifier.js

@@ -1,135 +0,0 @@
-// @bun
-// packages/blocker-classifier-plugin/src/classifier.ts
-import { Schema } from "effect";
-import { BlockerClassification } from "@rig/contracts";
-import { isTaskTerminalStatus, readTaskMetadataStringList } from "@rig/core/task-graph";
-var HUMAN_DECISION_LABEL = {
-  "human-decision": true,
-  "needs-decision": true,
-  decision: true,
-  "blocked:decision": true
-};
-var HUMAN_APPROVAL_LABEL = {
-  "human-approval": true,
-  "needs-approval": true,
-  approval: true,
-  "blocked:approval": true,
-  "review-blocked": true
-};
-var EXTERNAL_INPUT_LABEL = {
-  "external-input": true,
-  external: true,
-  vendor: true,
-  customer: true,
-  "blocked:external": true
-};
-var MACHINE_BLOCKED_LABEL = {
-  "task-blocked": true,
-  "blocked:task": true,
-  "dependency-blocked": true
-};
-function tierOf(blockerClass) {
-  if (blockerClass === "human-decision")
-    return "t2-reversible";
-  if (blockerClass === "human-approval")
-    return "t3-external";
-  if (blockerClass === "external-input")
-    return "t3-external";
-  if (blockerClass === "unknown")
-    return "t4-irreversible";
-  return null;
-}
-function classification(task, blockerClass, rationale, source, autoApplied) {
-  return { taskId: task.id, blockerClass, actionRiskTier: tierOf(blockerClass), rationale, source, autoApplied };
-}
-function normalizedLabels(task) {
-  return readTaskMetadataStringList(task, "labels").map((label) => label.trim().toLowerCase()).filter((label) => label.length > 0);
-}
-function classifyFromLabels(task) {
-  const labels = normalizedLabels(task);
-  if (labels.some((label) => HUMAN_DECISION_LABEL[label]))
-    return classification(task, "human-decision", "Task carries a human-decision blocker label.", "label", true);
-  if (labels.some((label) => HUMAN_APPROVAL_LABEL[label]))
-    return classification(task, "human-approval", "Task carries a human-approval blocker label.", "label", true);
-  if (labels.some((label) => EXTERNAL_INPUT_LABEL[label]))
-    return classification(task, "external-input", "Task carries an external-input blocker label.", "label", true);
-  if (labels.some((label) => MACHINE_BLOCKED_LABEL[label]))
-    return classification(task, "task-blocked", "Task carries a task/dependency blocker label.", "label", true);
-  return null;
-}
-function residue(task) {
-  return `${task.title}
-${task.description}`.toLowerCase();
-}
-function classifyFromResidue(task) {
-  const text = residue(task);
-  if (/\b(approval|approve|review required|sign[ -]?off)\b/u.test(text))
-    return classification(task, "human-approval", "Task text asks for approval or sign-off.", "status", true);
-  if (/\b(decide|decision|choose|clarify|question)\b/u.test(text))
-    return classification(task, "human-decision", "Task text asks for a human decision or clarification.", "status", true);
-  if (/\b(vendor|customer|external|third[- ]party|credential|account)\b/u.test(text))
-    return classification(task, "external-input", "Task text depends on an external party or account input.", "status", true);
-  return null;
-}
-function dependencyClassification(task, badge, options) {
-  if (options.activeRunStatus === "waiting-approval")
-    return classification(task, "human-approval", "Active run is waiting for approval.", "status", true);
-  if (options.activeRunStatus === "waiting-user-input" || options.activeRunStatus === "needs-attention") {
-    return classification(task, "human-decision", "Active run is waiting for operator input or attention.", "status", true);
-  }
-  if (!badge?.blocked)
-    return null;
-  if (!options.tasksById)
-    return classification(task, "task-blocked", "Task is blocked by incomplete dependency tasks.", "elimination", true);
-  const dependencyTasks = badge.blockedBy.map((taskId) => options.tasksById?.get(taskId)).filter((value) => value !== undefined);
-  if (dependencyTasks.some((dependency) => !isTaskTerminalStatus(dependency.status))) {
-    return classification(task, "task-blocked", "Task is blocked by at least one incomplete dependency task.", "elimination", true);
-  }
-  return classification(task, "human-decision", "Task is marked blocked even though known dependencies are terminal.", "elimination", false);
-}
-async function classifyResidueWithLlm(task, badge, port) {
-  const decoded = Schema.decodeUnknownSync(BlockerClassification)(await port.classify({ task, badge, residue: residue(task) }));
-  return { ...decoded, taskId: task.id, actionRiskTier: decoded.actionRiskTier ?? tierOf(decoded.blockerClass), source: "llm", autoApplied: false };
-}
-async function classifyBlocker(task, badges, options = {}) {
-  const badge = badges.get(task.id) ?? null;
-  const dependencyBlocked = dependencyClassification(task, badge, options);
-  if (dependencyBlocked?.blockerClass === "human-approval")
-    return dependencyBlocked;
-  const labelClassification = classifyFromLabels(task);
-  if (labelClassification)
-    return labelClassification;
-  const residueClassification = classifyFromResidue(task);
-  if (residueClassification)
-    return residueClassification;
-  if (dependencyBlocked)
-    return dependencyBlocked;
-  if (task.status === "blocked" && options.llm)
-    return classifyResidueWithLlm(task, badge, options.llm);
-  if (task.status === "blocked")
-    return classification(task, "unknown", "Task is blocked but no deterministic blocker class matched.", "elimination", false);
-  return classification(task, "not-blocked", "Task has no blocked status, dependency blocker, or blocker label.", "elimination", true);
-}
-function classifyBlockerSync(task, badges, options = {}) {
-  const badge = badges.get(task.id) ?? null;
-  const dependencyBlocked = dependencyClassification(task, badge, options);
-  if (dependencyBlocked?.blockerClass === "human-approval")
-    return dependencyBlocked;
-  const labelClassification = classifyFromLabels(task);
-  if (labelClassification)
-    return labelClassification;
-  const residueClassification = classifyFromResidue(task);
-  if (residueClassification)
-    return residueClassification;
-  if (dependencyBlocked)
-    return dependencyBlocked;
-  if (task.status === "blocked")
-    return classification(task, "unknown", "Task is blocked but no deterministic blocker class matched.", "elimination", false);
-  return classification(task, "not-blocked", "Task has no blocked status, dependency blocker, or blocker label.", "elimination", true);
-}
-export {
-  tierOf,
-  classifyResidueWithLlm,
-  classifyBlockerSync,
-  classifyBlocker
-};