@haiyangbg/buildbeat 3.3.1 → 4.1.0

package/src/v2/engine/reducer.js

@@ -70,6 +70,7 @@ export function applyEvent(state, event) {
         entry: data.entry ?? null,
         planDigest: data.planDigest ?? "UNVERIFIED",
         intentDigest: data.intentDigest ?? "UNVERIFIED",
+        ...(data.deliveryChecks ? { deliveryChecks: data.deliveryChecks } : {}),
       };
       break;
     }
@@ -162,6 +163,7 @@ export function applyEvent(state, event) {
           ? { suppressedFingerprints: data.suppressedFingerprints }
           : {}),
         ...(data.cacheKey ? { cacheKey: data.cacheKey } : {}),
+        ...(data.source ? { source: data.source } : {}),
         ...(data.reused ? { reused: data.reused } : {}),
       });
       break;

package/src/v2/engine/risk-preset.js

@@ -1,48 +1,15 @@
-// Risk presets per docs/v2/RFC-0003-workflow-policy.md §7: fast / standard /
-// controlled, plus release. A preset is data —
-// human boundaries (stopAt) and a policy set — never kernel-fixed gates.
-
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-import { PolicyError, parsePolicyDoc } from "../policy/policy.js";
-import { parseYamlSubset } from "./yaml-subset.js";
-
-const PRESET_DIR = fileURLToPath(new URL("../presets/risk/", import.meta.url));
-const PRESET_FIELDS = new Set(["kind", "version", "name", "stopAt", "policies"]);
-
-export function parseRiskPreset(doc) {
-  if (!doc || typeof doc !== "object" || Array.isArray(doc)) {
-    throw new PolicyError("risk preset must be a map");
-  }
-  for (const key of Object.keys(doc)) {
-    if (!PRESET_FIELDS.has(key)) {
-      throw new PolicyError(`unknown field "${key}" in risk preset ${doc.name ?? "(unnamed)"}`);
-    }
-  }
-  if (doc.kind !== "risk-preset" || doc.version !== 1) {
-    throw new PolicyError("risk preset requires kind: risk-preset and version: 1");
-  }
-  if (typeof doc.name !== "string" || doc.name.length === 0) {
-    throw new PolicyError("risk preset needs a name");
-  }
-  const stopAt = doc.stopAt ?? [];
-  if (!Array.isArray(stopAt) || stopAt.some((step) => typeof step !== "string")) {
-    throw new PolicyError(`risk preset ${doc.name}: stopAt must be a list of step ids`);
-  }
-  const policies = (doc.policies ?? []).map((policy) => parsePolicyDoc(policy));
-  return { name: doc.name, stopAt, policies };
-}
-
-export function loadRiskPreset(name) {
-  if (!/^[a-z0-9-]+$/.test(name)) {
-    throw new PolicyError(`invalid risk preset name: ${name}`);
-  }
-  const text = readFileSync(join(PRESET_DIR, `${name}.yaml`), "utf8");
-  const preset = parseRiskPreset(parseYamlSubset(text));
-  if (preset.name !== name) {
-    throw new PolicyError(`risk preset file ${name}.yaml declares name ${preset.name}`);
-  }
-  return preset;
+// Compatibility names translate to fixed safeguards. No preset DSL is loaded.
+import { PolicyError, deliveryChecks } from "../policy/policy.js";
+export function loadRiskPreset(name, { artifact = "plan" } = {}) {
+  if (!["fast", "standard", "controlled"].includes(name))
+    throw new PolicyError(
+      `unsupported risk preset ${name}; release/custom presets are retired; see docs/MIGRATION.md`,
+    );
+  const checks = {
+    artifact,
+    requireAcceptance: name !== "fast",
+    requireIntent: name === "controlled",
+    maxSeverity: name === "controlled" ? "P3" : "P2",
+  };
+  return { name, stopAt: [], checks, policies: deliveryChecks(checks) };
 }

package/src/v2/engine/workflow.js

@@ -1,208 +1,200 @@
-// Minimal workflow parser per docs/v2/RFC-0003-workflow-policy.md §1.
-// The kernel is phase-agnostic: business steps come entirely from the
-// workflow file. Movement combines the declared step order (each step chains
-// to the next on "succeeded") with explicit transitions, which override the
-// default edge for the same (from, on) pair. Unknown fields are rejected.
-
+// Fixed delivery graph. Legacy official files are decoded only to preserve
+// their exact pinned digest and safeguards; arbitrary workflow authoring is retired.
 import { readFileSync } from "node:fs";
-
 import { parseYamlSubset } from "./yaml-subset.js";
 
-export class WorkflowError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "WorkflowError";
-  }
-}
-
-const ID_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
-const TOP_FIELDS = new Set([
-  "kind",
-  "version",
-  "name",
-  "entry",
-  "steps",
-  "transitions",
-  "terminal",
-  "policies",
-  "budgets",
+export class WorkflowError extends Error {}
+export const DELIVERY_TEXT = `kind: workflow
+version: 1
+name: software-delivery
+entry: build
+steps:
+  - id: build
+    worker: builder
+  - id: verify
+    worker: verifier
+  - id: review
+    worker: reviewer
+    readonly: true
+  - id: wait-merge
+  - id: fix
+    worker: fixer
+transitions:
+  - from: verify
+    on: failed
+    to: fix
+  - from: fix
+    on: succeeded
+    to: verify
+  - from: review
+    on: findings-blocking
+    to: fix
+terminal:
+  - wait-merge
+`;
+const CORE = ["build", "verify", "review", "wait-merge", "fix"];
+const LEGACY = ["intent", "spec", "plan", ...CORE];
+const ROLES = {
+  intent: "planner",
+  spec: "planner",
+  plan: "planner",
+  build: "builder",
+  verify: "verifier",
+  review: "reviewer",
+  fix: "fixer",
+};
+const EDGES = new Map([
+  ["build|succeeded", "verify"],
+  ["verify|succeeded", "review"],
+  ["verify|failed", "fix"],
+  ["review|succeeded", "wait-merge"],
+  ["review|findings-blocking", "fix"],
+  ["fix|succeeded", "verify"],
 ]);
-const STEP_FIELDS = new Set(["id", "worker", "optional", "requiredWhen", "readonly", "grade"]);
-const EVIDENCE_GRADES = new Set(["L0", "L1", "L2", "L3", "L4"]);
-const TRANSITION_FIELDS = new Set(["from", "on", "to"]);
-
-function rejectUnknownFields(object, allowed, where) {
-  for (const key of Object.keys(object)) {
-    if (!allowed.has(key)) {
-      throw new WorkflowError(`unknown field "${key}" in ${where}`);
-    }
-  }
-}
-
-function requireId(value, where) {
-  if (typeof value !== "string" || !ID_PATTERN.test(value)) {
-    throw new WorkflowError(`${where} must be a lowercase id, got: ${JSON.stringify(value)}`);
-  }
-  return value;
+const RETIRED =
+  "custom workflows and the release lane are retired; finish active runs with 3.3.1, then migrate using docs/MIGRATION.md";
+function reject(detail) {
+  throw new WorkflowError(`${detail}; ${RETIRED}`);
 }
-
 export function parseWorkflow(text) {
   const doc = parseYamlSubset(text);
-  if (!doc || typeof doc !== "object" || Array.isArray(doc)) {
-    throw new WorkflowError("workflow document must be a map");
-  }
-  rejectUnknownFields(doc, TOP_FIELDS, "workflow");
-  if (doc.kind !== "workflow") {
-    throw new WorkflowError(`kind must be "workflow", got: ${JSON.stringify(doc.kind)}`);
-  }
-  if (doc.version !== 1) {
-    throw new WorkflowError(`unsupported workflow version: ${JSON.stringify(doc.version)}`);
-  }
-  const name = requireId(doc.name, "name");
-  if (!Array.isArray(doc.steps) || doc.steps.length === 0) {
-    throw new WorkflowError("steps must be a non-empty list");
-  }
-
-  const steps = [];
-  const stepIds = new Set();
-  for (const raw of doc.steps) {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-      throw new WorkflowError("each step must be a map");
-    }
-    rejectUnknownFields(raw, STEP_FIELDS, `step ${JSON.stringify(raw.id)}`);
-    const id = requireId(raw.id, "step id");
-    if (stepIds.has(id)) {
-      throw new WorkflowError(`duplicate step id: ${id}`);
-    }
-    if (raw.worker !== undefined) {
-      requireId(raw.worker, `step ${id} worker`);
-    }
-    if (raw.optional !== undefined && typeof raw.optional !== "boolean") {
-      throw new WorkflowError(`step ${id} optional must be a boolean`);
-    }
-    if (raw.readonly !== undefined && typeof raw.readonly !== "boolean") {
-      throw new WorkflowError(`step ${id} readonly must be a boolean`);
-    }
-    // Evidence grade a step's command evidence is recorded at (iteration 08:
-    // release readbacks run against the real environment and are L4).
-    if (raw.grade !== undefined && !EVIDENCE_GRADES.has(raw.grade)) {
-      throw new WorkflowError(`step ${id} grade must be one of L0-L4`);
-    }
-    stepIds.add(id);
-    steps.push({
-      id,
+  if (
+    !doc ||
+    doc.kind !== "workflow" ||
+    doc.version !== 1 ||
+    doc.name !== "software-delivery"
+  )
+    reject("expected the fixed software-delivery workflow");
+  for (const key of Object.keys(doc))
+    if (
+      ![
+        "kind",
+        "version",
+        "name",
+        "entry",
+        "steps",
+        "transitions",
+        "terminal",
+        "budgets",
+        "policies",
+      ].includes(key)
+    )
+      reject(`unknown workflow field ${key}`);
+  if (!Array.isArray(doc.steps)) reject("steps must be a list");
+  const ids = doc.steps.map((step) => step?.id);
+  const legacy = JSON.stringify(ids) === JSON.stringify(LEGACY);
+  if (!legacy && JSON.stringify(ids) !== JSON.stringify(CORE))
+    reject("delivery step order changed");
+  if (doc.entry !== (legacy ? "intent" : "build"))
+    reject("workflow entry changed");
+  if (JSON.stringify(doc.terminal) !== '["wait-merge"]')
+    reject("delivery terminal changed");
+  if (
+    doc.policies !== undefined &&
+    (!Array.isArray(doc.policies) || doc.policies.length)
+  )
+    reject("workflow policies are unsupported");
+  if (doc.budgets !== undefined) {
+    if (
+      !doc.budgets ||
+      typeof doc.budgets !== "object" ||
+      Array.isArray(doc.budgets) ||
+      Object.keys(doc.budgets).some((key) => key !== "maxAttempts")
+    )
+      reject("unsupported workflow budget");
+    const attempts = doc.budgets.maxAttempts ?? {};
+    if (
+      !attempts ||
+      typeof attempts !== "object" ||
+      Array.isArray(attempts) ||
+      Object.entries(attempts).some(
+        ([step, value]) =>
+          !ids.includes(step) || !Number.isInteger(value) || value < 1,
+      )
+    )
+      reject("invalid workflow attempt budget");
+  }
+  const steps = doc.steps.map((raw) => {
+    for (const key of Object.keys(raw))
+      if (
+        ![
+          "id",
+          "worker",
+          "readonly",
+          "optional",
+          "requiredWhen",
+          "grade",
+        ].includes(key)
+      )
+        reject(`unknown step field ${key}`);
+    const spec = legacy && raw.id === "spec";
+    if (
+      (raw.worker ?? null) !== (ROLES[raw.id] ?? null) ||
+      (raw.readonly ?? false) !== (raw.id === "review") ||
+      (raw.optional ?? false) !== spec ||
+      (raw.requiredWhen ?? null) !== (spec ? "ui-delivery" : null)
+    )
+      reject(`delivery role or safeguard changed at ${raw.id}`);
+    if (
+      raw.grade !== undefined &&
+      !["L0", "L1", "L2", "L3", "L4"].includes(raw.grade)
+    )
+      reject("grade must be one of L0-L4");
+    return {
+      id: raw.id,
       worker: raw.worker ?? null,
-      optional: raw.optional ?? false,
+      readonly: raw.id === "review",
+      optional: spec,
       requiredWhen: raw.requiredWhen ?? null,
-      readonly: raw.readonly ?? false,
       grade: raw.grade ?? "L2",
-    });
-  }
-
-  const entry = requireId(doc.entry, "entry");
-  if (!stepIds.has(entry)) {
-    throw new WorkflowError(`entry references unknown step: ${entry}`);
+    };
+  });
+  const expected = new Map([
+    ["verify|failed", "fix"],
+    ["fix|succeeded", "verify"],
+    ["review|findings-blocking", "fix"],
+  ]);
+  if (
+    !Array.isArray(doc.transitions) ||
+    doc.transitions.length !== expected.size
+  )
+    reject("delivery transitions changed");
+  const seen = new Set();
+  for (const row of doc.transitions) {
+    if (!row || typeof row !== "object" || Array.isArray(row))
+      reject("invalid delivery transition");
+    const key = `${row.from}|${row.on}`;
+    if (
+      Object.keys(row).some((key) => !["from", "on", "to"].includes(key)) ||
+      expected.get(key) !== row.to ||
+      seen.has(key)
+    )
+      reject("delivery transitions changed");
+    seen.add(key);
+  }
+  const edges = new Map(EDGES);
+  if (legacy) {
+    edges.set("intent|succeeded", "spec");
+    edges.set("spec|succeeded", "plan");
+    edges.set("plan|succeeded", "build");
   }
-  if (!Array.isArray(doc.terminal) || doc.terminal.length === 0) {
-    throw new WorkflowError("terminal must be a non-empty list");
-  }
-  const terminal = new Set();
-  for (const id of doc.terminal) {
-    if (!stepIds.has(id)) {
-      throw new WorkflowError(`terminal references unknown step: ${id}`);
-    }
-    terminal.add(id);
-  }
-
-  const edges = new Map();
-  const explicit = doc.transitions ?? [];
-  if (!Array.isArray(explicit)) {
-    throw new WorkflowError("transitions must be a list");
-  }
-  for (const raw of explicit) {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-      throw new WorkflowError("each transition must be a map");
-    }
-    rejectUnknownFields(raw, TRANSITION_FIELDS, "transition");
-    const from = requireId(raw.from, "transition from");
-    const to = requireId(raw.to, "transition to");
-    if (!stepIds.has(from) || !stepIds.has(to)) {
-      throw new WorkflowError(`transition references unknown step: ${from} -> ${to}`);
-    }
-    if (typeof raw.on !== "string" || raw.on.length === 0) {
-      throw new WorkflowError(`transition ${from} -> ${to} needs a non-empty "on"`);
-    }
-    const key = `${from}|${raw.on}`;
-    if (edges.has(key)) {
-      throw new WorkflowError(`duplicate transition for (${from}, ${raw.on})`);
-    }
-    edges.set(key, to);
-  }
-
-  for (const [index, step] of steps.entries()) {
-    const key = `${step.id}|succeeded`;
-    if (terminal.has(step.id) || edges.has(key)) {
-      continue;
-    }
-    const next = steps[index + 1];
-    if (next) {
-      edges.set(key, next.id);
-    }
-  }
-
-  const outgoing = new Map();
-  for (const [key, to] of edges) {
-    const from = key.split("|")[0];
-    if (!outgoing.has(from)) {
-      outgoing.set(from, []);
-    }
-    outgoing.get(from).push(to);
-  }
-
-  const reachable = new Set([entry]);
-  const queue = [entry];
-  while (queue.length > 0) {
-    const current = queue.pop();
-    for (const to of outgoing.get(current) ?? []) {
-      if (!reachable.has(to)) {
-        reachable.add(to);
-        queue.push(to);
-      }
-    }
-  }
-  const reachesTerminal = new Set(terminal);
-  let grew = true;
-  while (grew) {
-    grew = false;
-    for (const [from, targets] of outgoing) {
-      if (!reachesTerminal.has(from) && targets.some((to) => reachesTerminal.has(to))) {
-        reachesTerminal.add(from);
-        grew = true;
-      }
-    }
-  }
-  for (const id of reachable) {
-    if (!reachesTerminal.has(id)) {
-      throw new WorkflowError(`step "${id}" has no path to a terminal step`);
-    }
-  }
-
   return {
-    name,
-    entry,
+    name: doc.name,
+    entry: doc.entry,
     steps,
-    stepIds,
-    terminal,
+    stepIds: new Set(ids),
+    terminal: new Set(["wait-merge"]),
     edges,
-    policies: doc.policies ?? [],
+    policies: [],
     budgets: doc.budgets ?? {},
   };
 }
-
 export function loadWorkflow(filePath) {
   return parseWorkflow(readFileSync(filePath, "utf8"));
 }
-
+export function deliveryWorkflow() {
+  return parseWorkflow(DELIVERY_TEXT);
+}
 export function nextStep(workflow, from, outcome) {
   return workflow.edges.get(`${from}|${outcome}`) ?? null;
 }

package/src/v2/evidence/collector.js

@@ -39,6 +39,12 @@ export function collectCommandEvidence({
     `signal: ${execResult.signal}`,
     `timedOut: ${execResult.timedOut}`,
     `spawnError: ${execResult.spawnError}`,
+    ...(execResult.requirementFailure
+      ? [`requirement: ${execResult.requirementFailure}`]
+      : []),
+    ...(execResult.screenshotsRejected?.length
+      ? [`screenshots rejected: ${execResult.screenshotsRejected.join(", ")}`]
+      : []),
     "--- stdout ---",
     scrub(execResult.stdout),
     "--- stderr ---",
@@ -50,7 +56,12 @@ export function collectCommandEvidence({
   let status;
   if (execResult.spawnError) {
     status = "unverified";
-  } else if (execResult.exitCode === 0 && !execResult.timedOut && !execResult.signal) {
+  } else if (
+    execResult.exitCode === 0 &&
+    !execResult.timedOut &&
+    !execResult.signal &&
+    !execResult.requirementFailure
+  ) {
     status = "passed";
   } else {
     status = "failed";