@cassiomc1/forgeloop 1.1.0 → 1.2.1

package/src/core/diagnosis.js

@@ -0,0 +1,171 @@
+import { appendProtocolEvent, validateEventLedger } from "./events.js";
+import { readWorkState, writeWorkState } from "./work-state.js";
+import {
+  DIAGNOSIS_INFORMATION_GAIN,
+  assertDiagnosisDetails,
+  classifyDiagnosisInformationGain,
+  createDiagnosisDetails,
+  currentCycleDiagnosis,
+  diagnosisEventsForTask,
+  diagnosisFingerprint,
+  normalizeDiagnosisText,
+} from "./diagnosis-model.js";
+
+export {
+  DIAGNOSIS_INFORMATION_GAIN,
+  assertDiagnosisDetails,
+  classifyDiagnosisInformationGain,
+  createDiagnosisDetails,
+  currentCycleDiagnosis,
+  diagnosisEventsForTask,
+  diagnosisFingerprint,
+  normalizeDiagnosisText,
+};
+
+export async function recordDiagnosis({
+  target,
+  packageRoot,
+  hypothesis,
+  failureClass,
+  evidenceRefs,
+  settledBy,
+  nextSafeAction,
+  taskId = null,
+  statePath = null,
+  eventsPath = null,
+}) {
+  const state = await readWorkState(target, { packageRoot, taskId, statePath });
+  if (!state) {
+    const error = new Error("Work state not found");
+    error.code = "E_STATE_MISSING";
+    throw error;
+  }
+  if (state.phase !== "DIAGNOSING") {
+    const error = new Error(`Recording a diagnosis requires phase DIAGNOSING, currently ${state.phase}`);
+    error.code = "E_PHASE_PREREQUISITE_MISSING";
+    throw error;
+  }
+  if (typeof state.verificationCycle !== "number" || state.verificationCycle < 1) {
+    const error = new Error("Active verification cycle must be an integer >= 1");
+    error.code = "E_DIAGNOSIS_INVALID";
+    throw error;
+  }
+
+  const ledger = await validateEventLedger(target, packageRoot, { taskId: taskId ?? null, eventsPath });
+  if (!ledger.valid) {
+    const first = ledger.errors[0];
+    const error = new Error(first.message);
+    error.code = first.code;
+    throw error;
+  }
+
+  const verificationStarted = ledger.events.some(
+    (e) => e.taskId === state.taskId && e.event === "VERIFICATION_STARTED",
+  );
+  if (!verificationStarted) {
+    const error = new Error("No VERIFICATION_STARTED event found for active cycle");
+    error.code = "E_PHASE_CHRONOLOGY_INVALID";
+    throw error;
+  }
+
+  const currentCycleChecks = (state.checks ?? []).filter(
+    (c) => c.details?.verificationCycle === state.verificationCycle,
+  );
+
+  const cleanRefs = (evidenceRefs ?? []).map((r) => String(r).trim()).filter(Boolean);
+  if (cleanRefs.length === 0) {
+    const error = new Error("record-diagnosis requires at least one evidenceRef");
+    error.code = "E_DIAGNOSIS_EVIDENCE_INVALID";
+    throw error;
+  }
+
+  const matchedChecks = [];
+  for (const ref of cleanRefs) {
+    const check = currentCycleChecks.find((c) => (c.id === ref || c.checkId === ref));
+    if (!check) {
+      const error = new Error(`Evidence reference "${ref}" does not match any check from verification cycle ${state.verificationCycle}`);
+      error.code = "E_DIAGNOSIS_EVIDENCE_INVALID";
+      throw error;
+    }
+    matchedChecks.push(check);
+  }
+
+  const hasFailedOrBlocked = matchedChecks.some((c) => c.status === "failed" || c.status === "blocked");
+  if (!hasFailedOrBlocked) {
+    const error = new Error("Diagnosis evidenceRefs must include at least one failed or blocked check from the current cycle");
+    error.code = "E_DIAGNOSIS_EVIDENCE_INVALID";
+    throw error;
+  }
+
+  const existingEvent = currentCycleDiagnosis(
+    ledger.events,
+    state.taskId,
+    state.verificationCycle,
+  );
+
+  const requestedFingerprint = diagnosisFingerprint({
+    failureClass,
+    hypothesis,
+    evidenceRefs: cleanRefs,
+  });
+
+  if (existingEvent?.details?.diagnosisFingerprint === requestedFingerprint) {
+    const updatedState = {
+      ...state,
+      diagnosedHypothesis: existingEvent.details.hypothesis,
+      lastUpdated: new Date().toISOString(),
+    };
+    await writeWorkState(target, updatedState, {
+      packageRoot,
+      taskId: taskId ?? null,
+      statePath,
+    });
+    return {
+      event: existingEvent,
+      state: updatedState,
+      diagnosis: existingEvent.details,
+      idempotent: true,
+    };
+  }
+
+  const taskDiagnosisEvents = diagnosisEventsForTask(ledger.events, state.taskId);
+  const previousEvent = taskDiagnosisEvents.at(-1) ?? null;
+  const previousDetails = previousEvent?.details ?? null;
+
+  const details = createDiagnosisDetails(
+    {
+      verificationCycle: state.verificationCycle,
+      failureClass,
+      hypothesis,
+      evidenceRefs: cleanRefs,
+      settledBy,
+      nextSafeAction,
+    },
+    previousDetails,
+  );
+
+  const event = await appendProtocolEvent(
+    target,
+    {
+      taskId: state.taskId,
+      event: "DIAGNOSIS_RECORDED",
+      details,
+    },
+    packageRoot,
+    { taskId: taskId ?? null, eventsPath },
+  );
+
+  const updatedState = {
+    ...state,
+    diagnosedHypothesis: hypothesis.trim(),
+    lastUpdated: new Date().toISOString(),
+  };
+  await writeWorkState(target, updatedState, { packageRoot, taskId: taskId ?? null, statePath });
+
+  return {
+    event,
+    state: updatedState,
+    diagnosis: details,
+    idempotent: false,
+  };
+}

