ai-maestro 1.0.0

package/src/orchestration/verifier.mjs

@@ -0,0 +1,1608 @@
+import { evaluateBudget } from './budget-manager.mjs';
+import { isNestedSandboxProcessFailure } from './failure-classifier.mjs';
+
+const VERIFIER_SCHEMA_VERSION = 1;
+const NEW_VERIFIER_OUTCOMES = ['verified', 'verified_with_warnings', 'rejected', 'inconclusive', 'blocked', 'needs_human'];
+const EVIDENCE_SOURCE_TYPES = [
+  'run-status',
+  'syntax-validation',
+  'workspace-diff',
+  'test-result',
+  'host-validation',
+  'failure-classification',
+  'verifier-result',
+  'diagnostics',
+  'worker-report',
+  'other'
+];
+const ACCEPTANCE_STATES = ['satisfied', 'partially_satisfied', 'not_satisfied', 'not_verifiable', 'invalid'];
+const ACCEPTANCE_MODES = [
+  'file_exists',
+  'file_changed',
+  'file_not_changed',
+  'syntax_passed',
+  'tests_passed',
+  'no_forbidden_files',
+  'no_unexpected_changes',
+  'evidence_present',
+  'host_validation_passed',
+  'manual',
+  'text_only'
+];
+const RECOMMENDATION_ACTIONS = ['complete', 'verify', 'fallback', 'fix', 'ask_human', 'block', 'none'];
+
+export const VERIFIER_OUTCOMES = NEW_VERIFIER_OUTCOMES;
+
+// Deterministic layer: reuses the same signals src/task-commands.mjs already
+// computes today (syntax validation, workspace-diff guards, tool-call
+// detection) — this is not a new detection mechanism, it's a shared verdict
+// format over the existing ones so risk>=medium tasks get a structured
+// verified/rejected/inconclusive call instead of just a task status string.
+export function runDeterministicVerification({
+  exitCode,
+  syntaxValidationFailed,
+  analysisTaskChangedCode,
+  deletedOutOfScope,
+  unsupportedToolCall,
+  suspectedFalsePositive,
+  windowsShellCommandMismatch,
+  testsRun,
+  testsPassed
+} = {}) {
+  const failures = [];
+  const warnings = [];
+  const signal = arguments[0] || {};
+  const output = [signal.output, signal.stdout, signal.stderr].filter(Boolean).join('\\n');
+  const failureCategory = signal.failureCategory || signal.validationFailureCategory;
+  if (failureCategory === 'nested_sandbox_process_failure' || isNestedSandboxProcessFailure(output)) {
+    return {
+      outcome: 'inconclusive',
+      status: 'inconclusive',
+      reason: 'Tests could not run because the sandbox blocked process creation.',
+      infrastructureFailure: true,
+      failures,
+      warnings: ['worker validation blocked by nested sandbox'],
+      source: 'deterministic'
+    };
+  }
+
+  if (typeof exitCode === 'number' && exitCode !== 0) failures.push('worker exit code was ' + exitCode);
+  if (syntaxValidationFailed) failures.push('changed file(s) failed syntax validation');
+  if (analysisTaskChangedCode) failures.push('analysis-only task changed code outside .memory/.maestro');
+  if (deletedOutOfScope) failures.push('worker deleted file(s) outside .memory/.maestro');
+  if (testsRun === true && testsPassed === false) failures.push('test run failed');
+
+  if (unsupportedToolCall) warnings.push('worker attempted an unsupported tool call');
+  if (suspectedFalsePositive) warnings.push('worker may have claimed success without a matching file change');
+  if (windowsShellCommandMismatch) warnings.push('worker used a Unix command under PowerShell');
+
+  if (failures.length > 0) {
+    return { outcome: 'rejected', status: 'rejected', failures, warnings, source: 'deterministic' };
+  }
+  if (warnings.length > 0) {
+    return { outcome: 'verified_with_warnings', status: 'verified_with_warnings', failures, warnings, source: 'deterministic' };
+  }
+  return { outcome: 'verified', status: 'verified', failures, warnings, source: 'deterministic' };
+}
+
+// Order from the spec: deterministic first, cheap model second, strong model
+// only if truly necessary. This function decides whether step 2 is even
+// warranted — a clean 'rejected' from deterministic checks needs no second
+// opinion (the failure is already conclusive), but 'verified_with_warnings'
+// or any high/critical-risk task benefits from one.
+export function needsIndependentModelCheck(classification, deterministicResult) {
+  if (!deterministicResult || deterministicResult.outcome === 'rejected') {
+    return false;
+  }
+  if (deterministicResult.outcome === 'verified_with_warnings') {
+    return true;
+  }
+  if (classification && (classification.risk === 'high' || classification.risk === 'critical')) {
+    return true;
+  }
+  if (classification && classification.verificationRequired === true && deterministicResult.outcome !== 'verified') {
+    return true;
+  }
+  return false;
+}
+
+// Ties the deterministic verdict together with an OPTIONAL model-backed
+// second opinion. This module never calls a real engine on its own — that
+// would violate "não chamar workers reais desnecessariamente" for anything
+// that merely imports this file (including tests). A second opinion only
+// happens if the caller explicitly passes `options.runEngineFn`, and even
+// then only after budget/policy allows it.
+export async function verifyTaskResult({ task, classification, runSignals = {}, options = {} } = {}) {
+  const deterministic = runDeterministicVerification(runSignals);
+
+  if (options.skipModelVerification || !needsIndependentModelCheck(classification, deterministic)) {
+    return { ...deterministic, modelVerification: null };
+  }
+
+  if (typeof options.runEngineFn !== 'function') {
+    return {
+      outcome: deterministic.outcome === 'verified' ? 'inconclusive' : deterministic.outcome,
+      failures: deterministic.failures,
+      warnings: [...deterministic.warnings, 'independent model verification recommended but no runEngineFn was provided'],
+      source: 'deterministic',
+      modelVerification: null
+    };
+  }
+
+  const budgetResult = await evaluateBudget({
+    engineRecord: options.verifierEngineRecord || null,
+    ...(options.budgetContext || {})
+  });
+  if (!budgetResult.allowed) {
+    return {
+      outcome: deterministic.outcome === 'verified' ? 'inconclusive' : deterministic.outcome,
+      failures: deterministic.failures,
+      warnings: [...deterministic.warnings, 'independent model verification skipped: ' + budgetResult.reason],
+      source: 'deterministic',
+      modelVerification: null
+    };
+  }
+
+  const modelResult = await options.runEngineFn({ task, classification, deterministic });
+  const outcome = modelResult && VERIFIER_OUTCOMES.includes(modelResult.outcome) ? modelResult.outcome : 'inconclusive';
+  return {
+    outcome,
+    failures: deterministic.failures,
+    warnings: deterministic.warnings,
+    source: 'deterministic+model',
+    modelVerification: modelResult || null
+  };
+}
+
+export function verifySubtaskResult(input) {
+  assertPlainApiObject(input, 'input');
+  if (!isNonBlankString(input.subtaskId)) {
+    throw new TypeError('subtaskId must be a non-empty string');
+  }
+  if (!Object.prototype.hasOwnProperty.call(input, 'runId')) {
+    throw new TypeError('runId key is required');
+  }
+  if (!(input.runId === null || isNonBlankString(input.runId))) {
+    throw new TypeError('runId must be a non-empty string or null');
+  }
+  for (const field of ['expectedFiles', 'forbiddenFiles', 'warnings', 'acceptanceCriteria']) {
+    if (input[field] !== undefined && !Array.isArray(input[field])) {
+      throw new TypeError(`${field} must be an array`);
+    }
+  }
+
+  const ctx = createVerificationContext('subtask');
+  const subtaskId = input.subtaskId;
+  const runId = input.runId;
+  const run = isPlainObject(input.run) ? input.run : null;
+  const runStatus = stringOrNull(input.runStatus) || stringOrNull(run && run.status);
+  const task = isPlainObject(input.task) ? input.task : null;
+  const subtask = isPlainObject(input.subtask) ? input.subtask : null;
+  const expectedFiles = normalizePathArray(input.expectedFiles || task && task.files || subtask && subtask.expectedFiles || []);
+  const forbiddenFiles = normalizePathArray(input.forbiddenFiles || []);
+  const noChangeExpected = input.noChangeExpected === true ||
+    (task && task.noChangeExpected === true) ||
+    (subtask && subtask.noChangeExpected === true);
+
+  for (const warning of input.warnings || []) {
+    if (typeof warning === 'string') ctx.warnings.push(warning);
+  }
+
+  analyzeRunAssociation(ctx, { subtaskId, runId, runStatus, noExecutionReason: input.noExecutionReason });
+  analyzeRunStatus(ctx, { subtaskId, runId, runStatus });
+  analyzeWorkspaceDiff(ctx, {
+    subtaskId,
+    runId,
+    workspaceDiff: input.workspaceDiff,
+    expectedFiles,
+    forbiddenFiles,
+    noChangeExpected,
+    task
+  });
+  analyzeSyntaxChecks(ctx, { subtaskId, runId, syntaxChecks: input.syntaxChecks });
+  analyzeTestResults(ctx, { subtaskId, runId, testResults: input.testResults });
+  analyzeHostValidation(ctx, { subtaskId, runId, hostValidation: input.hostValidation });
+  analyzeDiagnostics(ctx, { subtaskId, runId, diagnostics: input.diagnostics });
+  analyzeFailureClassification(ctx, { subtaskId, runId, failureClassification: input.failureClassification });
+  analyzeExecutionContext(ctx, { subtaskId, runId, executionContext: input.executionContext });
+
+  const acceptance = verifyAcceptanceCriteria({
+    criteria: input.acceptanceCriteria || [],
+    evidenceBundle: buildAcceptanceEvidenceBundle({
+      acceptedEvidence: ctx.acceptedEvidence,
+      rejectedEvidence: ctx.rejectedEvidence,
+      missingEvidence: ctx.missingEvidence,
+      contradictoryEvidence: ctx.contradictoryEvidence,
+      workspaceDiff: input.workspaceDiff,
+      expectedFiles,
+      forbiddenFiles,
+      syntaxChecks: input.syntaxChecks,
+      testResults: input.testResults,
+      hostValidation: input.hostValidation
+    }),
+    options: cloneData(input.options || {})
+  });
+  ctx.acceptanceCriteriaResults.push(...acceptance.results);
+  ctx.errors.push(...acceptance.errors);
+  ctx.warnings.push(...acceptance.warnings);
+  applyAcceptanceOutcome(ctx, acceptance);
+
+  if (acceptedNonRunEvidenceCount(ctx) === 0 && ctx.acceptanceCriteriaResults.length === 0 &&
+      !ctx.blocked && !ctx.needsHuman && !ctx.hasCodeFailure && !ctx.hasInfrastructureFailure) {
+    ctx.missingEvidence.push(evidenceDecision({
+      evidenceId: `missing:${subtaskId}:${runId ?? 'none'}:deterministic-evidence`,
+      sourceType: 'other',
+      subtaskId,
+      runId,
+      rule: 'deterministic-evidence-required',
+      reason: 'No deterministic evidence was provided for the subtask result.',
+      originalEvidence: null
+    }));
+  }
+
+  return finalizeVerificationResult(ctx, {
+    scope: 'subtask',
+    subtaskId,
+    runId,
+    recommendedAction: defaultRecommendationForContext(ctx)
+  });
+}
+
+export function verifyConsolidatedResult(input) {
+  assertPlainApiObject(input, 'input');
+  if (!isPlainObject(input.consolidatedResult)) {
+    throw new TypeError('consolidatedResult must be an object');
+  }
+  const consolidated = input.consolidatedResult;
+  const ctx = createVerificationContext('consolidated');
+
+  const taskId = typeof consolidated.taskId === 'string' ? consolidated.taskId : null;
+  const completeness = stringOrNull(consolidated.consolidationCompleteness);
+  const status = stringOrNull(consolidated.status);
+  if (!['complete', 'partial', 'invalid'].includes(completeness)) {
+    ctx.errors.push('consolidationCompleteness is missing or invalid');
+    ctx.structuralInvalid = true;
+  }
+  if (!['accepted', 'accepted_with_warnings', 'rejected', 'inconclusive', 'needs_human'].includes(status)) {
+    ctx.errors.push('consolidated status is missing or unknown');
+    ctx.structuralInvalid = true;
+  }
+
+  ctx.warnings.push(...stringArrayOrError(ctx, consolidated.warnings, 'warnings'));
+  ctx.errors.push(...stringArrayOrError(ctx, consolidated.inputErrors, 'inputErrors'));
+  ctx.conflicts.push(...stringArrayOrError(ctx, consolidated.conflicts, 'conflicts'));
+  ctx.inconsistencies.push(...stringArrayOrError(ctx, consolidated.inconsistencies, 'inconsistencies'));
+  ctx.invalidReferences.push(...stringArrayOrError(ctx, consolidated.invalidReferences, 'invalidReferences'));
+  ctx.failures.push(...stringArrayOrError(ctx, consolidated.failures, 'failures'));
+  ctx.codeFailures.push(...stringArrayOrError(ctx, consolidated.codeFailures, 'codeFailures'));
+  ctx.infrastructureFailures.push(...stringArrayOrError(ctx, consolidated.infrastructureFailures, 'infrastructureFailures'));
+
+  if (ctx.codeFailures.length > 0) {
+    ctx.hasCodeFailure = true;
+  }
+  if (ctx.infrastructureFailures.length > 0) {
+    ctx.hasInfrastructureFailure = true;
+  }
+  if (completeness === 'invalid' || countArray(consolidated.inputErrors) > 0) {
+    ctx.structuralInvalid = true;
+  }
+  if (completeness === 'partial') {
+    ctx.partial = true;
+  }
+  if (ctx.conflicts.length > 0 || ctx.inconsistencies.length > 0) {
+    ctx.contradictory = true;
+  }
+  if (ctx.invalidReferences.length > 0) {
+    ctx.structuralInvalid = true;
+  }
+
+  const consolidatedEvidence = objectArrayOrError(ctx, consolidated.evidence, 'evidence');
+  const consolidatedMissingEvidence = objectArrayOrError(ctx, consolidated.missingEvidence, 'missingEvidence');
+  const consolidatedPerSubtask = objectArrayOrError(ctx, consolidated.perSubtask, 'perSubtask');
+
+  for (const item of consolidatedEvidence) {
+    ctx.acceptedEvidence.push(evidenceDecisionFromRaw(item, {
+      rule: 'consolidated-evidence-preserved',
+      reason: 'Evidence produced by the Consolidator was preserved for verification.',
+      relatedCriterionId: null
+    }));
+  }
+  for (const item of consolidatedMissingEvidence) {
+    ctx.missingEvidence.push(evidenceDecisionFromRaw(item, {
+      rule: 'consolidated-missing-evidence-preserved',
+      reason: objectReason(item, 'Missing evidence reported by the Consolidator.'),
+      relatedCriterionId: stringOrNull(item && item.criterionId)
+    }));
+  }
+
+  for (const item of consolidatedPerSubtask) {
+    const subtaskId = stringOrNull(item.subtaskId);
+    const runId = normalizeRunId(item.runId);
+    const observedState = stringOrNull(item.observedState);
+    if (observedState === 'blocked') {
+      ctx.blocked = true;
+      ctx.failures.push(`Subtask ${subtaskId ?? '(unknown)'} is blocked`);
+    } else if (observedState === 'needs_human') {
+      ctx.needsHuman = true;
+      ctx.failures.push(`Subtask ${subtaskId ?? '(unknown)'} needs human decision`);
+    } else if (observedState === 'failed') {
+      if (item.infrastructureFailure === true) {
+        ctx.hasInfrastructureFailure = true;
+        ctx.infrastructureFailures.push(`Subtask ${subtaskId ?? '(unknown)'} failed due to infrastructure`);
+      } else {
+        ctx.hasCodeFailure = true;
+        ctx.codeFailures.push(`Subtask ${subtaskId ?? '(unknown)'} failed`);
+      }
+    } else if (observedState === 'missing') {
+      ctx.missingEvidence.push(evidenceDecision({
+        evidenceId: `missing:${subtaskId ?? 'unknown'}:${runId ?? 'none'}:subtask-result`,
+        sourceType: 'verifier-result',
+        subtaskId,
+        runId,
+        rule: 'subtask-result-required',
+        reason: 'Subtask result is missing.',
+        originalEvidence: item
+      }));
+    } else if (observedState === 'contradictory') {
+      ctx.contradictory = true;
+      ctx.contradictoryEvidence.push(evidenceDecision({
+        evidenceId: `contradictory:${subtaskId ?? 'unknown'}:${runId ?? 'none'}:subtask-result`,
+        sourceType: 'verifier-result',
+        subtaskId,
+        runId,
+        rule: 'subtask-signals-contradict',
+        reason: 'Subtask execution signals are contradictory.',
+        originalEvidence: item
+      }));
+    } else if (observedState === 'invalid') {
+      ctx.structuralInvalid = true;
+      ctx.invalidReferences.push(`Subtask ${subtaskId ?? '(unknown)'} has invalid execution association`);
+    }
+    pushStrings(ctx.warnings, item.warnings);
+    pushStrings(ctx.failures, item.failures);
+  }
+
+  const acceptance = verifyAcceptanceCriteria({
+    criteria: Array.isArray(input.acceptanceCriteria) ? input.acceptanceCriteria : [],
+    evidenceBundle: {
+      acceptedEvidence: ctx.acceptedEvidence,
+      missingEvidence: ctx.missingEvidence,
+      evidence: consolidatedEvidence
+    },
+    options: cloneData(input.options || {})
+  });
+  ctx.acceptanceCriteriaResults.push(...acceptance.results);
+  ctx.errors.push(...acceptance.errors);
+  ctx.warnings.push(...acceptance.warnings);
+  applyAcceptanceOutcome(ctx, acceptance);
+
+  if (isNonBlankString(consolidated.recommendedNextAction)) {
+    ctx.recommendations.push({
+      action: normalizeRecommendationAction(consolidated.recommendedNextAction),
+      reason: 'Recommendation copied from Consolidator as consultative metadata.',
+      consultative: true
+    });
+  }
+
+  return finalizeVerificationResult(ctx, {
+    scope: 'consolidated',
+    taskId,
+    consolidatedStatus: status,
+    consolidationCompleteness: completeness,
+    recommendedAction: defaultRecommendationForContext(ctx)
+  });
+}
+
+export function verifyAcceptanceCriteria(input) {
+  assertPlainApiObject(input, 'input');
+  if (input.criteria !== undefined && !Array.isArray(input.criteria)) {
+    throw new TypeError('criteria must be an array');
+  }
+  if (input.evidenceBundle !== undefined && !isPlainObject(input.evidenceBundle)) {
+    throw new TypeError('evidenceBundle must be an object');
+  }
+  const criteria = input.criteria || [];
+  const evidenceBundle = input.evidenceBundle || {};
+  const evidence = normalizeEvidenceBundle(evidenceBundle);
+  const errors = [];
+  const warnings = [];
+  const seenIds = new Set();
+  const results = [];
+
+  criteria.forEach((criterion, index) => {
+    const normalized = normalizeCriterion(criterion, index);
+    if (!normalized.valid) {
+      errors.push(normalized.reason);
+      results.push(criterionResult({
+        id: normalized.id,
+        description: normalized.description,
+        required: normalized.required,
+        verificationMode: normalized.verificationMode,
+        state: 'invalid',
+        reason: normalized.reason
+      }));
+      return;
+    }
+    if (seenIds.has(normalized.id)) {
+      const reason = `duplicate criterion id: ${normalized.id}`;
+      errors.push(reason);
+      results.push(criterionResult({
+        ...normalized,
+        state: 'invalid',
+        reason
+      }));
+      return;
+    }
+    seenIds.add(normalized.id);
+
+    const evaluated = evaluateCriterion(normalized, evidence, evidenceBundle);
+    results.push(evaluated);
+    if (evaluated.required !== true && evaluated.state !== 'satisfied') {
+      warnings.push(`optional criterion ${evaluated.id} is ${evaluated.state}`);
+    }
+  });
+
+  const sortedResults = [...results].sort(compareCriterionResults);
+  const summary = {
+    satisfied: sortedResults.filter(item => item.state === 'satisfied').length,
+    partiallySatisfied: sortedResults.filter(item => item.state === 'partially_satisfied').length,
+    notSatisfied: sortedResults.filter(item => item.state === 'not_satisfied').length,
+    notVerifiable: sortedResults.filter(item => item.state === 'not_verifiable').length,
+    invalid: sortedResults.filter(item => item.state === 'invalid').length,
+    requiredUnsatisfied: sortedResults.filter(item => item.required === true && item.state !== 'satisfied').length
+  };
+
+  let verificationOutcome = 'verified';
+  if (sortedResults.some(item => item.required === true && item.state === 'not_satisfied')) {
+    verificationOutcome = 'rejected';
+  } else if (sortedResults.some(item => item.required === true && item.verificationMode === 'manual')) {
+    verificationOutcome = 'needs_human';
+  } else if (sortedResults.some(item => item.required === true && item.state !== 'satisfied')) {
+    verificationOutcome = 'inconclusive';
+  } else if (warnings.length > 0) {
+    verificationOutcome = 'verified_with_warnings';
+  }
+
+  return {
+    schemaVersion: VERIFIER_SCHEMA_VERSION,
+    scope: 'acceptance',
+    verificationOutcome,
+    outcome: verificationOutcome,
+    results: sortedResults,
+    summary,
+    errors: uniqueSorted(errors),
+    warnings: uniqueSorted(warnings)
+  };
+}
+
+function createVerificationContext(scope) {
+  return {
+    scope,
+    errors: [],
+    warnings: [],
+    acceptedEvidence: [],
+    rejectedEvidence: [],
+    missingEvidence: [],
+    contradictoryEvidence: [],
+    acceptanceCriteriaResults: [],
+    failures: [],
+    codeFailures: [],
+    infrastructureFailures: [],
+    failureClassifications: [],
+    conflicts: [],
+    inconsistencies: [],
+    invalidReferences: [],
+    recommendations: [],
+    hasForbiddenChange: false,
+    hasCodeFailure: false,
+    hasInfrastructureFailure: false,
+    hostValidationPassed: false,
+    needsHuman: false,
+    blocked: false,
+    structuralInvalid: false,
+    contradictory: false,
+    partial: false
+  };
+}
+
+function assertPlainApiObject(value, name) {
+  if (!isPlainObject(value)) {
+    throw new TypeError(`${name} must be an object`);
+  }
+}
+
+function analyzeRunAssociation(ctx, { subtaskId, runId, runStatus, noExecutionReason }) {
+  if (runId === null) {
+    if (runStatus === 'blocked' && noExecutionReason === 'blocked_before_execution') {
+      return;
+    }
+    if (runStatus === 'needs_human' && noExecutionReason === 'needs_human_before_execution') {
+      return;
+    }
+    if ((runStatus === null || runStatus === undefined) &&
+        (noExecutionReason === 'not_executed' || noExecutionReason === 'result_missing')) {
+      ctx.missingEvidence.push(evidenceDecision({
+        evidenceId: `missing:${subtaskId}:none:${noExecutionReason}`,
+        sourceType: 'run-status',
+        subtaskId,
+        runId,
+        rule: 'no-execution-declared',
+        reason: `No execution occurred: ${noExecutionReason}.`,
+        originalEvidence: { runStatus: runStatus ?? null, noExecutionReason }
+      }));
+      return;
+    }
+    ctx.invalidReferences.push(`invalid run association for ${subtaskId}: runId null requires a coherent noExecutionReason`);
+    ctx.structuralInvalid = true;
+  }
+}
+
+function analyzeRunStatus(ctx, { subtaskId, runId, runStatus }) {
+  if (!runStatus) return;
+  ctx.acceptedEvidence.push(evidenceDecision({
+    evidenceId: `run-status:${subtaskId}:${runId ?? 'none'}`,
+    sourceType: 'run-status',
+    subtaskId,
+    runId,
+    sourceId: runId,
+    sourceIdentifier: runStatus,
+    rule: 'run-status-preserved',
+    reason: `Runtime reported status ${runStatus}.`,
+    originalEvidence: { status: runStatus }
+  }));
+  if (runStatus === 'failed') {
+    ctx.hasCodeFailure = true;
+    ctx.codeFailures.push(`Subtask ${subtaskId} run failed`);
+  } else if (runStatus === 'blocked') {
+    ctx.blocked = true;
+    ctx.failures.push(`Subtask ${subtaskId} is blocked`);
+  } else if (runStatus === 'needs_human') {
+    ctx.needsHuman = true;
+    ctx.failures.push(`Subtask ${subtaskId} needs human decision`);
+  } else if (runStatus === 'completed_with_warnings') {
+    ctx.warnings.push(`Subtask ${subtaskId} completed with warnings`);
+  } else if (!['completed', 'completed_with_warnings', 'failed', 'blocked', 'needs_human'].includes(runStatus)) {
+    ctx.invalidReferences.push(`unknown runStatus ${runStatus}`);
+    ctx.structuralInvalid = true;
+  }
+}
+
+function analyzeWorkspaceDiff(ctx, { subtaskId, runId, workspaceDiff, expectedFiles, forbiddenFiles, noChangeExpected, task }) {
+  if (workspaceDiff === null || workspaceDiff === undefined) {
+    if (expectedFiles.length > 0) {
+      ctx.missingEvidence.push(evidenceDecision({
+        evidenceId: `missing:${subtaskId}:${runId ?? 'none'}:workspace-diff`,
+        sourceType: 'workspace-diff',
+        subtaskId,
+        runId,
+        rule: 'workspace-diff-required',
+        reason: 'Workspace diff evidence is required for expected files.',
+        originalEvidence: null
+      }));
+    }
+    return;
+  }
+  if (!isPlainObject(workspaceDiff)) {
+    ctx.errors.push('workspaceDiff must be an object when provided');
+    ctx.structuralInvalid = true;
+    return;
+  }
+  const changed = normalizePathArray(workspaceDiff.changedFiles || []);
+  const created = normalizePathArray(workspaceDiff.createdFiles || []);
+  const deleted = normalizePathArray(workspaceDiff.deletedFiles || []);
+  const outOfScope = normalizePathArray(workspaceDiff.outOfScopeChanges || []);
+  const allChanged = uniqueSorted([...changed, ...created, ...deleted, ...outOfScope]);
+  const expectedSet = new Set(expectedFiles);
+  const forbiddenSet = new Set(forbiddenFiles);
+
+  for (const file of allChanged) {
+    const kind = deleted.includes(file) ? 'deleted' : created.includes(file) ? 'created' : 'changed';
+    const decision = evidenceDecision({
+      evidenceId: `workspace:${kind}:${file}`,
+      sourceType: 'workspace-diff',
+      subtaskId,
+      runId,
+      sourceId: file,
+      sourceIdentifier: file,
+      provenance: { field: `${kind}Files` },
+      rule: `workspace-file-${kind}`,
+      reason: `Workspace file was ${kind}: ${file}.`,
+      originalEvidence: { file, kind }
+    });
+    if (forbiddenSet.has(file) || outOfScope.includes(file) || isSensitiveOrOutsidePath(file)) {
+      ctx.rejectedEvidence.push({
+        ...decision,
+        rule: 'forbidden-or-out-of-scope-change',
+        reason: `File change is forbidden or outside scope: ${file}.`
+      });
+      ctx.errors.push(`forbidden or out-of-scope file changed: ${file}`);
+      ctx.hasForbiddenChange = true;
+    } else {
+      ctx.acceptedEvidence.push(decision);
+      if (!expectedSet.has(file) && expectedFiles.length > 0) {
+        ctx.warnings.push(`unexpected file changed: ${file}`);
+      }
+    }
+  }
+
+  for (const file of expectedFiles) {
+    if (changed.includes(file) || created.includes(file)) {
+      continue;
+    }
+    if (deleted.includes(file)) {
+      ctx.rejectedEvidence.push(evidenceDecision({
+        evidenceId: `workspace:deleted-expected:${file}`,
+        sourceType: 'workspace-diff',
+        subtaskId,
+        runId,
+        sourceId: file,
+        sourceIdentifier: file,
+        rule: 'expected-file-deleted',
+        reason: `Expected file was deleted: ${file}.`,
+        originalEvidence: { file, kind: 'deleted' }
+      }));
+      ctx.hasCodeFailure = true;
+      ctx.codeFailures.push(`expected file was deleted: ${file}`);
+    } else {
+      ctx.missingEvidence.push(evidenceDecision({
+        evidenceId: `missing:expected-file:${file}`,
+        sourceType: 'workspace-diff',
+        subtaskId,
+        runId,
+        sourceId: file,
+        sourceIdentifier: file,
+        rule: 'expected-file-not-changed',
+        reason: `Expected file has no verified change: ${file}.`,
+        originalEvidence: { file }
+      }));
+    }
+  }
+
+  const changedFlag = workspaceDiff.workspaceChanged === true || allChanged.length > 0;
+  if (!changedFlag && !noChangeExpected && expectedFiles.length === 0 && taskLooksLikeWrite(task)) {
+    ctx.missingEvidence.push(evidenceDecision({
+      evidenceId: `missing:${subtaskId}:${runId ?? 'none'}:write-without-files`,
+      sourceType: 'workspace-diff',
+      subtaskId,
+      runId,
+      rule: 'write-task-needs-diff',
+      reason: 'Task appears to require writing but no changed files or expected files were provided.',
+      originalEvidence: cloneData(workspaceDiff)
+    }));
+  }
+}
+
+function analyzeSyntaxChecks(ctx, { subtaskId, runId, syntaxChecks }) {
+  const entries = normalizeCheckEntries(syntaxChecks, 'syntaxValidation');
+  for (const entry of entries) {
+    const sourceId = stringOrNull(entry.path) || stringOrNull(entry.file) || stringOrNull(entry.sourceId) || 'syntax';
+    const status = checkStatus(entry);
+    const decision = evidenceDecision({
+      evidenceId: `syntax:${sourceId}`,
+      sourceType: 'syntax-validation',
+      subtaskId,
+      runId,
+      sourceId,
+      sourceIdentifier: sourceId,
+      rule: `syntax-${status}`,
+      reason: `Syntax check ${status} for ${sourceId}.`,
+      originalEvidence: entry
+    });
+    if (status === 'passed' || status === 'not_applicable') {
+      ctx.acceptedEvidence.push(decision);
+    } else if (status === 'failed') {
+      ctx.rejectedEvidence.push(decision);
+      ctx.hasCodeFailure = true;
+      ctx.codeFailures.push(`syntax check failed: ${sourceId}`);
+    } else if (status === 'blocked_by_infrastructure') {
+      ctx.hasInfrastructureFailure = true;
+      ctx.infrastructureFailures.push(`syntax check blocked by infrastructure: ${sourceId}`);
+      ctx.missingEvidence.push({ ...decision, reason: `Syntax check blocked by infrastructure for ${sourceId}.` });
+    } else {
+      ctx.missingEvidence.push({ ...decision, reason: `Syntax check was not run for ${sourceId}.` });
+    }
+  }
+}
+
+function analyzeTestResults(ctx, { subtaskId, runId, testResults }) {
+  const entries = normalizeCheckEntries(testResults, 'tests');
+  for (const entry of entries) {
+    const sourceId = stringOrNull(entry.commandId) || stringOrNull(entry.name) || stringOrNull(entry.sourceId) || 'tests';
+    const status = testStatus(entry);
+    const decision = evidenceDecision({
+      evidenceId: `test:${sourceId}`,
+      sourceType: 'test-result',
+      subtaskId,
+      runId,
+      sourceId,
+      sourceIdentifier: sourceId,
+      rule: `tests-${status}`,
+      reason: `Test result ${status} for ${sourceId}.`,
+      originalEvidence: entry
+    });
+    if (status === 'passed' || status === 'not_applicable') {
+      ctx.acceptedEvidence.push(decision);
+    } else if (status === 'failed') {
+      ctx.rejectedEvidence.push(decision);
+      ctx.hasCodeFailure = true;
+      ctx.codeFailures.push(`test run failed: ${sourceId}`);
+    } else if (status === 'blocked_by_infrastructure') {
+      ctx.hasInfrastructureFailure = true;
+      ctx.infrastructureFailures.push(`test run blocked by infrastructure: ${sourceId}`);
+      ctx.missingEvidence.push({ ...decision, reason: `Test did not start because infrastructure blocked it: ${sourceId}.` });
+    } else {
+      ctx.missingEvidence.push({ ...decision, reason: `Test did not run: ${sourceId}.` });
+    }
+  }
+}
+
+function analyzeHostValidation(ctx, { subtaskId, runId, hostValidation }) {
+  const entries = normalizeCheckEntries(hostValidation, 'results');
+  for (const entry of entries) {
+    const sourceId = stringOrNull(entry.commandId) || stringOrNull(entry.sourceId) || 'host-validation';
+    const result = hostValidationStatus(entry);
+    const decision = evidenceDecision({
+      evidenceId: `host:${sourceId}`,
+      sourceType: 'host-validation',
+      subtaskId,
+      runId,
+      sourceId,
+      sourceIdentifier: sourceId,
+      provenance: entry.metadata ? { metadata: cloneData(entry.metadata) } : null,
+      rule: `host-validation-${result}`,
+      reason: `Host validation ${result} for ${sourceId}.`,
+      originalEvidence: entry
+    });
+    if (result === 'passed') {
+      ctx.hostValidationPassed = true;
+      ctx.acceptedEvidence.push(decision);
+      if (ctx.hasInfrastructureFailure) {
+        ctx.warnings.push(`host validation passed for ${sourceId}; original infrastructure failure preserved`);
+      }
+    } else if (result === 'failed') {
+      ctx.rejectedEvidence.push(decision);
+      ctx.hasHostValidationFailure = true;
+    } else if (result === 'blocked') {
+      ctx.blocked = true;
+      ctx.rejectedEvidence.push(decision);
+    } else {
+      ctx.missingEvidence.push(decision);
+    }
+  }
+}
+
+function analyzeDiagnostics(ctx, { subtaskId, runId, diagnostics }) {
+  if (!isPlainObject(diagnostics)) return;
+  pushStrings(ctx.warnings, diagnostics.warnings);
+  if (diagnostics.suspectedFalsePositive === true) {
+    ctx.contradictory = true;
+    ctx.contradictoryEvidence.push(evidenceDecision({
+      evidenceId: `diagnostics:${subtaskId}:${runId ?? 'none'}:suspected-false-positive`,
+      sourceType: 'diagnostics',
+      subtaskId,
+      runId,
+      rule: 'diagnostics-false-positive',
+      reason: 'Diagnostics indicate the worker claimed success without matching deterministic evidence.',
+      originalEvidence: diagnostics
+    }));
+  }
+  if (diagnostics.explicitWorkerFailure === true) {
+    ctx.hasCodeFailure = true;
+    ctx.codeFailures.push('worker explicitly reported failure');
+    ctx.rejectedEvidence.push(evidenceDecision({
+      evidenceId: `diagnostics:${subtaskId}:${runId ?? 'none'}:explicit-worker-failure`,
+      sourceType: 'diagnostics',
+      subtaskId,
+      runId,
+      rule: 'diagnostics-explicit-worker-failure',
+      reason: 'Diagnostics indicate the worker explicitly reported it could not complete the task.',
+      originalEvidence: diagnostics
+    }));
+  }
+  if (diagnostics.unsupportedToolCall === true) {
+    ctx.warnings.push('worker used an unsupported tool call');
+  }
+  if (diagnostics.windowsShellCommandMismatch === true) {
+    ctx.warnings.push('worker used a Unix command under PowerShell');
+  }
+}
+
+function analyzeFailureClassification(ctx, { subtaskId, runId, failureClassification }) {
+  if (!isPlainObject(failureClassification)) return;
+  ctx.failureClassifications.push(cloneData(failureClassification));
+  const category = stringOrNull(failureClassification.category);
+  ctx.acceptedEvidence.push(evidenceDecision({
+    evidenceId: `failure-classification:${category ?? 'unknown'}:${subtaskId}:${runId ?? 'none'}`,
+    sourceType: 'failure-classification',
+    subtaskId,
+    runId,
+    sourceIdentifier: category,
+    rule: 'failure-classification-preserved',
+    reason: `Failure classification preserved: ${category ?? 'unknown'}.`,
+    originalEvidence: failureClassification
+  }));
+  if (category === 'syntax_failure' || category === 'test_failure') {
+    ctx.hasCodeFailure = true;
+    ctx.codeFailures.push(`failure classification: ${category}`);
+  } else if (category === 'needs_human' || failureClassification.shouldAskHuman === true) {
+    ctx.needsHuman = true;
+  } else if (['policy_violation', 'budget_exceeded', 'safety_blocked', 'insufficient_capability', 'missing_tool'].includes(category)) {
+    ctx.blocked = true;
+  } else if (failureClassification.infrastructureFailure === true ||
+      category === 'nested_sandbox_process_failure' ||
+      category === 'windows_sandbox_acl_failure') {
+    ctx.hasInfrastructureFailure = true;
+    ctx.infrastructureFailures.push(`infrastructure failure classification: ${category ?? 'unknown'}`);
+  } else if (category === 'suspected_false_positive') {
+    ctx.contradictory = true;
+  }
+  pushStrings(ctx.failures, failureClassification.reason);
+}
+
+function analyzeExecutionContext(ctx, { subtaskId, runId, executionContext }) {
+  if (!isPlainObject(executionContext)) return;
+  const runtimeGate = executionContext.runtimeGate;
+  if (isPlainObject(runtimeGate)) {
+    if (runtimeGate.decision === 'NEEDS_HUMAN' || runtimeGate.status === 'NEEDS_HUMAN') {
+      ctx.needsHuman = true;
+    } else if (runtimeGate.decision === 'BLOCK' || runtimeGate.status === 'BLOCK') {
+      ctx.blocked = true;
+    }
+  }
+  if (isPlainObject(executionContext.policy) && executionContext.policy.ok === false) {
+    ctx.blocked = true;
+    ctx.rejectedEvidence.push(evidenceDecision({
+      evidenceId: `execution-context:${subtaskId}:${runId ?? 'none'}:policy`,
+      sourceType: 'other',
+      subtaskId,
+      runId,
+      rule: 'policy-block',
+      reason: 'Execution context policy blocks automatic approval.',
+      originalEvidence: executionContext.policy
+    }));
+  }
+}
+
+function applyAcceptanceOutcome(ctx, acceptance) {
+  if (acceptance.outcome === 'needs_human') {
+    ctx.needsHuman = true;
+  } else if (acceptance.outcome === 'rejected') {
+    ctx.hasCodeFailure = true;
+    ctx.codeFailures.push('required acceptance criterion was not satisfied');
+  } else if (acceptance.outcome === 'inconclusive') {
+    ctx.partial = true;
+  } else if (acceptance.outcome === 'verified_with_warnings') {
+    ctx.warnings.push('optional acceptance criterion is not fully satisfied');
+  }
+}
+
+function finalizeVerificationResult(ctx, extra) {
+  const failureInformation = {
+    failures: uniqueSorted([...ctx.failures, ...ctx.codeFailures, ...ctx.infrastructureFailures]),
+    codeFailures: uniqueSorted(ctx.codeFailures),
+    infrastructureFailures: uniqueSorted(ctx.infrastructureFailures),
+    failureClassifications: cloneData(ctx.failureClassifications)
+  };
+  let verificationOutcome = decideVerificationOutcome(ctx, failureInformation);
+  verificationOutcome = applyConsolidatedStatusCeiling(verificationOutcome, extra.consolidatedStatus, ctx);
+
+  const recommendations = [
+    ...ctx.recommendations,
+    {
+      action: normalizeRecommendationAction(extra.recommendedAction || recommendationForOutcome(verificationOutcome)),
+      reason: recommendationReason(verificationOutcome),
+      consultative: true
+    }
+  ];
+
+  return {
+    schemaVersion: VERIFIER_SCHEMA_VERSION,
+    scope: extra.scope,
+    ...(extra.taskId !== undefined ? { taskId: extra.taskId } : {}),
+    ...(extra.subtaskId !== undefined ? { subtaskId: extra.subtaskId } : {}),
+    ...(Object.prototype.hasOwnProperty.call(extra, 'runId') ? { runId: extra.runId } : {}),
+    verificationOutcome,
+    outcome: verificationOutcome,
+    verified: verificationOutcome === 'verified',
+    errors: uniqueSorted(ctx.errors),
+    warnings: uniqueSorted(ctx.warnings),
+    acceptedEvidence: sortEvidenceDecisions(ctx.acceptedEvidence),
+    rejectedEvidence: sortEvidenceDecisions(ctx.rejectedEvidence),
+    missingEvidence: sortEvidenceDecisions(ctx.missingEvidence),
+    contradictoryEvidence: sortEvidenceDecisions(ctx.contradictoryEvidence),
+    acceptanceCriteriaResults: [...ctx.acceptanceCriteriaResults].sort(compareCriterionResults).map(item => cloneData(item)),
+    failureInformation,
+    conflicts: uniqueSorted(ctx.conflicts),
+    inconsistencies: uniqueSorted(ctx.inconsistencies),
+    invalidReferences: uniqueSorted(ctx.invalidReferences),
+    recommendations: sortRecommendations(recommendations),
+    summary: summarizeVerification({ scope: extra.scope, verificationOutcome, ctx, failureInformation }),
+    source: 'verifier'
+  };
+}
+
+function decideVerificationOutcome(ctx, failureInformation) {
+  if (ctx.hasForbiddenChange) return 'rejected';
+  if (ctx.hasCodeFailure || failureInformation.codeFailures.length > 0) return 'rejected';
+  if (ctx.needsHuman) return 'needs_human';
+  if (ctx.blocked) return 'blocked';
+  if (failureInformation.failures.length > 0 && !ctx.hasInfrastructureFailure && failureInformation.infrastructureFailures.length === 0) {
+    return 'inconclusive';
+  }
+  if (ctx.structuralInvalid || ctx.invalidReferences.length > 0 || ctx.errors.length > 0) return 'inconclusive';
+  if (ctx.contradictory || ctx.conflicts.length > 0 || ctx.inconsistencies.length > 0 || ctx.contradictoryEvidence.length > 0) {
+    return 'inconclusive';
+  }
+  if (ctx.missingEvidence.length > 0 || ctx.partial || ctx.hasHostValidationFailure) {
+    return 'inconclusive';
+  }
+  if (ctx.hasInfrastructureFailure || failureInformation.infrastructureFailures.length > 0) {
+    return ctx.hostValidationPassed ? 'verified_with_warnings' : 'inconclusive';
+  }
+  if (ctx.warnings.length > 0) return 'verified_with_warnings';
+  return 'verified';
+}
+
+function applyConsolidatedStatusCeiling(outcome, status, ctx) {
+  if (!status) return outcome;
+  if (outcome === 'blocked' && ctx.blocked && !ctx.needsHuman) {
+    return outcome;
+  }
+  if (status === 'needs_human') {
+    return outcome === 'rejected' ? 'rejected' : 'needs_human';
+  }
+  if (status === 'rejected') {
+    return 'rejected';
+  }
+  if (status === 'inconclusive' && (outcome === 'verified' || outcome === 'verified_with_warnings')) {
+    return 'inconclusive';
+  }
+  if (status === 'accepted_with_warnings' && outcome === 'verified') {
+    return 'verified_with_warnings';
+  }
+  return outcome;
+}
+
+function normalizeCriterion(criterion, index) {
+  if (typeof criterion === 'string') {
+    return {
+      valid: true,
+      id: `criterion:${index}`,
+      description: criterion,
+      required: true,
+      evidenceRequirements: [],
+      verificationMode: 'text_only',
+      metadata: {},
+      legacyText: true
+    };
+  }
+  if (!isPlainObject(criterion)) {
+    return {
+      valid: false,
+      id: `criterion:${index}`,
+      description: '',
+      required: true,
+      verificationMode: 'text_only',
+      reason: `criterion ${index} must be a string or object`
+    };
+  }
+  const id = stringOrNull(criterion.id);
+  const description = stringOrNull(criterion.description);
+  const verificationMode = stringOrNull(criterion.verificationMode) || 'text_only';
+  if (!id) {
+    return invalidCriterion(index, criterion, 'criterion object must include a non-empty id');
+  }
+  if (!description) {
+    return invalidCriterion(index, criterion, `criterion ${id} must include a non-empty description`);
+  }
+  if (!ACCEPTANCE_MODES.includes(verificationMode)) {
+    return {
+      valid: false,
+      id,
+      description,
+      required: criterion.required !== false,
+      verificationMode,
+      reason: `unknown verification mode for ${id}: ${verificationMode}`
+    };
+  }
+  if (criterion.evidenceRequirements !== undefined && !Array.isArray(criterion.evidenceRequirements)) {
+    return {
+      valid: false,
+      id,
+      description,
+      required: criterion.required !== false,
+      verificationMode,
+      reason: `criterion ${id} evidenceRequirements must be an array`
+    };
+  }
+  return {
+    valid: true,
+    id,
+    description,
+    required: criterion.required !== false,
+    evidenceRequirements: cloneData(criterion.evidenceRequirements || []),
+    verificationMode,
+    metadata: isPlainObject(criterion.metadata) ? cloneData(criterion.metadata) : {}
+  };
+}
+
+function invalidCriterion(index, criterion, reason) {
+  return {
+    valid: false,
+    id: stringOrNull(criterion && criterion.id) || `criterion:${index}`,
+    description: stringOrNull(criterion && criterion.description) || '',
+    required: criterion && criterion.required === false ? false : true,
+    verificationMode: stringOrNull(criterion && criterion.verificationMode) || 'text_only',
+    reason
+  };
+}
+
+function evaluateCriterion(criterion, evidence, evidenceBundle) {
+  if (criterion.verificationMode === 'manual') {
+    return criterionResult({
+      ...criterion,
+      state: 'not_verifiable',
+      reason: 'Manual verification requires a human decision.'
+    });
+  }
+  if (criterion.verificationMode === 'text_only') {
+    const rule = evidenceBundle.criteriaRules && evidenceBundle.criteriaRules[criterion.id];
+    if (isPlainObject(rule) && ACCEPTANCE_STATES.includes(rule.state)) {
+      return criterionResult({
+        ...criterion,
+        state: rule.state,
+        evidenceRefs: normalizeStringArray(rule.evidenceRefs || []),
+        reason: stringOrNull(rule.reason) || 'Structured criteria rule supplied the result.'
+      });
+    }
+    return criterionResult({
+      ...criterion,
+      state: 'not_verifiable',
+      reason: 'Text-only criterion has no deterministic verification rule.'
+    });
+  }
+
+  const relatedEvidence = evidence.items.filter(item => criterionEvidenceMatches(item, criterion.id));
+  const wrongRelated = evidence.items.filter(item => item.relatedCriterionId && item.relatedCriterionId !== criterion.id);
+  const requirementValues = criterion.evidenceRequirements.flatMap(requirementValuesFrom);
+
+  if (criterion.verificationMode === 'file_exists') {
+    return evaluateFileCriterion(criterion, evidence.filesExisting, evidence.filesDeleted, requirementValues, 'exists');
+  }
+  if (criterion.verificationMode === 'file_changed') {
+    return evaluateFileCriterion(criterion, evidence.filesChanged, evidence.filesDeleted, requirementValues, 'changed');
+  }
+  if (criterion.verificationMode === 'file_not_changed') {
+    return evaluateFileNotChangedCriterion(criterion, evidence, requirementValues);
+  }
+  if (criterion.verificationMode === 'syntax_passed') {
+    return evaluateStatusCriterion(criterion, evidence.syntax, 'syntax');
+  }
+  if (criterion.verificationMode === 'tests_passed') {
+    return evaluateStatusCriterion(criterion, evidence.tests, 'tests');
+  }
+  if (criterion.verificationMode === 'host_validation_passed') {
+    return evaluateStatusCriterion(criterion, evidence.hostValidation, 'host validation');
+  }
+  if (criterion.verificationMode === 'no_forbidden_files') {
+    const changed = evidence.forbiddenChanged;
+    return criterionResult({
+      ...criterion,
+      state: changed.length > 0 ? 'not_satisfied' : 'satisfied',
+      evidenceRefs: changed,
+      reason: changed.length > 0 ? `Forbidden files changed: ${changed.join(', ')}` : 'No forbidden file changes were reported.'
+    });
+  }
+  if (criterion.verificationMode === 'no_unexpected_changes') {
+    const unexpected = evidence.unexpectedChanged;
+    return criterionResult({
+      ...criterion,
+      state: unexpected.length > 0 ? 'not_satisfied' : 'satisfied',
+      evidenceRefs: unexpected,
+      reason: unexpected.length > 0 ? `Unexpected files changed: ${unexpected.join(', ')}` : 'No unexpected changes were reported.'
+    });
+  }
+  if (criterion.verificationMode === 'evidence_present') {
+    if (wrongRelated.length > 0 && relatedEvidence.length === 0 && requirementValues.length > 0) {
+      return criterionResult({
+        ...criterion,
+        state: 'not_satisfied',
+        missingEvidence: requirementValues,
+        reason: 'Evidence exists only for a different criterion.'
+      });
+    }
+    const presentIds = new Set(relatedEvidence.map(item => item.id));
+    const missing = requirementValues.filter(id => !presentIds.has(id));
+    return criterionResult({
+      ...criterion,
+      state: missing.length === 0 && relatedEvidence.length > 0 ? 'satisfied' :
+        (missing.length < requirementValues.length && relatedEvidence.length > 0 ? 'partially_satisfied' : 'not_verifiable'),
+      evidenceRefs: [...presentIds],
+      missingEvidence: missing,
+      reason: missing.length === 0 && relatedEvidence.length > 0 ? 'Required evidence is present.' : 'Required evidence is missing.'
+    });
+  }
+  return criterionResult({
+    ...criterion,
+    state: 'invalid',
+    reason: `unsupported verification mode: ${criterion.verificationMode}`
+  });
+}
+
+function evaluateFileCriterion(criterion, positiveFiles, deletedFiles, requirements, verb) {
+  const files = requirements.length > 0 ? requirements : positiveFiles;
+  const present = files.filter(file => positiveFiles.includes(file));
+  const deleted = files.filter(file => deletedFiles.includes(file));
+  const missing = files.filter(file => !positiveFiles.includes(file));
+  if (deleted.length > 0) {
+    return criterionResult({
+      ...criterion,
+      state: 'not_satisfied',
+      evidenceRefs: deleted,
+      missingEvidence: missing,
+      reason: `Required file was deleted: ${deleted.join(', ')}.`
+    });
+  }
+  if (files.length === 0) {
+    return criterionResult({ ...criterion, state: 'not_verifiable', reason: `No file evidence is available for ${verb}.` });
+  }
+  return criterionResult({
+    ...criterion,
+    state: missing.length === 0 ? 'satisfied' : present.length > 0 ? 'partially_satisfied' : 'not_satisfied',
+    evidenceRefs: present,
+    missingEvidence: missing,
+    reason: missing.length === 0 ? `Required file ${verb} evidence is present.` : `Missing file ${verb} evidence: ${missing.join(', ')}.`
+  });
+}
+
+function evaluateFileNotChangedCriterion(criterion, evidence, requirements) {
+  const files = requirements.length > 0 ? requirements : evidence.filesExisting;
+  const changed = files.filter(file => evidence.filesChanged.includes(file) || evidence.filesDeleted.includes(file));
+  if (files.length === 0) {
+    return criterionResult({ ...criterion, state: 'not_verifiable', reason: 'No file evidence is available for unchanged check.' });
+  }
+  return criterionResult({
+    ...criterion,
+    state: changed.length === 0 ? 'satisfied' : 'not_satisfied',
+    evidenceRefs: files.filter(file => !changed.includes(file)),
+    missingEvidence: changed,
+    reason: changed.length === 0 ? 'Required files were not changed.' : `Files changed but should not have: ${changed.join(', ')}.`
+  });
+}
+
+function evaluateStatusCriterion(criterion, statuses, label) {
+  if (statuses.failed.length > 0) {
+    return criterionResult({
+      ...criterion,
+      state: 'not_satisfied',
+      evidenceRefs: statuses.failed,
+      reason: `${label} failed.`
+    });
+  }
+  if (statuses.passed.length > 0) {
+    return criterionResult({
+      ...criterion,
+      state: statuses.missing.length > 0 ? 'partially_satisfied' : 'satisfied',
+      evidenceRefs: statuses.passed,
+      missingEvidence: statuses.missing,
+      reason: statuses.missing.length > 0 ? `${label} passed partially; some evidence is missing.` : `${label} passed.`
+    });
+  }
+  return criterionResult({
+    ...criterion,
+    state: statuses.blocked.length > 0 ? 'not_verifiable' : 'not_verifiable',
+    evidenceRefs: statuses.blocked,
+    missingEvidence: statuses.missing.length > 0 ? statuses.missing : [`${label}:missing`],
+    reason: statuses.blocked.length > 0 ? `${label} was blocked by infrastructure.` : `${label} evidence is missing.`
+  });
+}
+
+function normalizeEvidenceBundle(bundle) {
+  const workspaceDiff = isPlainObject(bundle.workspaceDiff) ? bundle.workspaceDiff : {};
+  const changed = normalizePathArray([...(workspaceDiff.changedFiles || []), ...(workspaceDiff.createdFiles || [])]);
+  const deleted = normalizePathArray(workspaceDiff.deletedFiles || []);
+  const expectedFiles = normalizePathArray(bundle.expectedFiles || []);
+  const forbiddenFiles = normalizePathArray(bundle.forbiddenFiles || []);
+  const accepted = arrayOrEmpty(bundle.acceptedEvidence);
+  const rejected = arrayOrEmpty(bundle.rejectedEvidence);
+  const rawEvidence = arrayOrEmpty(bundle.evidence);
+  const items = [...accepted, ...rejected, ...rawEvidence].map((item, index) => normalizeEvidenceItem(item, index));
+  const forbiddenChanged = changed.concat(deleted).filter(file => forbiddenFiles.includes(file) || isSensitiveOrOutsidePath(file));
+  const unexpectedChanged = expectedFiles.length > 0
+    ? changed.concat(deleted).filter(file => !expectedFiles.includes(file) && !forbiddenFiles.includes(file))
+    : normalizePathArray(bundle.unexpectedFiles || []);
+
+  return {
+    items,
+    filesChanged: uniqueSorted([...changed, ...items.filter(item => item.sourceType === 'workspace-diff').map(item => normalizePath(stringOrNull(item.sourceId) || '')).filter(Boolean)]),
+    filesDeleted: uniqueSorted(deleted),
+    filesExisting: uniqueSorted([...changed, ...normalizePathArray(bundle.existingFiles || [])]),
+    forbiddenChanged: uniqueSorted([...(bundle.forbiddenChanged || []), ...forbiddenChanged].map(normalizePath).filter(Boolean)),
+    unexpectedChanged: uniqueSorted(unexpectedChanged),
+    syntax: collectStatuses(bundle.syntaxChecks, 'syntaxValidation'),
+    tests: collectStatuses(bundle.testResults, 'tests'),
+    hostValidation: collectHostValidationStatuses(bundle.hostValidation)
+  };
+}
+
+function normalizeEvidenceItem(item, index) {
+  const raw = isPlainObject(item) ? item : { value: item };
+  const id = stringOrNull(raw.evidenceId) || stringOrNull(raw.id) || stringOrNull(raw.sourceId) || `evidence:${index}`;
+  return {
+    id,
+    sourceType: normalizeSourceType(raw.sourceType || raw.type),
+    relatedCriterionId: stringOrNull(raw.relatedCriterionId) || stringOrNull(raw.criterionId),
+    sourceId: stringOrNull(raw.sourceId) || stringOrNull(raw.sourceIdentifier),
+    raw
+  };
+}
+
+function collectStatuses(value, nestedField) {
+  const entries = normalizeCheckEntries(value, nestedField);
+  const statuses = { passed: [], failed: [], missing: [], blocked: [] };
+  entries.forEach((entry, index) => {
+    const id = stringOrNull(entry.evidenceId) || stringOrNull(entry.id) || stringOrNull(entry.path) || stringOrNull(entry.commandId) || `${nestedField}:${index}`;
+    const status = nestedField === 'tests' ? testStatus(entry) : checkStatus(entry);
+    if (status === 'passed' || status === 'not_applicable') statuses.passed.push(id);
+    else if (status === 'failed') statuses.failed.push(id);
+    else if (status === 'blocked_by_infrastructure') statuses.blocked.push(id);
+    else statuses.missing.push(id);
+  });
+  return mapStatusArrays(statuses);
+}
+
+function collectHostValidationStatuses(value) {
+  const entries = normalizeCheckEntries(value, 'results');
+  const statuses = { passed: [], failed: [], missing: [], blocked: [] };
+  entries.forEach((entry, index) => {
+    const id = stringOrNull(entry.commandId) || stringOrNull(entry.evidenceId) || `host:${index}`;
+    const status = hostValidationStatus(entry);
+    if (status === 'passed') statuses.passed.push(id);
+    else if (status === 'failed') statuses.failed.push(id);
+    else if (status === 'blocked') statuses.blocked.push(id);
+    else statuses.missing.push(id);
+  });
+  return mapStatusArrays(statuses);
+}
+
+function mapStatusArrays(statuses) {
+  return {
+    passed: uniqueSorted(statuses.passed),
+    failed: uniqueSorted(statuses.failed),
+    missing: uniqueSorted(statuses.missing),
+    blocked: uniqueSorted(statuses.blocked)
+  };
+}
+
+function criterionResult(input) {
+  return {
+    id: String(input.id),
+    description: String(input.description || ''),
+    required: input.required !== false,
+    verificationMode: String(input.verificationMode || 'text_only'),
+    state: ACCEPTANCE_STATES.includes(input.state) ? input.state : 'invalid',
+    evidenceRefs: uniqueSorted(input.evidenceRefs || []),
+    missingEvidence: uniqueSorted(input.missingEvidence || []),
+    reason: String(input.reason || '')
+  };
+}
+
+function evidenceDecisionFromRaw(raw, { rule, reason, relatedCriterionId }) {
+  const item = isPlainObject(raw) ? raw : { value: raw };
+  return evidenceDecision({
+    evidenceId: stringOrNull(item.evidenceId) || stringOrNull(item.id) || stringOrNull(item.sourceId) || canonicalStringify(item),
+    sourceType: normalizeSourceType(item.sourceType || item.type || item.kind),
+    subtaskId: stringOrNull(item.subtaskId),
+    runId: normalizeRunId(item.runId),
+    sourceId: stringOrNull(item.sourceId),
+    sourceIdentifier: stringOrNull(item.sourceIdentifier) || stringOrNull(item.field),
+    provenance: isPlainObject(item.provenance) ? item.provenance : null,
+    rule,
+    reason,
+    relatedCriterionId,
+    originalEvidence: Object.prototype.hasOwnProperty.call(item, 'value') ? item.value : item
+  });
+}
+
+function evidenceDecision(input) {
+  return {
+    evidenceId: String(input.evidenceId || 'evidence'),
+    sourceType: normalizeSourceType(input.sourceType),
+    subtaskId: input.subtaskId === undefined ? null : stringOrNull(input.subtaskId),
+    runId: input.runId === undefined ? null : normalizeRunId(input.runId),
+    sourceId: input.sourceId === undefined ? null : stringOrNull(input.sourceId),
+    sourceIdentifier: input.sourceIdentifier === undefined ? null : stringOrNull(input.sourceIdentifier),
+    provenance: input.provenance === undefined ? null : cloneData(input.provenance),
+    rule: String(input.rule || 'unspecified'),
+    reason: String(input.reason || ''),
+    relatedCriterionId: input.relatedCriterionId === undefined ? null : stringOrNull(input.relatedCriterionId),
+    originalEvidence: input.originalEvidence === undefined ? null : cloneData(input.originalEvidence)
+  };
+}
+
+function buildAcceptanceEvidenceBundle({ acceptedEvidence, rejectedEvidence, missingEvidence, contradictoryEvidence, workspaceDiff, expectedFiles, forbiddenFiles, syntaxChecks, testResults, hostValidation }) {
+  return {
+    acceptedEvidence: cloneData(acceptedEvidence),
+    rejectedEvidence: cloneData(rejectedEvidence),
+    missingEvidence: cloneData(missingEvidence),
+    contradictoryEvidence: cloneData(contradictoryEvidence),
+    workspaceDiff: cloneData(workspaceDiff),
+    expectedFiles: cloneData(expectedFiles),
+    forbiddenFiles: cloneData(forbiddenFiles),
+    syntaxChecks: cloneData(syntaxChecks),
+    testResults: cloneData(testResults),
+    hostValidation: cloneData(hostValidation)
+  };
+}
+
+function normalizeCheckEntries(value, nestedField) {
+  if (value === null || value === undefined) return [];
+  if (Array.isArray(value)) return value.filter(isPlainObject).map(item => cloneData(item));
+  if (isPlainObject(value)) {
+    if (Array.isArray(value[nestedField])) return value[nestedField].filter(isPlainObject).map(item => cloneData(item));
+    if (Array.isArray(value.results)) return value.results.filter(isPlainObject).map(item => cloneData(item));
+    return [cloneData(value)];
+  }
+  return [];
+}
+
+function checkStatus(entry) {
+  if (entry.ok === true || entry.passed === true || entry.status === 'passed' || entry.result === 'passed') return 'passed';
+  if (entry.ok === false || entry.passed === false || entry.status === 'failed' || entry.result === 'failed') return 'failed';
+  if (entry.status === 'not_applicable' || entry.result === 'not_applicable' || entry.skipped === true) return 'not_applicable';
+  if (entry.status === 'blocked_by_infrastructure' || entry.infrastructureFailure === true) return 'blocked_by_infrastructure';
+  return 'not_run';
+}
+
+function testStatus(entry) {
+  if (entry.ran === true && entry.passed === true) return 'passed';
+  if (entry.ran === true && entry.passed === false) return 'failed';
+  if (entry.status === 'passed' || entry.result === 'passed') return 'passed';
+  if (entry.status === 'failed' || entry.result === 'failed') return 'failed';
+  if (entry.status === 'not_applicable' || entry.result === 'not_applicable') return 'not_applicable';
+  if (entry.ran === false && (entry.infrastructureFailure === true || entry.status === 'blocked_by_infrastructure')) return 'blocked_by_infrastructure';
+  if (entry.ran === false || entry.status === 'not_run') return 'not_run';
+  if (entry.infrastructureFailure === true) return 'blocked_by_infrastructure';
+  return 'not_run';
+}
+
+function hostValidationStatus(entry) {
+  if (entry.result === 'passed' || entry.ok === true) return 'passed';
+  if (entry.result === 'failed' || entry.ok === false) return 'failed';
+  if (entry.result === 'blocked' || entry.blocked === true || entry.allowed === false) return 'blocked';
+  return 'not_run';
+}
+
+function requirementValuesFrom(requirement) {
+  if (typeof requirement === 'string') return [normalizePath(requirement) || requirement];
+  if (!isPlainObject(requirement)) return [];
+  return [
+    requirement.id,
+    requirement.evidenceId,
+    requirement.sourceId,
+    requirement.path,
+    requirement.file
+  ].filter(value => typeof value === 'string').map(value => normalizePath(value) || value);
+}
+
+function criterionEvidenceMatches(item, criterionId) {
+  return !item.relatedCriterionId || item.relatedCriterionId === criterionId;
+}
+
+function defaultRecommendationForContext(ctx) {
+  const outcome = decideVerificationOutcome(ctx, {
+    failures: uniqueSorted([...ctx.failures, ...ctx.codeFailures, ...ctx.infrastructureFailures]),
+    codeFailures: ctx.codeFailures,
+    infrastructureFailures: ctx.infrastructureFailures
+  });
+  return recommendationForOutcome(outcome);
+}
+
+function recommendationForOutcome(outcome) {
+  if (outcome === 'verified') return 'complete';
+  if (outcome === 'verified_with_warnings' || outcome === 'inconclusive') return 'verify';
+  if (outcome === 'rejected') return 'fix';
+  if (outcome === 'needs_human') return 'ask_human';
+  if (outcome === 'blocked') return 'block';
+  return 'none';
+}
+
+function recommendationReason(outcome) {
+  if (outcome === 'verified') return 'Verification evidence is sufficient.';
+  if (outcome === 'verified_with_warnings') return 'Verification evidence is sufficient with warnings preserved.';
+  if (outcome === 'rejected') return 'Deterministic verification found a blocking failure.';
+  if (outcome === 'needs_human') return 'A human decision is required.';
+  if (outcome === 'blocked') return 'An objective blocker prevents automatic approval.';
+  return 'Additional verification is required.';
+}
+
+function normalizeRecommendationAction(action) {
+  return RECOMMENDATION_ACTIONS.includes(action) ? action : 'verify';
+}
+
+function summarizeVerification({ scope, verificationOutcome, ctx, failureInformation }) {
+  const issueCount = uniqueSorted([
+    ...ctx.errors,
+    ...ctx.invalidReferences,
+    ...ctx.conflicts,
+    ...ctx.inconsistencies,
+    ...failureInformation.failures,
+    ...ctx.missingEvidence.map(item => item.reason)
+  ]).length;
+  return `Verification ${verificationOutcome}: ${scope}, ${ctx.acceptedEvidence.length} accepted evidence item(s), ${issueCount} issue(s).`;
+}
+
+function acceptedNonRunEvidenceCount(ctx) {
+  return ctx.acceptedEvidence.filter(item => item.sourceType !== 'run-status').length;
+}
+
+function sortEvidenceDecisions(values) {
+  return values.map(item => cloneData(item)).sort((a, b) =>
+    compareStrings(a.subtaskId ?? '', b.subtaskId ?? '') ||
+    compareStrings(a.runId ?? '', b.runId ?? '') ||
+    compareStrings(a.evidenceId, b.evidenceId) ||
+    compareStrings(a.relatedCriterionId ?? '', b.relatedCriterionId ?? '') ||
+    compareStrings(a.rule, b.rule)
+  );
+}
+
+function compareCriterionResults(a, b) {
+  return compareStrings(a.id, b.id) ||
+    compareStrings(a.verificationMode, b.verificationMode) ||
+    compareStrings(a.reason, b.reason);
+}
+
+function sortRecommendations(values) {
+  return values.map(item => cloneData(item)).sort((a, b) =>
+    compareStrings(a.action, b.action) ||
+    compareStrings(a.reason, b.reason)
+  );
+}
+
+function stringArrayOrError(ctx, value, field) {
+  if (value === undefined) return [];
+  if (!Array.isArray(value)) {
+    ctx.errors.push(`${field} must be an array`);
+    ctx.structuralInvalid = true;
+    return [];
+  }
+  return normalizeStringArray(value);
+}
+
+function objectArrayOrError(ctx, value, field) {
+  if (value === undefined) return [];
+  if (!Array.isArray(value)) {
+    ctx.errors.push(`${field} must be an array`);
+    ctx.structuralInvalid = true;
+    return [];
+  }
+  const entries = [];
+  value.forEach((item, index) => {
+    if (!isPlainObject(item)) {
+      ctx.errors.push(`${field}[${index}] must be an object`);
+      ctx.structuralInvalid = true;
+      return;
+    }
+    entries.push(item);
+  });
+  return entries;
+}
+
+function pushStrings(target, values) {
+  if (!Array.isArray(values)) return;
+  for (const value of values) {
+    if (typeof value === 'string') target.push(value);
+  }
+}
+
+function normalizeStringArray(values) {
+  return Array.isArray(values) ? values.filter(value => typeof value === 'string') : [];
+}
+
+function normalizePathArray(values) {
+  return Array.isArray(values) ? uniqueSorted(values.map(normalizePath).filter(Boolean)) : [];
+}
+
+function normalizePath(value) {
+  if (typeof value !== 'string') return null;
+  const normalized = value.replace(/\\/g, '/').replace(/^\.\//, '').trim();
+  return normalized || null;
+}
+
+function isSensitiveOrOutsidePath(file) {
+  const normalized = normalizePath(file) || '';
+  const lower = normalized.toLowerCase();
+  return lower === '.env' ||
+    lower.endsWith('/.env') ||
+    lower.includes('/.env/') ||
+    lower.includes('secret') ||
+    lower.includes('token') ||
+    normalized.startsWith('../') ||
+    normalized.includes('/../') ||
+    normalized.startsWith('/') ||
+    /^[A-Za-z]:\//.test(normalized);
+}
+
+function taskLooksLikeWrite(task) {
+  if (!isPlainObject(task)) return false;
+  const text = `${task.title || ''} ${task.description || ''}`.toLowerCase();
+  return /\b(implement|create|update|modify|fix|add|write|editar|alterar|criar|corrigir|implementar)\b/.test(text);
+}
+
+function objectReason(item, fallback) {
+  return isPlainObject(item) && typeof item.reason === 'string' ? item.reason : fallback;
+}
+
+function normalizeRunId(value) {
+  return isNonBlankString(value) ? value : null;
+}
+
+function stringOrNull(value) {
+  return typeof value === 'string' && value.trim().length > 0 ? value : null;
+}
+
+function normalizeSourceType(value) {
+  return EVIDENCE_SOURCE_TYPES.includes(value) ? value : 'other';
+}
+
+function uniqueSorted(values) {
+  return [...new Set((values || []).filter(value => typeof value === 'string'))].sort(compareStrings);
+}
+
+function arrayOrEmpty(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function countArray(value) {
+  return Array.isArray(value) ? value.length : 0;
+}
+
+function isPlainObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function isNonBlankString(value) {
+  return typeof value === 'string' && value.trim().length > 0;
+}
+
+function cloneData(value, seen = new WeakMap()) {
+  if (Array.isArray(value)) {
+    if (seen.has(value)) return '[Circular]';
+    seen.set(value, true);
+    return value.map(item => cloneData(item, seen));
+  }
+  if (isPlainObject(value)) {
+    if (seen.has(value)) return '[Circular]';
+    seen.set(value, true);
+    return Object.fromEntries(Object.keys(value).sort(compareStrings).map(key => [key, cloneData(value[key], seen)]));
+  }
+  if (typeof value === 'function' || typeof value === 'symbol') {
+    return String(value);
+  }
+  return value;
+}
+
+function canonicalStringify(value, seen = new WeakMap()) {
+  if (Array.isArray(value)) {
+    if (seen.has(value)) return '"[Circular]"';
+    seen.set(value, true);
+    return `[${value.map(item => canonicalStringify(item, seen)).join(',')}]`;
+  }
+  if (isPlainObject(value)) {
+    if (seen.has(value)) return '"[Circular]"';
+    seen.set(value, true);
+    return `{${Object.keys(value).sort(compareStrings).map(key => `${JSON.stringify(key)}:${canonicalStringify(value[key], seen)}`).join(',')}}`;
+  }
+  if (typeof value === 'bigint') {
+    return JSON.stringify(`${value.toString()}n`);
+  }
+  return JSON.stringify(value);
+}
+
+function compareStrings(a, b) {
+  const left = String(a);
+  const right = String(b);
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
+}