AI Delivery Workbench

Human approval gate

Approval for validation refuses to advance until a person records changed-file review.

const approveForValidation = async () => {
    const gate = evaluateValidationApproval({ issue, pullRequest: base, override: ov });
    const blocker = gate.blockers[0];
    if (blocker) {
      const message = {
        VERIFY_NOT_PASSED: [
          "Verification must pass",
          "A failed, stale, or incomplete Verify stage blocks validation approval.",
        ],
        REQUIRED_CHECKS_NOT_PASSED: [
          "Required checks must pass",
          "Resolve every required automated check before requesting validation approval.",
        ],
        DIFF_NOT_REVIEWED: [
          "Review the diff first",
          "Mark the changed-file diff reviewed before approving for validation.",
        ],
        REVIEW_CHECKLIST_INCOMPLETE: [
          "Complete the demo checklist",
          "Every browser-local reviewer checklist item must be checked before validation approval.",
        ],
        BOUND_APPROVAL_REQUIRED: ["Bound approval required", "A bound approval is required."],
        VALIDATION_PERSONA_REQUIRED: ["Validator required", "A distinct validator is required."],
        VALIDATION_SCENARIOS_INCOMPLETE: [
          "Validation incomplete",
          "Validation scenarios remain open.",
        ],
        VALIDATION_EVIDENCE_INCOMPLETE: [
          "Evidence incomplete",
          "Validation evidence remains open.",
        ],
        VALIDATION_ACCEPTANCE_INCOMPLETE: [
          "Acceptance incomplete",
          "Acceptance criteria remain open.",
        ],
        VALIDATION_SECURITY_INCOMPLETE: [
          "Security review incomplete",
          "Security review remains open.",
        ],
        VALIDATION_ACCESSIBILITY_INCOMPLETE: [
          "Accessibility review incomplete",
          "Accessibility review remains open.",
        ],
      } as const;
      actions.toast("warn", message[blocker.code][0], message[blocker.code][1]);
      return;
    }
    const now = new Date().toISOString();
    const validation = validationFor(issue);
    const argumentsValue = {
      issueKey: issue.key,
      testedCommit: validation.commitSha,
      decision: "release-ready",
    } as const;
    const context = await authorizeRegistryAction({
      snapshot: registrySnapshot,
      persona: personaById(state.personaId),
      stageId: "review",
      toolId: "tool.workflow.release-readiness",
      targetPaths: [],
      approvedChangeTargets: [],
      networkAccess: false,
      evidenceFinalized: true,
      effectiveSubject: issue.key,
      runId: `run.browser.${issue.key.toLocaleLowerCase()}`,
      sessionId: "session.browser.demo",
      now,
      expiresAt: new Date(Date.parse(now) + 15 * 60 * 1000).toISOString(),
      decisionId: `decision.browser.release.${issue.key.toLocaleLowerCase()}`,
    });
    actions.recordAuthorizationDecision(context.decision);
    if (context.decision.mode !== "REQUIRE_APPROVAL") {
      actions.toast(
        context.decision.allowed ? "success" : "error",
        context.decision.allowed ? "Transition allowed" : "Transition blocked",
        context.decision.explanation,
      );
      return;
    }
    const changeTargetDigest = await sha256Hex(base.files.map((file) => file.path).sort());
    const contextPackDigest = (await buildContextPack(issue.key, "review")).packDigest;
    const request = await actions.queueApproval({
      context,
      argumentsValue,
      targetPaths: [],
      changeTargetDigest,
      contextPackDigest,
      requestedAt: now,
    });
    actions.toast(
      "info",
      "Validation approval requested",
      `${request.requestId} is waiting for a distinct synthetic validator; no transition ran.`,
    );
    actions.navigate("approvals", issue.key);
  };
  /*