package/src/core/error-codes.js

@@ -30,6 +30,15 @@ export const E_TASK_LAYOUT_LEGACY = "E_TASK_LAYOUT_LEGACY";
 export const E_TASK_MIGRATION_INVALID = "E_TASK_MIGRATION_INVALID";
 export const E_TASK_MIGRATION_IDENTITY_MISMATCH = "E_TASK_MIGRATION_IDENTITY_MISMATCH";
 
+export const E_DIAGNOSIS_REQUIRED = "E_DIAGNOSIS_REQUIRED";
+export const E_DIAGNOSIS_INVALID = "E_DIAGNOSIS_INVALID";
+export const E_DIAGNOSIS_EVIDENCE_INVALID = "E_DIAGNOSIS_EVIDENCE_INVALID";
+export const E_DIAGNOSIS_CYCLE_MISMATCH = "E_DIAGNOSIS_CYCLE_MISMATCH";
+export const E_DIAGNOSIS_NO_NEW_INFORMATION = "E_DIAGNOSIS_NO_NEW_INFORMATION";
+export const E_PROGRESS_STALLED = "E_PROGRESS_STALLED";
+export const E_DECISION_CRITERION_INVALID = "E_DECISION_CRITERION_INVALID";
+export const E_DECISION_NOT_UNRESOLVED = "E_DECISION_NOT_UNRESOLVED";
+
 /**
  * Public, stable ForgeLoop error and reason codes documented for users and harnesses.
  */
@@ -160,6 +169,62 @@ export const PUBLIC_ERROR_CODES = Object.freeze({
     meaning: "Modified paths in repository exceed the declared task write claims.",
     safeResolution: "Update write claims with forgeloop task-scope or revert out-of-scope modifications.",
   }),
