ai-maestro 1.0.0

package/src/orchestration/engine-selector.mjs

@@ -0,0 +1,187 @@
+import { listEngineRecords, hasTool, isCostAcceptable } from './capability-registry.mjs';
+import { runPreflight } from './preflight.mjs';
+
+const REQUIRED_TOOL_KEYS = ['shell', 'filesystemWrite', 'browser', 'vision', 'testExecution'];
+
+function checkRequiredTool(engineRecord, key) {
+  if (key === 'vision') {
+    return engineRecord.capabilities && engineRecord.capabilities.vision === true;
+  }
+  return hasTool(engineRecord, key);
+}
+
+function hardFilterReason(engineRecord, classification, { allowPaid, allowUnknownCost }) {
+  if (engineRecord.enabled !== true) {
+    return 'disabled';
+  }
+  if (engineRecord.health && engineRecord.health.available === false) {
+    return 'marked unavailable';
+  }
+  if (!isCostAcceptable(engineRecord, { allowPaid, allowUnknownCost })) {
+    return 'cost class "' + (engineRecord.cost ? engineRecord.cost.class : 'unknown') + '" not allowed (allowPaid=' + allowPaid + ')';
+  }
+  const requires = classification.requires || {};
+  for (const key of REQUIRED_TOOL_KEYS) {
+    if (requires[key] === true && !checkRequiredTool(engineRecord, key)) {
+      return 'missing required tool: ' + key;
+    }
+  }
+  const requiredContext = requires.minimumContextTokens;
+  const maxContext = engineRecord.limits ? engineRecord.limits.maxContextTokens : null;
+  if (typeof requiredContext === 'number' && typeof maxContext === 'number' && maxContext < requiredContext) {
+    return 'insufficient context window (' + maxContext + ' < ' + requiredContext + ' required)';
+  }
+  const requestsPerDay = engineRecord.limits ? engineRecord.limits.requestsPerDay : null;
+  if (requestsPerDay === 0) {
+    return 'daily quota exhausted (requestsPerDay=0)';
+  }
+  return null;
+}
+
+function findHistoryFor(history, engineId) {
+  return history.filter(entry => entry.engine === engineId);
+}
+
+function successRateFromHistory(entries) {
+  if (!entries.length) {
+    return null;
+  }
+  const successes = entries.filter(entry => entry.success === true).length;
+  return successes / entries.length;
+}
+
+function scoreEngine(engineRecord, classification, { history = [], preferFree = true } = {}) {
+  const reasons = [];
+  let score = 0;
+
+  const costClass = engineRecord.cost ? engineRecord.cost.class : 'unknown';
+  if (costClass === 'free' || costClass === 'local') {
+    score += preferFree ? 15 : 8;
+    reasons.push('cost class "' + costClass + '"' + (preferFree ? ' (preferred)' : ''));
+  } else if (costClass === 'free-tier') {
+    score += preferFree ? 10 : 6;
+    reasons.push('cost class "free-tier"');
+  } else if (costClass === 'paid') {
+    score += 0;
+    reasons.push('cost class "paid"');
+  } else {
+    score += 3;
+    reasons.push('cost class "unknown" (small neutral credit, not preferred over confirmed-free)');
+  }
+
+  const caps = engineRecord.capabilities || {};
+  const requires = classification.requires || {};
+  for (const key of ['reasoning', 'coding']) {
+    const have = caps[key];
+    const need = requires[key];
+    if (typeof have === 'number' && typeof need === 'number') {
+      if (have >= need) {
+        score += 8 + (have - need) * 2;
+        reasons.push(key + ' capability ' + have + ' meets requirement ' + need);
+      } else {
+        score -= 10;
+        reasons.push(key + ' capability ' + have + ' below requirement ' + need);
+      }
+    }
+  }
+
+  // Prefer a smaller/cheaper engine for trivial tasks, and a stronger one
+  // for architecture/critical work, but only when capability is confirmed
+  // or probable enough to have a numeric score at all — never invent one.
+  if (classification.complexity <= 2 && typeof caps.coding === 'number' && caps.coding >= 4) {
+    score -= 3;
+    reasons.push('deprioritized: strong engine on a low-complexity task');
+  }
+  if ((classification.taskKind === 'architecture' || classification.risk === 'critical') && typeof caps.reasoning === 'number') {
+    if (caps.reasoning >= 4) {
+      score += 6;
+      reasons.push('reasoning capability suits architecture/critical task');
+    } else {
+      score -= 6;
+      reasons.push('reasoning capability likely too low for architecture/critical task');
+    }
+  }
+
+  const entries = findHistoryFor(history, engineRecord.id);
+  const successRate = successRateFromHistory(entries);
+  if (successRate !== null) {
+    score += Math.round(successRate * 20);
+    reasons.push('recent success rate ' + Math.round(successRate * 100) + '% over ' + entries.length + ' runs');
+  } else if (engineRecord.health && typeof engineRecord.health.recentSuccessRate === 'number') {
+    score += Math.round(engineRecord.health.recentSuccessRate * 20);
+    reasons.push('recorded success rate ' + Math.round(engineRecord.health.recentSuccessRate * 100) + '%');
+  } else {
+    score += 5;
+    reasons.push('no history yet (neutral score)');
+  }
+
+  const consecutiveFailures = engineRecord.health ? (engineRecord.health.consecutiveFailures || 0) : 0;
+  if (consecutiveFailures > 0) {
+    score -= consecutiveFailures * 3;
+    reasons.push(consecutiveFailures + ' consecutive recent failures (penalty)');
+  }
+
+  if (engineRecord.validated === true) {
+    score += 5;
+    reasons.push('engine is validated');
+  } else {
+    reasons.push('engine is not yet validated');
+  }
+
+  return { score, reasons };
+}
+
+export async function selectEngine(classification, options = {}) {
+  const allowPaid = options.allowPaid === true;
+  const allowUnknownCost = options.allowUnknownCost !== false;
+  const preferFree = options.preferFree !== false;
+  const engines = options.engines || await listEngineRecords();
+  const history = options.history || [];
+
+  const candidates = [];
+  const alternatives = [];
+
+  for (const engineRecord of engines) {
+    const rejection = hardFilterReason(engineRecord, classification, { allowPaid, allowUnknownCost });
+    if (rejection) {
+      alternatives.push({ engine: engineRecord.id, rejectedBecause: rejection });
+      continue;
+    }
+    const { score, reasons } = scoreEngine(engineRecord, classification, { history, preferFree });
+    candidates.push({ engine: engineRecord, score, reasons });
+  }
+
+  if (candidates.length === 0) {
+    return {
+      selectedEngine: null,
+      score: null,
+      reason: ['No enabled engine in .maestro/engines.json satisfies this task\'s hard requirements.'],
+      alternatives
+    };
+  }
+
+  candidates.sort((a, b) => b.score - a.score);
+  const winner = candidates[0];
+  const runnerUps = candidates.slice(1).map(candidate => ({
+    engine: candidate.engine.id,
+    rejectedBecause: 'lower score (' + candidate.score + ' < ' + winner.score + ')'
+  }));
+
+  return {
+    selectedEngine: winner.engine.id,
+    score: winner.score,
+    reason: winner.reasons,
+    alternatives: [...alternatives, ...runnerUps]
+  };
+}
+
+export async function selectEngineWithPreflight(task, classification, options = {}) {
+  const selection = await selectEngine(classification, options);
+  if (!selection.selectedEngine) {
+    return { selection, preflight: null };
+  }
+  const engines = options.engines || await listEngineRecords();
+  const engineRecord = engines.find(engine => engine.id === selection.selectedEngine);
+  const preflight = runPreflight(task, engineRecord, classification, options);
+  return { selection, preflight };
+}

