role-os 2.0.0 → 2.2.0

package/src/evidence.mjs

@@ -146,7 +146,7 @@ const DEFAULT_REQUIREMENTS = {
  * @property {EvidenceItem[]} evidence - Structured evidence items
  * @property {string[]} gaps - What's missing or weak
  * @property {string[]} risks - Identified risks
- * @property {string} [requiredNextArtifact] - What the next role must produce (for non-approve)
+ * @property {string} [requiredNextArtifact] - What the next role must produce (for non-accept)
  * @property {string} confidence - One of CONFIDENCE_LEVELS
  */
 
@@ -182,25 +182,25 @@ export function checkSufficiency(verdict) {
     .map(e => `${e.kind}: ${e.claim} (${e.reference})`);
 
   if (contradictions.length > 0 && verdict.verdict === "accept") {
-    warnings.push("Verdict is 'approve' but evidence contains contradictions — review carefully");
+    warnings.push("Verdict is 'accept' but evidence contains contradictions — review carefully");
   }
 
-  // Check for missing evidence items on non-approve verdicts
+  // Check for missing evidence items on accept verdicts
   const missingItems = verdict.evidence.filter(e => e.status === "missing");
   if (missingItems.length > 0 && verdict.verdict === "accept") {
-    warnings.push("Verdict is 'approve' but some evidence items are marked 'missing'");
+    warnings.push("Verdict is 'accept' but some evidence items are marked 'missing'");
   }
 
-  // Non-approve verdicts should have gaps or requiredNextArtifact
-  if (verdict.verdict !== "approve" && verdict.verdict !== "accept-with-notes") {
+  // Non-accept verdicts should have gaps or requiredNextArtifact
+  if (verdict.verdict !== "accept" && verdict.verdict !== "accept-with-notes") {
     if (verdict.gaps.length === 0 && !verdict.requiredNextArtifact) {
-      warnings.push("Non-approve verdict should specify gaps or requiredNextArtifact for recovery");
+      warnings.push("Non-accept verdict should specify gaps or requiredNextArtifact for recovery");
     }
   }
 
-  // Low confidence + approve is suspicious
+  // Low confidence + accept is suspicious
   if (verdict.confidence === "low" && verdict.verdict === "accept") {
-    warnings.push("Low confidence approve — consider whether evidence is actually sufficient");
+    warnings.push("Low confidence accept — consider whether evidence is actually sufficient");
   }
 
   const sufficient = missingRequired.length === 0 && contradictions.length === 0;

package/src/mission-run.mjs

@@ -10,8 +10,7 @@
  */
 
 import { MISSIONS, getMission, validateMission } from "./mission.mjs";
-import { TEAM_PACKS } from "./packs.mjs";
-import { validateArtifact, ROLE_ARTIFACT_CONTRACTS } from "./artifacts.mjs";
+import { validateArtifact } from "./artifacts.mjs";
 
 let _runCounter = 0;
 
@@ -59,7 +58,7 @@ let _runCounter = 0;
  * @param {string} taskDescription
  * @returns {MissionRun}
  */
-export function createRun(missionKey, taskDescription) {
+export function createRun(missionKey, taskDescription, options = {}) {
   const mission = getMission(missionKey);
   if (!mission) {
     throw new Error(`Mission "${missionKey}" not found. Available: ${Object.keys(MISSIONS).join(", ")}`);
@@ -72,16 +71,26 @@ export function createRun(missionKey, taskDescription) {
 
   const id = `${missionKey}-${Date.now()}-${++_runCounter}`;
 
-  const steps = mission.artifactFlow.map((step) => ({
-    role: step.role,
-    produces: step.produces,
-    consumedBy: step.consumedBy,
-    status: "pending",
-    artifact: null,
-    note: null,
-    startedAt: null,
-    completedAt: null,
-  }));
+  let steps;
+  const dd = mission.dynamicDispatch;
+
+  if (dd && options.manifest) {
+    // Dynamic dispatch — build steps from manifest
+    steps = buildDynamicSteps(mission, options.manifest);
+  } else {
+    // Static dispatch — use artifactFlow as-is
+    steps = mission.artifactFlow.map((step) => ({
+      role: step.role,
+      produces: step.produces,
+      consumedBy: step.consumedBy,
+      status: "pending",
+      artifact: null,
+      artifactValidation: null,
+      note: null,
+      startedAt: null,
+      completedAt: null,
+    }));
+  }
 
   return {
     id,
@@ -93,9 +102,94 @@ export function createRun(missionKey, taskDescription) {
     startedAt: new Date().toISOString(),
     completedAt: null,
     completionReport: null,
+    dynamicDispatch: dd && options.manifest ? true : false,
+    manifest: options.manifest || null,
   };
 }
 
+/**
+ * Build steps from manifest for dynamic dispatch missions.
+ * @param {Object} mission
+ * @param {Object} manifest - The audit-manifest.json content
+ * @returns {MissionStep[]}
+ */
+function buildDynamicSteps(mission, manifest) {
+  const dd = mission.dynamicDispatch;
+  const steps = [];
+
+  // Scaling roles: one step per manifest entry
+  const components = manifest[dd.componentAuditorPer] || [];
+  const boundaries = manifest[dd.seamAuditorPer] || manifest.boundaries || [];
+
+  // Component Auditor × N
+  for (const comp of components) {
+    steps.push({
+      role: "Component Auditor",
+      produces: "component-audit-report",
+      consumedBy: "Audit Synthesizer",
+      parcel: comp.id || comp.name,
+      status: "pending",
+      artifact: null,
+      artifactValidation: null,
+      note: null,
+      startedAt: null,
+      completedAt: null,
+    });
+  }
+
+  // Test Truth Auditor × M
+  for (const comp of components) {
+    steps.push({
+      role: "Test Truth Auditor",
+      produces: "test-truth-report",
+      consumedBy: "Audit Synthesizer",
+      parcel: comp.id || comp.name,
+      status: "pending",
+      artifact: null,
+      artifactValidation: null,
+      note: null,
+      startedAt: null,
+      completedAt: null,
+    });
+  }
+
+  // Seam Auditor × K
+  for (const boundary of boundaries) {
+    const label = boundary.id || `${boundary.from}-${boundary.to}`;
+    steps.push({
+      role: "Seam Auditor",
+      produces: "seam-audit-report",
+      consumedBy: "Audit Synthesizer",
+      parcel: label,
+      status: "pending",
+      artifact: null,
+      artifactValidation: null,
+      note: null,
+      startedAt: null,
+      completedAt: null,
+    });
+  }
+
+  // Non-scaling roles from artifactFlow (Audit Synthesizer, Critic Reviewer)
+  for (const step of mission.artifactFlow) {
+    if (!dd.scalingRoles.includes(step.role)) {
+      steps.push({
+        role: step.role,
+        produces: step.produces,
+        consumedBy: step.consumedBy,
+        status: "pending",
+        artifact: null,
+        artifactValidation: null,
+        note: null,
+        startedAt: null,
+        completedAt: null,
+      });
+    }
+  }
+
+  return steps;
+}
+
 // ── Step through a run ──────────────────────────────────────────────────────
 
 /**
@@ -127,6 +221,10 @@ export function completeStep(run, artifact, note) {
     throw new Error("No active step to complete");
   }
 
+  // Validate artifact against role contract (warn, don't block)
+  const validation = validateArtifact(active.role, artifact);
+  active.artifactValidation = validation;
+
   active.status = "completed";
   active.artifact = artifact;
   active.note = note || null;