+  E_DIAGNOSIS_REQUIRED: Object.freeze({
+    code: "E_DIAGNOSIS_REQUIRED",
+    category: "diagnosis",
+    classification: "PUBLIC_STABLE",
+    meaning: "Current correction cycle has no append-only diagnosis record.",
+    safeResolution: "Run forgeloop record-diagnosis with current failed evidence before correcting.",
+  }),
+  E_DIAGNOSIS_INVALID: Object.freeze({
+    code: "E_DIAGNOSIS_INVALID",
+    category: "diagnosis",
+    classification: "PUBLIC_STABLE",
+    meaning: "Diagnosis record details or parameters are malformed.",
+    safeResolution: "Provide valid failureClass, hypothesis, evidenceRefs, settledBy, and nextSafeAction.",
+  }),
+  E_DIAGNOSIS_EVIDENCE_INVALID: Object.freeze({
+    code: "E_DIAGNOSIS_EVIDENCE_INVALID",
+    category: "diagnosis",
+    classification: "PUBLIC_STABLE",
+    meaning: "Referenced diagnosis evidence is missing or has no failed checks in the current cycle.",
+    safeResolution: "Reference at least one failed or blocked check ID from the active verification cycle.",
+  }),
+  E_DIAGNOSIS_CYCLE_MISMATCH: Object.freeze({
+    code: "E_DIAGNOSIS_CYCLE_MISMATCH",
+    category: "diagnosis",
+    classification: "PUBLIC_STABLE",
+    meaning: "Diagnosis verification cycle does not match the active work state verification cycle.",
+    safeResolution: "Record diagnosis for the current active verification cycle.",
+  }),
+  E_DIAGNOSIS_NO_NEW_INFORMATION: Object.freeze({
+    code: "E_DIAGNOSIS_NO_NEW_INFORMATION",
+    category: "diagnosis",
+    classification: "PUBLIC_STABLE",
+    meaning: "The proposed retry repeats the previous hypothesis with the same evidence.",
+    safeResolution: "Change the hypothesis, collect independent evidence, or change strategy.",
+  }),
+  E_PROGRESS_STALLED: Object.freeze({
+    code: "E_PROGRESS_STALLED",
+    category: "progress",
+    classification: "PUBLIC_STABLE",
+    meaning: "Persisted correction history shows no new diagnostic information.",
+    safeResolution: "Use an independent check, revisit assumptions, or record a materially different diagnosis.",
+  }),
+  E_DECISION_CRITERION_INVALID: Object.freeze({
+    code: "E_DECISION_CRITERION_INVALID",
+    category: "contract",
+    classification: "PUBLIC_STABLE",
+    meaning: "Decision settlement criterion details or parameters are malformed.",
+    safeResolution: "Provide non-empty decision text and settledBy criterion.",
+  }),
+  E_DECISION_NOT_UNRESOLVED: Object.freeze({
+    code: "E_DECISION_NOT_UNRESOLVED",
+    category: "contract",
+    classification: "PUBLIC_STABLE",
+    meaning: "A settlement criterion referenced a decision not present in current unresolvedDecisions.",
+    safeResolution: "Use the exact current unresolved decision text or update the contract first.",
+  }),
 });
 
 export const ALL_KNOWN_ERROR_CODES = Object.freeze(new Set([

package/src/core/events.js

@@ -12,6 +12,9 @@ import { isRecoverableCompletionEvidenceCode } from "./completion-recovery.js";
 
 import { taskArtifactPath } from "./task-paths.js";
 
+import { assertDiagnosisDetails } from "./diagnosis-model.js";
+import { assertDecisionCriterionDetails } from "./settlement-model.js";
+
 const EVENT_SCHEMA_VERSION = 1;
 export const LIFECYCLE_MILESTONES = Object.freeze([
   "CONTRACT_VALIDATED",
@@ -37,6 +40,20 @@ const REPEATABLE_MILESTONES = new Set([
   "TERMINAL_RESULT_RECORDED",
 ]);
 
+export function validateKnownEventDetails(event) {
+  if (!event || typeof event !== "object") return;
+  switch (event.event) {
+    case "DIAGNOSIS_RECORDED":
+      assertDiagnosisDetails(event.details);
+      return;
+    case "DECISION_CRITERION_RECORDED":
+      assertDecisionCriterionDetails(event.details);
+      return;
+    default:
+      return;
+  }
+}
+
 function eventHash(event) {
   const { hash, ...body } = event;
   return canonicalFingerprint(body);
@@ -64,8 +81,9 @@ export async function readEvents(target, packageRoot, options = {}) {
       event = JSON.parse(line);
       assertJsonLimits(event, `${relPath}[${index}]`);
       assertSchema(event, schema, `${relPath}[${index}]`);
+      validateKnownEventDetails(event);
     } catch (error) {
-      throw protocolError("E_EVENT_INVALID", `${relPath} line ${index + 1}: ${error.message}`, [relPath]);
+      throw protocolError(error.code ?? "E_EVENT_INVALID", `${relPath} line ${index + 1}: ${error.message}`, [relPath]);
     }
     return event;
   });
@@ -88,6 +106,7 @@ export async function appendProtocolEvent(target, input, packageRoot, options =
     previousHash: previous?.hash ?? null,
     ...(input.details ? { details: structuredClone(input.details) } : {}),
   };
+  validateKnownEventDetails(event);
   assertSecretFree(event);
   const schema = await readSchema("event", packageRoot);
   assertSchema(event, schema, relPath);
@@ -125,6 +144,11 @@ export async function validateEventLedger(target, packageRoot, options = {}) {
     if (event.hash !== eventHash(event)) {
       errors.push({ code: "E_LEDGER_HASH_INVALID", message: `event ${event.seq} hash does not match its content` });
     }
+    try {
+      validateKnownEventDetails(event);
+    } catch (err) {
+      errors.push({ code: err.code ?? "E_EVENT_INVALID", message: `event ${event.seq} (${event.event}): ${err.message}` });
+    }
     const milestoneIndex = LIFECYCLE_MILESTONES.indexOf(event.event);
     if (milestoneIndex >= 0) {
       const count = (milestoneCounts.get(event.event) ?? 0) + 1;

package/src/core/next-action-model.js

@@ -13,7 +13,9 @@ export const NEXT_ACTIONS = Object.freeze({
   CONTINUE_IMPLEMENTATION: "CONTINUE_IMPLEMENTATION",
   RECORD_VERIFICATION: "RECORD_VERIFICATION",
   DIAGNOSE: "DIAGNOSE",
+  RECORD_DIAGNOSIS: "RECORD_DIAGNOSIS",
   CORRECT: "CORRECT",
+  CHANGE_STRATEGY: "CHANGE_STRATEGY",
   ENTER_REVIEWING: "ENTER_REVIEWING",
   RECORD_TERMINAL_RESULT: "RECORD_TERMINAL_RESULT",
   PREPARE_COMPLETION: "PREPARE_COMPLETION",
@@ -32,13 +34,20 @@ export function result({
   commandSpecs = [],
   requiredArtifacts = [],
   missingArtifacts = [],
+  progress = undefined,
 }) {
   const normalizedReasons = reasons
-    .map((reason) => ({
-      code: reason.code ?? "E_NEXT_ACTION_BLOCKED",
-      message: reason.message ?? String(reason),
-      artifacts: uniqueSorted(reason.artifacts ?? []),
-    }))
+    .map((reason) => {
+      const base = {
+        code: reason.code ?? "E_NEXT_ACTION_BLOCKED",
+        message: reason.message ?? String(reason),
+        artifacts: uniqueSorted(reason.artifacts ?? []),
+      };
+      if (reason.resolution) {
+        base.resolution = structuredClone(reason.resolution);
+      }
+      return base;
+    })
     .sort((left, right) => left.code.localeCompare(right.code)
       || left.artifacts.join("\0").localeCompare(right.artifacts.join("\0"))
       || left.message.localeCompare(right.message));
@@ -57,6 +66,7 @@ export function result({
       .sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right))),
     requiredArtifacts: uniqueSorted(requiredArtifacts),
     missingArtifacts: uniqueSorted(missingArtifacts),
+    ...(progress ? { progress: structuredClone(progress) } : {}),
   };
 }
 
@@ -91,6 +101,22 @@ export function recordCheckCommandSpec(requirement) {
   };
 }
 
+export function recordDiagnosisCommandSpec() {
+  return {
+    commandId: "record-diagnosis",
+    executable: "forgeloop",
+    subcommand: "record-diagnosis",
+    argv: ["record-diagnosis"],
+    requiredInputs: [
+      { name: "hypothesis", option: "--hypothesis=<text>" },
+      { name: "failureClass", option: "--failure-class=<class>" },
+      { name: "evidenceRef", option: "--evidence-ref=<check-id>", repeatable: true },
+      { name: "settledBy", option: "--settled-by=<text>" },
+      { name: "nextSafeAction", option: "--next-safe-action=<text>" },
+    ],
+  };
+}
+
 export function recordTerminalResultCommandSpec(requirement) {
   const reqId = requirement.id ?? requirement;
   const type = requirement.type ?? "PUBLICATION";

package/src/core/next-action.js

@@ -17,6 +17,7 @@ import {
   commandFor,
   decision,
   recordCheckCommandSpec,
+  recordDiagnosisCommandSpec,
   recordTerminalResultCommandSpec,
   result,
   uniqueSorted,
@@ -31,10 +32,14 @@ import {
 } from "./next-action-artifacts.js";
 import { PHASES_REQUIRING_EXECUTION_CHRONOLOGY } from "./next-action-phases.js";
 import { evaluateContinuityNextAction } from "./next-action-continuity.js";
+import { currentCycleDiagnosis } from "./diagnosis-model.js";
+import { evaluateProgress, PROGRESS_STATUS } from "./progress.js";
+import { criterionForDecision } from "./settlement-model.js";
+import { readEvents } from "./events.js";
 
 export { NEXT_ACTIONS } from "./next-action-model.js";
 
-export async function getNextAction(targetOrOptions = {}, packageRootOption) {
+async function computeNextAction(targetOrOptions = {}, packageRootOption) {
   const normalized = typeof targetOrOptions === "string"
     ? { target: targetOrOptions, packageRoot: packageRootOption }
     : targetOrOptions;
@@ -456,19 +461,50 @@ export async function getNextAction(targetOrOptions = {}, packageRootOption) {
     });
   }
   if (state.phase === "DIAGNOSING") {
-    if (typeof state.diagnosedHypothesis !== "string" || !state.diagnosedHypothesis.trim()) {
-      return decision(
-        context,
-        NEXT_ACTIONS.RESOLVE_BLOCKER,
-        artifactError(
-          "E_DIAGNOSIS_HYPOTHESIS_MISSING",
-          "Record diagnosedHypothesis in .forgeloop/work-state.json before advancing to CORRECTING",
-          [ARTIFACT_PATHS.state],
-        ),
+    const ledger = await validateEventLedger(target, packageRoot, { taskId: normalized.taskId ?? null });
+    const cycle = state.verificationCycle ?? 1;
+    const diagEvent = currentCycleDiagnosis(ledger.events, state.taskId, cycle);
+    if (!diagEvent) {
+      return result({
+        ...context,
+        nextAction: NEXT_ACTIONS.RECORD_DIAGNOSIS,
+        reasons: [
+          artifactError(
+            "E_DIAGNOSIS_REQUIRED",
+            "Current correction cycle has no append-only diagnosis record.",
+            [ARTIFACT_PATHS.events],
+          ),
+        ],
+        commandSpecs: [recordDiagnosisCommandSpec()],
+        requiredArtifacts: [...requiredArtifacts, ARTIFACT_PATHS.events],
+      });
+    }
+    const progress = evaluateProgress({ state, events: ledger.events });
+    if (progress.status === PROGRESS_STATUS.STALLED) {
+      return result({
+        ...context,
+        nextAction: NEXT_ACTIONS.CHANGE_STRATEGY,
+        reasons: [
+          artifactError(
+            "E_PROGRESS_STALLED",
+            "The current correction strategy has no new diagnostic information.",
+            [ARTIFACT_PATHS.state, ARTIFACT_PATHS.events],
+          ),
+        ],
+        progress,
         requiredArtifacts,
-      );
+      });
     }
-    return decision(context, NEXT_ACTIONS.CORRECT, artifactError("PHASE_DIAGNOSING", "The persisted diagnosis hypothesis permits correction"));
+    return result({
+      ...context,
+      nextAction: NEXT_ACTIONS.CORRECT,
+      commands: [commandFor(NEXT_ACTIONS.CORRECT)],
+      reasons: [
+        artifactError("PHASE_DIAGNOSING", "The persisted diagnosis hypothesis permits correction"),
+      ],
+      ...(progress.status === PROGRESS_STATUS.WATCH ? { progress } : {}),
+      requiredArtifacts,
+    });
   }
   if (state.phase === "CORRECTING") {
     return decision(context, NEXT_ACTIONS.ENTER_VERIFYING, artifactError("PHASE_CORRECTING", "Correction is ready for verification"));
@@ -675,3 +711,64 @@ export async function getNextAction(targetOrOptions = {}, packageRootOption) {
     requiredArtifacts,
   );
 }
+
+export async function getNextAction(targetOrOptions = {}, packageRootOption) {
+  const res = await computeNextAction(targetOrOptions, packageRootOption);
+  if (res && res.reasons && res.reasons.some((r) => r.code === "E_CONTRACT_UNRESOLVED_DECISION" || r.code === "E_UNRESOLVED_DECISION")) {
+    const normalized = typeof targetOrOptions === "string" ? { target: targetOrOptions, packageRoot: packageRootOption } : targetOrOptions;
+    const { target, packageRoot, taskId } = normalized ?? {};
+    try {
+      const explicitTaskId = taskId ?? null;
+      const contract = await readContract(target, packageRoot, { taskId: explicitTaskId });
+      const events = await readEvents(target, packageRoot, { taskId: explicitTaskId });
+      if (contract?.value?.unresolvedDecisions?.length > 0) {
+        const foundCriteria = [];
+        for (const dec of contract.value.unresolvedDecisions) {
+          const criterion = criterionForDecision(events, res.taskId, dec, contract.fingerprint);
+          if (criterion) {
+            foundCriteria.push({
+              decisionId: criterion.decisionId,
+              decision: dec,
+              settledBy: criterion.settledBy,
+            });
+          }
+        }
+
+        if (foundCriteria.length > 0) {
+          let resolution;
+          if (foundCriteria.length === 1) {
+            resolution = {
+              kind: "SETTLEMENT_CRITERION",
+              itemId: foundCriteria[0].decisionId,
+              decision: foundCriteria[0].decision,
+              settledBy: foundCriteria[0].settledBy,
+            };
+          } else {
+            resolution = {
+              kind: "SETTLEMENT_CRITERIA",
+              items: foundCriteria,
+            };
+          }
+
+          const enrichedReasons = res.reasons.map((r) => {
+            if (r.code === "E_CONTRACT_UNRESOLVED_DECISION" || r.code === "E_UNRESOLVED_DECISION") {
+              return {
+                ...r,
+                resolution,
+              };
+            }
+            return r;
+          });
+
+          return result({
+            ...res,
+            reasons: enrichedReasons,
+          });
+        }
+      }
+    } catch {
+      // Ignore read errors
+    }
+  }
+  return res;
+}

package/src/core/phase.js

@@ -21,6 +21,7 @@ import { discoverTasks } from "./task-discovery.js";
 import { assertNoScopeConflicts, assertScopeClean } from "./task-scope.js";
 import { readTaskDescriptor } from "./task-descriptor.js";
 import { E_TASK_SCOPE_REQUIRED } from "./error-codes.js";
+import { currentCycleDiagnosis } from "./diagnosis-model.js";
 
 function phaseError(code, message, artifacts = []) {
   const error = new Error(message);
@@ -242,7 +243,35 @@ export async function advanceWorkState(target, toPhase, options = {}) {
       );
     }
   }
+  if (toPhase === "CORRECTING" && state.phase === "DIAGNOSING") {
+    const cycle = state.verificationCycle ?? 1;
+    const diagEvent = currentCycleDiagnosis(ledger.events, state.taskId, cycle);
+    if (!diagEvent) {
+      throw phaseError(
+        "E_DIAGNOSIS_REQUIRED",
+        "DIAGNOSING -> CORRECTING requires an append-only diagnosis record for the active verification cycle",
+        [eventsRel],
+      );
+    }
+    const details = diagEvent.details;
+    if (!details || details.informationGain === "NONE") {
+      throw phaseError(
+        "E_DIAGNOSIS_NO_NEW_INFORMATION",
+        "The proposed retry repeats the previous hypothesis with the same evidence without new information",
+        [eventsRel],
+      );
+    }
+  }
   if (toPhase === "VERIFYING" && state.phase === "CORRECTING") {
+    const cycle = state.verificationCycle ?? 1;
+    const diagEvent = currentCycleDiagnosis(ledger.events, state.taskId, cycle);
+    if (!diagEvent) {
+      throw phaseError(
+        "E_DIAGNOSIS_REQUIRED",
+        "CORRECTING -> VERIFYING requires an append-only diagnosis record for the current cycle",
+        [eventsRel],
+      );
+    }
     if (typeof state.diagnosedHypothesis !== "string" || !state.diagnosedHypothesis.trim()) {
       throw phaseError(
         "E_PHASE_PREREQUISITE_MISSING",

package/src/core/preflight-model.js

@@ -34,11 +34,19 @@ export function sameStringSet(left, right) {
 export function validatePersistedPreflight(persisted, current) {
   const errors = [];
   if (persisted?.status !== "READY") {
-    errors.push(issue("E_PREFLIGHT_NOT_READY", "A persisted READY preflight is required", [ARTIFACT_PATHS.preflight]));
+    if (Array.isArray(persisted?.errors) && persisted.errors.length > 0) {
+      errors.push(...persisted.errors);
+    } else {
+      errors.push(issue("E_PREFLIGHT_NOT_READY", "A persisted READY preflight is required", [ARTIFACT_PATHS.preflight]));
+    }
     return errors;
   }
   if (current?.status !== "READY") {
-    errors.push(issue("E_PREFLIGHT_NOT_READY", "The current preflight evaluation is not READY", [ARTIFACT_PATHS.preflight]));
+    if (Array.isArray(current?.errors) && current.errors.length > 0) {
+      errors.push(...current.errors);
+    } else {
+      errors.push(issue("E_PREFLIGHT_NOT_READY", "The current preflight evaluation is not READY", [ARTIFACT_PATHS.preflight]));
+    }
   }
   if (persisted.taskId !== current?.taskId) {
     errors.push(issue(