package/src/orchestration/execution-context.mjs

@@ -0,0 +1,45 @@
+// src/orchestration/execution-context.mjs
+
+export function buildExecutionContext(input) {
+  const context = {
+    projectRoot: input.projectRoot || '',
+    task: input.task || {},
+    originalRequest: input.originalRequest || '',
+    taskClassification: input.taskClassification || {},
+    selectedManager: input.selectedManager || {},
+    selectedEngine: input.selectedEngine || {},
+    runtimeGate: input.runtimeGate || {},
+    budget: input.budget || {},
+    policy: input.policy || {},
+    attemptNumber: input.attemptNumber || 1,
+    maxAttempts: input.maxAttempts || 3,
+    parentRunId: input.parentRunId || null,
+    runKind: input.runKind || 'task',
+    orchestrationDepth: input.orchestrationDepth || 0,
+    previousFailures: input.previousFailures || [],
+    constraints: input.constraints || {},
+    allowedActions: input.allowedActions || [],
+    forbiddenActions: input.forbiddenActions || []
+  };
+  return context;
+}
+
+export function summarizeExecutionContext(context) {
+  const summary = {
+    taskTitle: context.task ? context.task.title : 'No Task',
+    runKind: context.runKind,
+    attemptNumber: context.attemptNumber,
+    orchestrationDepth: context.orchestrationDepth,
+    // Add other non-sensitive summary fields
+  };
+  return summary;
+}
+
+export function validateExecutionContext(context) {
+  // console.log('Validating context:', JSON.stringify(context, null, 2)); // Debug log
+  if (!context || !context.task || !context.task.id) {
+    // console.log('Throwing error due to missing task.id'); // Debug log
+    throw new Error('Validation Error: Execution context must contain a valid task.');
+  }
+  return true;
+}

