@h-rig/blocker-classifier-plugin 0.0.6-alpha.133

package/README.md

@@ -0,0 +1 @@
+# @h-rig/blocker-classifier-plugin

package/dist/src/classifier.d.ts

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,135 @@
+// @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
+};

package/dist/src/index.d.ts

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

package/dist/src/index.js

@@ -0,0 +1,163 @@
+// @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);
+}
+// 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 blockerClassifierPlugin = definePlugin({
+  name: BLOCKER_CLASSIFIER_PLUGIN_NAME,
+  version: "0.0.0-alpha.1",
+  provides: [],
+  requires: [],
+  contributes: {
+    stageMutations: [blockerReclassifyStageMutation]
+  }
+});
+export {
+  tierOf,
+  classifyResidueWithLlm,
+  classifyBlockerSync,
+  classifyBlocker,
+  blockerReclassifyStageMutation,
+  blockerClassifierPlugin,
+  BLOCKER_RECLASSIFY_STAGE_ID,
+  BLOCKER_CLASSIFIER_PLUGIN_NAME
+};

package/dist/src/plugin.d.ts

@@ -0,0 +1,6 @@
+import type { StageMutation } from "@rig/contracts";
+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 blockerClassifierPlugin: import("@rig/core").RigPluginWithRuntime;
+export default blockerClassifierPlugin;

package/dist/src/plugin.js

@@ -0,0 +1,33 @@
+// @bun
+// 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 blockerClassifierPlugin = definePlugin({
+  name: BLOCKER_CLASSIFIER_PLUGIN_NAME,
+  version: "0.0.0-alpha.1",
+  provides: [],
+  requires: [],
+  contributes: {
+    stageMutations: [blockerReclassifyStageMutation]
+  }
+});
+var plugin_default = blockerClassifierPlugin;
+export {
+  plugin_default as default,
+  blockerReclassifyStageMutation,
+  blockerClassifierPlugin,
+  BLOCKER_RECLASSIFY_STAGE_ID,
+  BLOCKER_CLASSIFIER_PLUGIN_NAME
+};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@h-rig/blocker-classifier-plugin",
+  "version": "0.0.6-alpha.133",
+  "type": "module",
+  "description": "First-party human-vs-machine blocker classifier plugin for Rig.",
+  "license": "UNLICENSED",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "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"
+    }
+  },
+  "engines": {
+    "bun": ">=1.3.11"
+  },
+  "main": "./dist/src/index.js",
+  "module": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "dependencies": {
+    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.133",
+    "@rig/core": "npm:@h-rig/core@0.0.6-alpha.133",
+    "effect": "4.0.0-beta.78"
+  }
+}