package/src/orchestration/failure-classifier.mjs

@@ -0,0 +1,136 @@
+// src/orchestration/failure-classifier.mjs
+
+const NESTED_SANDBOX_PROCESS_FAILURE_PATTERNS = [
+  /spawn\s+EPERM/i,
+  /operation not permitted/i,
+  /CreateProcess failed/i,
+  /nested sandbox/i,
+  /child process blocked/i,
+  /npm(?:\.cmd)?\s+[^\r\n]*\b(blocked|EPERM|operation not permitted|CreateProcess failed)/i,
+  /subprocess(?:o)?\s+(?:blocked|impedido|bloqueado)/i,
+  /process creation\s+(?:blocked|denied|not permitted)/i,
+  /sandbox[^\r\n]*(?:blocked|denied|not permitted)[^\r\n]*(?:child process|subprocess|process creation|npm(?:\.cmd)?)/i
+];
+
+export function isNestedSandboxProcessFailure(input = '') {
+  const text = typeof input === 'string'
+    ? input
+    : [input.stdout, input.stderr, input.message, input.error && input.error.message]
+      .filter(Boolean)
+      .join('\n');
+  return NESTED_SANDBOX_PROCESS_FAILURE_PATTERNS.some(pattern => pattern.test(String(text || '')));
+}
+
+function nestedSandboxFailure(reasonText) {
+  return {
+    category: 'nested_sandbox_process_failure',
+    severity: 'high',
+    retryable: false,
+    shouldFallback: true,
+    shouldAskHuman: false,
+    infrastructureFailure: true,
+    reason: ['Sandbox blocked subprocess creation for worker validation.'],
+    evidence: [reasonText].filter(Boolean),
+  };
+}
+
+export function classifyFailure(input = {}) {
+  const { exitCode, stdout, stderr, runtimeGate, syntaxValidation, enginePolicyViolation, taskStatus, result } = input;
+  let category = 'unknown_failure';
+  let severity = 'medium';
+  let retryable = true;
+  let shouldFallback = true;
+  let shouldAskHuman = false;
+  let infrastructureFailure = false;
+  const reason = [];
+  const evidence = [];
+
+  const fullOutput = [stdout, stderr, result && result.stdout, result && result.stderr, result && result.message]
+    .filter(Boolean)
+    .join(' ');
+
+  if (isNestedSandboxProcessFailure(fullOutput)) {
+    return nestedSandboxFailure(fullOutput);
+  }
+
+  const checkMessage = (message, keywords, assignedCategory, assignedSeverity = 'medium', assignedRetryable = true, assignedShouldFallback = true, assignedShouldAskHuman = false, assignedInfrastructureFailure = false) => {
+    for (const keyword of keywords) {
+      if (message.includes(keyword)) {
+        category = assignedCategory;
+        severity = assignedSeverity;
+        retryable = assignedRetryable;
+        shouldFallback = assignedShouldFallback;
+        shouldAskHuman = assignedShouldAskHuman;
+        infrastructureFailure = assignedInfrastructureFailure;
+        reason.push(`Keyword "${keyword}" found in message.`);
+        evidence.push(message);
+        return true;
+      }
+    }
+    return false;
+  };
+
+  if (checkMessage(fullOutput, ['apply deny-read ACLs', 'apply deny-read acls', 'helper_unknown_error'], 'windows_sandbox_acl_failure', 'critical', false, true, true, true)) {}
+  else if (checkMessage(fullOutput, ['rate limit', '429'], 'rate_limit', 'high', true, true, false)) {}
+  else if (checkMessage(fullOutput, ['quota', 'insufficient quota'], 'quota_exceeded', 'high', true, true, false)) {}
+  else if (checkMessage(fullOutput, ['ECONNRESET', 'ETIMEDOUT', 'ENOTFOUND'], 'network_error', 'medium', true, true, false)) {}
+  else if (checkMessage(fullOutput, ['401', '403', 'auth', 'unauthorized'], 'authentication_error', 'critical', false, false, true)) {}
+  else if (checkMessage(fullOutput, ['missing tool', 'tool unavailable', 'no shell', 'filesystemWrite false'], 'missing_tool', 'high', false, true, true)) {}
+  else if (checkMessage(fullOutput, ['Unexpected token', 'SyntaxError', 'node --check failed'], 'syntax_failure', 'medium', false, true, false)) {}
+  else if (checkMessage(fullOutput, ['test failed', 'npm test failed', 'failing tests'], 'test_failure', 'medium', true, true, false)) {}
+  else if (checkMessage(fullOutput, ['policy violation', 'enginePolicyViolation', 'cannot access external network'], 'policy_violation', 'critical', false, false, true)) {}
+  else if (checkMessage(fullOutput, ['budget exceeded', 'allowPaid false'], 'budget_exceeded', 'high', false, false, true)) {}
+  else if (checkMessage(fullOutput, ['needs_human', 'NEEDS_HUMAN'], 'needs_human', 'critical', false, false, true)) {}
+  else if (checkMessage(fullOutput, ['ls -la', 'tail -50', 'cat << EOF', 'grep', 'sed -i'], 'windows_shell_mismatch', 'high', false, true, true) && process.platform === 'win32') {}
+  else if (checkMessage(fullOutput, ['unsupported tool', 'apply_patch unavailable'], 'unsupported_tool_call', 'medium', false, true, false)) {}
+  else if (checkMessage(fullOutput, ['suspected_false_positive'], 'suspected_false_positive', 'low', true, true, false)) {}
+  else if (runtimeGate && runtimeGate.status === 'NEEDS_HUMAN') {
+    category = 'needs_human';
+    severity = 'critical';
+    shouldAskHuman = true;
+    retryable = false;
+    shouldFallback = false;
+    reason.push('Runtime gate explicitly set to NEEDS_HUMAN.');
+    evidence.push(runtimeGate);
+  }
+  else if (enginePolicyViolation) {
+    category = 'policy_violation';
+    severity = 'critical';
+    shouldAskHuman = true;
+    retryable = false;
+    shouldFallback = false;
+    reason.push('Engine policy violation detected.');
+    evidence.push(enginePolicyViolation);
+  }
+  else if (syntaxValidation && !syntaxValidation.isValid) {
+    category = 'syntax_failure';
+    severity = 'medium';
+    retryable = false;
+    shouldFallback = true;
+    reason.push('Syntax validation failed.');
+    evidence.push(syntaxValidation);
+  }
+  else if (taskStatus && taskStatus === 'failed') {
+    category = 'unknown_failure';
+    severity = 'medium';
+    retryable = true;
+    shouldFallback = true;
+    reason.push('Task reported as failed without specific classification.');
+    evidence.push(taskStatus);
+    if (exitCode === 0) {
+      retryable = false;
+      severity = 'high';
+    }
+  }
+
+  return {
+    category,
+    severity,
+    retryable,
+    shouldFallback,
+    shouldAskHuman,
+    infrastructureFailure,
+    reason,
+    evidence,
+  };
+}

package/src/orchestration/failure-evidence.mjs

@@ -0,0 +1,237 @@
+import { redactCredentials, redactObject } from '../format.mjs';
+
+export const FAILURE_CLASSES = new Set([
+  'infrastructure',
+  'authentication',
+  'quota',
+  'rate_limit',
+  'timeout',
+  'network',
+  'stream_interruption',
+  'provider_unavailable',
+  'model_unavailable',
+  'engine_resolution',
+  'worker_failure',
+  'deliverable_rejection',
+  'safety_block',
+  'human_decision',
+  'unknown'
+]);
+
+export const HEALTH_AFFECTING_FAILURE_CLASSES = new Set([
+  'infrastructure',
+  'authentication',
+  'quota',
+  'rate_limit',
+  'timeout',
+  'network',
+  'stream_interruption',
+  'provider_unavailable',
+  'model_unavailable'
+]);
+
+export const RETRYABLE_FAILURE_CLASSES = new Set([
+  'infrastructure',
+  'rate_limit',
+  'timeout',
+  'network',
+  'stream_interruption',
+  'provider_unavailable'
+]);
+
+export const LONG_COOLDOWN_FAILURE_CLASSES = new Set(['authentication', 'quota']);
+
+export const EVIDENCE_SUMMARY_LIMIT = 2000;
+export const RETRY_AFTER_SAFETY_CEILING_MS = 86400000;
+
+const CONTENT_PATTERNS = [
+  { failureClass: 'authentication', retryable: false, patterns: [/\b401\b/i, /\b403\b/i, /unauthori[sz]ed/i, /invalid api key/i, /authentication failed/i, /\bapi[_\s-]?key\b.*(?:invalid|missing|expired)/i] },
+  { failureClass: 'quota', retryable: false, patterns: [/quota/i, /insufficient[_\s-]?(?:credit|balance)/i, /out of credits/i, /billing limit/i] },
+  { failureClass: 'rate_limit', retryable: true, patterns: [/rate[\s-]?limit/i, /too many requests/i, /\b429\b/i] },
+  { failureClass: 'stream_interruption', retryable: true, patterns: [/Reconnecting\.\.\.\s*\d+\s*\/\s*\d+/i, /stream disconnected before completion/i] },
+  { failureClass: 'network', retryable: true, patterns: [/\bECONNRESET\b/i, /\bECONNREFUSED\b/i, /\bENOTFOUND\b/i, /\bETIMEDOUT\b/i, /\bEAI_AGAIN\b/i, /network error/i, /fetch failed/i, /connection (?:reset|refused|timed out)/i] },
+  { failureClass: 'provider_unavailable', retryable: true, patterns: [/\b5\d\d\b/i, /service unavailable/i, /bad gateway/i, /gateway timeout/i, /provider (?:is )?(?:down|unavailable)/i] },
+  { failureClass: 'model_unavailable', retryable: false, patterns: [/model (?:not found|unavailable|does not exist)/i, /unsupported model/i, /model .* is not available/i] },
+  { failureClass: 'safety_block', retryable: false, patterns: [/safety (?:guard|policy|block)/i, /policy violation/i, /blocked by safety/i] },
+  { failureClass: 'deliverable_rejection', retryable: false, patterns: [/deliverable (?:rejected|verification failed)/i, /verification outcome: rejected/i, /acceptance criteria failed/i] },
+  { failureClass: 'human_decision', retryable: false, patterns: [/needs[_\s-]?human/i, /human decision required/i, /requires human/i] },
+  { failureClass: 'worker_failure', retryable: false, patterns: [/worker failed/i, /invalid output/i, /malformed (?:json|output)/i, /unsupported tool call/i] }
+];
+
+function asString(value) {
+  return typeof value === 'string' ? value : value == null ? '' : String(value);
+}
+
+function isPlainObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function uniqueNonEmptyStrings(values) {
+  const seen = new Set();
+  const result = [];
+  for (const value of values.flat(Infinity)) {
+    const text = asString(value);
+    if (!text || seen.has(text)) continue;
+    seen.add(text);
+    result.push(text);
+  }
+  return result;
+}
+
+export function normalizeFailureEvidence(input = {}) {
+  const acceptanceCriteria = Array.isArray(input.acceptanceCriteria)
+    ? input.acceptanceCriteria
+    : Array.isArray(input.acceptance)
+      ? input.acceptance
+      : [];
+  const commandEchoed = input.commandEchoed ?? input.echoedCommand ?? '';
+  return {
+    source: asString(input.source || 'unknown'),
+    command: asString(input.command || ''),
+    prompt: asString(input.prompt || ''),
+    taskDescription: asString(input.taskDescription || input.description || ''),
+    acceptanceCriteria: acceptanceCriteria.map(asString),
+    commandEchoed: asString(commandEchoed),
+    knownInputs: uniqueNonEmptyStrings([
+      input.knownInputs || [],
+      input.prompt || '',
+      input.taskDescription || input.description || '',
+      acceptanceCriteria,
+      commandEchoed
+    ]),
+    exitCode: typeof input.exitCode === 'number' ? input.exitCode : input.exitCode === null ? null : typeof input.code === 'number' ? input.code : null,
+    signal: input.signal == null ? null : asString(input.signal),
+    timedOut: input.timedOut === true || input.timeout === true,
+    timeout: input.timeout === true || input.timedOut === true,
+    processError: input.processError == null ? null : asString(input.processError && input.processError.message ? input.processError.message : input.processError),
+    stdout: asString(input.stdout),
+    stderr: asString(input.stderr),
+    fullStdout: input.fullStdout == null ? null : asString(input.fullStdout),
+    fullStderr: input.fullStderr == null ? null : asString(input.fullStderr),
+    structuredResult: input.structuredResult == null ? null : input.structuredResult,
+    retryAfterMs: input.retryAfterMs
+  };
+}
+
+export function stripKnownInputEcho(text, knownInputs = []) {
+  let cleaned = asString(text);
+  for (const input of uniqueNonEmptyStrings(knownInputs)) {
+    cleaned = cleaned.replace(new RegExp(escapeRegExp(input), 'g'), '');
+  }
+  return cleaned;
+}
+
+export function validateRetryAfterMs(value) {
+  if (value === undefined || value === null) {
+    return { valid: false, value: null };
+  }
+  if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
+    return { valid: false, value: null };
+  }
+  return { valid: true, value: Math.min(value, RETRY_AFTER_SAFETY_CEILING_MS) };
+}
+
+export function validateStructuredResult(value) {
+  if (!isPlainObject(value)) return { valid: false };
+  if (value.outcome !== 'success' && value.outcome !== 'failure') return { valid: false };
+  if (value.outcome === 'success') return { valid: true, outcome: 'success' };
+  const failureClass = value.failureClass || value.class || value.category;
+  if (!FAILURE_CLASSES.has(failureClass)) return { valid: false };
+  return { valid: true, outcome: 'failure', failureClass };
+}
+
+function retryableFor(failureClass) {
+  return RETRYABLE_FAILURE_CLASSES.has(failureClass);
+}
+
+function affectsHealth(failureClass) {
+  return HEALTH_AFFECTING_FAILURE_CLASSES.has(failureClass);
+}
+
+function summary(text) {
+  const redacted = redactCredentials(asString(text));
+  return redacted.length > EVIDENCE_SUMMARY_LIMIT ? redacted.slice(0, EVIDENCE_SUMMARY_LIMIT) : redacted;
+}
+
+function classification({ outcome = 'failure', failureClass = null, evidenceSource, evidenceSummary = '', reason }) {
+  const retryAfter = validateRetryAfterMs(classification.currentRetryAfterMs);
+  const result = {
+    outcome,
+    failureClass,
+    retryable: failureClass ? retryableFor(failureClass) : false,
+    affectsHealth: failureClass ? affectsHealth(failureClass) : false,
+    evidenceSource,
+    evidenceSummary: summary(evidenceSummary),
+    reason
+  };
+  if (retryAfter.valid) {
+    result.retryAfterMs = retryAfter.value;
+  }
+  return redactObject(result);
+}
+
+classification.currentRetryAfterMs = null;
+
+function matchContent(text) {
+  for (const entry of CONTENT_PATTERNS) {
+    for (const pattern of entry.patterns) {
+      const matched = asString(text).match(pattern);
+      if (matched) {
+        return { failureClass: entry.failureClass, matchedText: matched[0] };
+      }
+    }
+  }
+  return null;
+}
+
+export function classifyFailureEvidence(input = {}) {
+  const evidence = normalizeFailureEvidence(input);
+  classification.currentRetryAfterMs = evidence.retryAfterMs;
+  try {
+    if (evidence.timedOut) {
+      return classification({ failureClass: 'timeout', evidenceSource: 'timedOut', evidenceSummary: 'timedOut=true', reason: 'process timed out' });
+    }
+    if (evidence.processError) {
+      return classification({ failureClass: 'engine_resolution', evidenceSource: 'processError', evidenceSummary: evidence.processError, reason: 'runner reported a process error' });
+    }
+    if (evidence.signal) {
+      return classification({ failureClass: 'infrastructure', evidenceSource: 'signal', evidenceSummary: evidence.signal, reason: 'process ended by signal' });
+    }
+
+    const structured = validateStructuredResult(evidence.structuredResult);
+    if (structured.valid) {
+      if (structured.outcome === 'success') {
+        return classification({ outcome: 'success', failureClass: null, evidenceSource: 'structuredResult', evidenceSummary: 'outcome=success', reason: 'worker returned structured success' });
+      }
+      return classification({ failureClass: structured.failureClass, evidenceSource: 'structuredResult', evidenceSummary: JSON.stringify(evidence.structuredResult), reason: 'worker returned structured failure' });
+    }
+
+    const sources = [
+      ['stderr', evidence.stderr],
+      ['stdout', evidence.stdout],
+      ['fullStderr', evidence.fullStderr],
+      ['fullStdout', evidence.fullStdout]
+    ];
+    for (const [source, text] of sources) {
+      const cleaned = stripKnownInputEcho(text, evidence.knownInputs);
+      const matched = matchContent(cleaned);
+      if (matched) {
+        return classification({ failureClass: matched.failureClass, evidenceSource: source, evidenceSummary: cleaned, reason: 'matched reliable worker output pattern' });
+      }
+    }
+
+    if (evidence.exitCode === 0) {
+      return classification({ outcome: 'success', failureClass: null, evidenceSource: 'exitCode', evidenceSummary: 'exitCode=0', reason: 'process exited successfully and no failure evidence matched' });
+    }
+    if (typeof evidence.exitCode === 'number' && evidence.exitCode !== 0) {
+      return classification({ failureClass: 'worker_failure', evidenceSource: 'exitCode', evidenceSummary: 'exitCode=' + evidence.exitCode, reason: 'non-zero exit without provider-health evidence' });
+    }
+    return classification({ failureClass: 'unknown', evidenceSource: 'none', evidenceSummary: '', reason: 'no reliable failure evidence matched' });
+  } finally {
+    classification.currentRetryAfterMs = null;
+  }
+}