@xenonbyte/da-vinci-workflow 0.2.2 → 0.2.4

package/lib/workflow-state.js

@@ -1,6 +1,12 @@
+const fs = require("fs");
 const path = require("path");
 const { auditProject } = require("./audit");
-const { parseCheckpointStatusMap, normalizeCheckpointLabel } = require("./audit-parsers");
+const {
+  parseCheckpointStatusMap,
+  normalizeCheckpointLabel,
+  parseDisciplineMarkers,
+  DISCIPLINE_MARKER_NAMES
+} = require("./audit-parsers");
 const { pathExists, readTextIfExists } = require("./utils");
 const {
   parseTasksArtifact,
@@ -13,7 +19,8 @@ const {
   STATUS,
   CHECKPOINT_LABELS,
   HANDOFF_GATES,
-  getStageById
+  getStageById,
+  mergeStatuses
 } = require("./workflow-contract");
 const {
   selectPersistedStateForChange,
@@ -22,7 +29,14 @@ const {
   readTaskGroupMetadata,
   sanitizePersistedNotes
 } = require("./workflow-persisted-state");
-const { readExecutionSignals, summarizeSignalsBySurface } = require("./execution-signals");
+const {
+  readExecutionSignals,
+  summarizeSignalsBySurface,
+  listSignalsBySurfacePrefix
+} = require("./execution-signals");
+const { deriveExecutionProfile } = require("./execution-profile");
+const { collectVerificationFreshness } = require("./verify");
+const { runWorktreePreflight } = require("./worktree-preflight");
 
 const MAX_REPORTED_MESSAGES = 3;
 
@@ -49,6 +63,206 @@ function dedupeFindings(findings) {
   findings.notes = dedupeMessages(findings.notes);
 }
 
+function resolveDisciplineGateMode() {
+  const strictEnv = String(process.env.DA_VINCI_DISCIPLINE_REQUIRE_APPROVAL || "").trim();
+  const strict = strictEnv === "1" || /^true$/i.test(strictEnv);
+  return {
+    strict
+  };
+}
+
+function statusTokenMatches(status, acceptedTokens) {
+  const normalized = String(status || "").trim().toUpperCase();
+  return acceptedTokens.includes(normalized);
+}
+
+function inspectDisciplineState(changeDir) {
+  const designPath = path.join(changeDir, "design.md");
+  const pencilDesignPath = path.join(changeDir, "pencil-design.md");
+  const pencilBindingsPath = path.join(changeDir, "pencil-bindings.md");
+  const tasksPath = path.join(changeDir, "tasks.md");
+  const designText = readTextIfExists(designPath);
+  const tasksText = readTextIfExists(tasksPath);
+  const designMarkers = parseDisciplineMarkers(designText);
+  const taskMarkers = parseDisciplineMarkers(tasksText);
+  const gateMode = resolveDisciplineGateMode();
+  const hasAnyMarker =
+    designMarkers.ordered.length > 0 ||
+    taskMarkers.ordered.length > 0 ||
+    designMarkers.malformed.length > 0 ||
+    taskMarkers.malformed.length > 0;
+
+  const designApproval =
+    designMarkers.markers[DISCIPLINE_MARKER_NAMES.designApproval] ||
+    taskMarkers.markers[DISCIPLINE_MARKER_NAMES.designApproval] ||
+    null;
+  const planSelfReview = taskMarkers.markers[DISCIPLINE_MARKER_NAMES.planSelfReview] || null;
+  const operatorReviewAck = taskMarkers.markers[DISCIPLINE_MARKER_NAMES.operatorReviewAck] || null;
+
+  const blockers = [];
+  const warnings = [];
+  const notes = [];
+  const designApprovalArtifacts = [
+    { label: "design.md", path: designPath },
+    { label: "pencil-design.md", path: pencilDesignPath },
+    { label: "pencil-bindings.md", path: pencilBindingsPath }
+  ];
+
+  for (const malformed of [...designMarkers.malformed, ...taskMarkers.malformed]) {
+    warnings.push(`Malformed discipline marker at line ${malformed.line}: ${malformed.reason}`);
+  }
+
+  let designApprovalState = "missing";
+  let designApprovalStale = false;
+  if (designApproval) {
+    if (!statusTokenMatches(designApproval.status, ["APPROVED", "PASS", "ACCEPTED"])) {
+      designApprovalState = "rejected";
+      blockers.push(
+        `Design approval marker is not approved (${designApproval.status}); keep workflow in tasks/design.`
+      );
+    } else {
+      designApprovalState = "approved";
+      if (designApproval.time) {
+        const approvalMs = Date.parse(designApproval.time);
+        const staleArtifacts = [];
+        if (Number.isFinite(approvalMs)) {
+          for (const artifact of designApprovalArtifacts) {
+            let artifactMtimeMs = 0;
+            try {
+              artifactMtimeMs = fs.statSync(artifact.path).mtimeMs;
+            } catch (_error) {
+              continue;
+            }
+            if (artifactMtimeMs > approvalMs) {
+              staleArtifacts.push(artifact.label);
+            }
+          }
+        }
+        if (staleArtifacts.length > 0) {
+          designApprovalState = "stale";
+          designApprovalStale = true;
+          blockers.push(
+            `Design approval marker is stale because design artifacts changed after approval timestamp: ${staleArtifacts.join(", ")}.`
+          );
+        }
+      } else {
+        warnings.push("Design approval marker is missing timestamp; staleness checks are limited.");
+      }
+    }
+  } else if (hasAnyMarker || gateMode.strict) {
+    blockers.push(
+      "Missing required design approval marker (`- design approval: APPROVED @ <ISO8601>`) for disciplined handoff."
+    );
+  } else {
+    warnings.push(
+      "Design approval marker is missing; legacy compatibility mode keeps this advisory. Set DA_VINCI_DISCIPLINE_REQUIRE_APPROVAL=1 to enforce."
+    );
+    notes.push("Legacy compatibility mode: missing discipline markers are advisory.");
+  }
+
+  if (!planSelfReview) {
+    warnings.push("Missing plan self-review marker in tasks.md (`- plan self review: PASS @ <ISO8601>`).");
+  } else if (!statusTokenMatches(planSelfReview.status, ["PASS", "APPROVED", "DONE"])) {
+    warnings.push(`Plan self-review marker is not PASS (${planSelfReview.status}).`);
+  }
+
+  if (!operatorReviewAck) {
+    warnings.push("Missing operator review acknowledgment marker in tasks.md (`- operator review ack: ACKNOWLEDGED @ <ISO8601>`).");
+  } else if (!statusTokenMatches(operatorReviewAck.status, ["ACKNOWLEDGED", "ACK", "CONFIRMED", "APPROVED"])) {
+    warnings.push(`Operator review acknowledgment marker is not acknowledged (${operatorReviewAck.status}).`);
+  }
+
+  return {
+    strictMode: gateMode.strict,
+    hasAnyMarker,
+    designApproval: {
+      state: designApprovalState,
+      stale: designApprovalStale,
+      marker: designApproval
+    },
+    planSelfReview: {
+      marker: planSelfReview
+    },
+    operatorReviewAck: {
+      marker: operatorReviewAck
+    },
+    malformed: [...designMarkers.malformed, ...taskMarkers.malformed],
+    blockers,
+    warnings,
+    notes
+  };
+}
+
+function mergeSignalBySurface(signals) {
+  const summary = {};
+  for (const signal of signals || []) {
+    const key = String(signal.surface || "").trim();
+    if (!key || summary[key]) {
+      continue;
+    }
+    summary[key] = signal;
+  }
+  return summary;
+}
+
+function applyTaskExecutionAndReviewFindings(findings, signals) {
+  const taskExecutionSignals = listSignalsBySurfacePrefix(signals, "task-execution.");
+  const taskReviewSignals = listSignalsBySurfacePrefix(signals, "task-review.");
+  const latestTaskExecution = mergeSignalBySurface(taskExecutionSignals);
+  const latestTaskReview = mergeSignalBySurface(taskReviewSignals);
+
+  for (const signal of Object.values(latestTaskExecution)) {
+    const envelope = signal.details && signal.details.envelope ? signal.details.envelope : null;
+    const taskGroupId =
+      (envelope && envelope.taskGroupId) ||
+      String(signal.surface || "").replace(/^task-execution\./, "") ||
+      "unknown";
+    if (signal.status === STATUS.BLOCK) {
+      findings.blockers.push(`Task group ${taskGroupId} is BLOCKED in implementer status envelope.`);
+    } else if (signal.status === STATUS.WARN) {
+      findings.warnings.push(`Task group ${taskGroupId} has unresolved implementer concerns/context needs.`);
+    }
+    if (envelope && envelope.summary) {
+      findings.notes.push(`Implementer summary ${taskGroupId}: ${envelope.summary}`);
+    }
+  }
+
+  const reviewStateByGroup = {};
+  for (const signal of Object.values(latestTaskReview)) {
+    const envelope = signal.details && signal.details.envelope ? signal.details.envelope : null;
+    const taskGroupId =
+      (envelope && envelope.taskGroupId) ||
+      String(signal.surface || "").replace(/^task-review\./, "").split(".")[0] ||
+      "unknown";
+    const stage = envelope && envelope.stage ? envelope.stage : String(signal.surface || "").split(".").pop();
+    if (!reviewStateByGroup[taskGroupId]) {
+      reviewStateByGroup[taskGroupId] = {};
+    }
+    reviewStateByGroup[taskGroupId][stage] = signal.status;
+    if (signal.status === STATUS.BLOCK) {
+      findings.blockers.push(`Task review ${taskGroupId}/${stage} is BLOCK.`);
+    } else if (signal.status === STATUS.WARN) {
+      findings.warnings.push(`Task review ${taskGroupId}/${stage} is WARN and requires follow-up.`);
+    }
+  }
+
+  for (const [taskGroupId, state] of Object.entries(reviewStateByGroup)) {
+    if (state.quality && state.quality === STATUS.PASS && state.spec !== STATUS.PASS) {
+      findings.blockers.push(
+        `Task review ordering violation for ${taskGroupId}: quality review passed before spec review PASS.`
+      );
+    }
+  }
+}
+
+function normalizeCheckpointStatus(status) {
+  const normalized = String(status || "").toUpperCase();
+  if (normalized === STATUS.PASS || normalized === STATUS.WARN || normalized === STATUS.BLOCK) {
+    return normalized;
+  }
+  return STATUS.PASS;
+}
+
 function collectIntegrityAudit(projectRoot, workflowRoot, signalSummary) {
   if (!pathExists(workflowRoot)) {
     return null;
@@ -121,6 +335,25 @@ function applyExecutionSignalFindings(stageId, findings, signalSummary) {
     findings.warnings.push(`Planning diff signal diff-spec reports ${diffSignal.status}.`);
   }
 
+  const lintTasksSignal = signalSummary["lint-tasks"];
+  const strictPromotion =
+    String(process.env.DA_VINCI_DISCIPLINE_STRICT_PROMOTION || "").trim() === "1" ||
+    /^true$/i.test(String(process.env.DA_VINCI_DISCIPLINE_STRICT_PROMOTION || "").trim());
+  if (lintTasksSignal && lintTasksSignal.status === STATUS.BLOCK) {
+    findings.blockers.push("lint-tasks signal is BLOCK and prevents promotion into build.");
+    if (nextStageId === "build" || nextStageId === "verify" || nextStageId === "complete") {
+      nextStageId = "tasks";
+    }
+  } else if (lintTasksSignal && lintTasksSignal.status === STATUS.WARN) {
+    findings.warnings.push("lint-tasks signal is WARN.");
+    if (strictPromotion && (nextStageId === "build" || nextStageId === "verify" || nextStageId === "complete")) {
+      findings.blockers.push(
+        "DA_VINCI_DISCIPLINE_STRICT_PROMOTION is enabled; lint-tasks WARN blocks promotion into build."
+      );
+      nextStageId = "tasks";
+    }
+  }
+
   const verificationSignal = signalSummary["verify-coverage"];
   if (verificationSignal && verificationSignal.status === STATUS.BLOCK) {
     findings.blockers.push("verify-coverage signal is BLOCK.");
@@ -266,6 +499,24 @@ function deriveStageFromArtifacts(artifactState, checkpointStatuses, findings) {
     findings.warnings.push("`design checkpoint` is WARN.");
   }
 
+  const designSourceCheckpoint = checkpointStatuses[CHECKPOINT_LABELS.DESIGN_SOURCE];
+  if (designSourceCheckpoint === STATUS.BLOCK) {
+    findings.blockers.push("`design source checkpoint` is BLOCK.");
+    return "design";
+  }
+  if (designSourceCheckpoint === STATUS.WARN) {
+    findings.warnings.push("`design source checkpoint` is WARN.");
+  }
+
+  const runtimeGateCheckpoint = checkpointStatuses[CHECKPOINT_LABELS.RUNTIME_GATE];
+  if (runtimeGateCheckpoint === STATUS.BLOCK) {
+    findings.blockers.push("`mcp runtime gate` is BLOCK.");
+    return "design";
+  }
+  if (runtimeGateCheckpoint === STATUS.WARN) {
+    findings.warnings.push("`mcp runtime gate` is WARN.");
+  }
+
   const mappingCheckpoint = checkpointStatuses[CHECKPOINT_LABELS.MAPPING];
   if (mappingCheckpoint === STATUS.BLOCK) {
     findings.blockers.push("`mapping checkpoint` is BLOCK.");
@@ -335,6 +586,21 @@ function deriveTaskGroupMetadata(tasksMarkdownText, checkpointStatuses) {
   }
 
   const normalizedTaskCheckpoint = checkpointStatuses[CHECKPOINT_LABELS.TASK] || STATUS.WARN;
+  const groupMetadataById = new Map(
+    (taskArtifact.taskGroups || []).map((group) => [
+      group.id,
+      {
+        targetFiles: Array.isArray(group.targetFiles) ? group.targetFiles : [],
+        fileReferences: Array.isArray(group.fileReferences) ? group.fileReferences : [],
+        verificationActions: Array.isArray(group.verificationActions) ? group.verificationActions : [],
+        verificationCommands: Array.isArray(group.verificationCommands) ? group.verificationCommands : [],
+        executionIntent: Array.isArray(group.executionIntent) ? group.executionIntent : [],
+        reviewIntent: group.reviewIntent === true,
+        testingIntent: group.testingIntent === true,
+        codeChangeLikely: group.codeChangeLikely === true
+      }
+    ])
+  );
   const metadata = sections.map((section, index) => {
     const total = section.checklistItems.length;
     const done = section.checklistItems.filter((item) => item.checked).length;
@@ -345,6 +611,7 @@ function deriveTaskGroupMetadata(tasksMarkdownText, checkpointStatuses) {
       sectionStatus === "completed"
         ? "advance to next task group"
         : section.checklistItems.find((item) => !item.checked)?.text || "continue group work";
+    const groupMetadata = groupMetadataById.get(section.id) || {};
 
     return {
       taskGroupId: section.id,
@@ -354,6 +621,14 @@ function deriveTaskGroupMetadata(tasksMarkdownText, checkpointStatuses) {
       checkpointOutcome: normalizedTaskCheckpoint,
       evidence: section.checklistItems.filter((item) => item.checked).map((item) => item.text),
       nextAction,
+      targetFiles: groupMetadata.targetFiles || [],
+      fileReferences: groupMetadata.fileReferences || [],
+      verificationActions: groupMetadata.verificationActions || [],
+      verificationCommands: groupMetadata.verificationCommands || [],
+      executionIntent: groupMetadata.executionIntent || [],
+      reviewIntent: groupMetadata.reviewIntent === true,
+      testingIntent: groupMetadata.testingIntent === true,
+      codeChangeLikely: groupMetadata.codeChangeLikely === true,
       resumeCursor: {
         groupIndex: index,
         nextUncheckedItem:
@@ -365,19 +640,30 @@ function deriveTaskGroupMetadata(tasksMarkdownText, checkpointStatuses) {
   });
 
   if (metadata.length === 0 && taskArtifact.taskGroups.length > 0) {
-    return taskArtifact.taskGroups.map((group, index) => ({
-      taskGroupId: group.id,
-      title: group.title,
-      status: "pending",
-      completion: 0,
-      checkpointOutcome: normalizedTaskCheckpoint,
-      evidence: [],
-      nextAction: "start task group",
-      resumeCursor: {
-        groupIndex: index,
-        nextUncheckedItem: null
-      }
-    }));
+    return taskArtifact.taskGroups.map((group, index) => {
+      const groupMetadata = groupMetadataById.get(group.id) || {};
+      return {
+        taskGroupId: group.id,
+        title: group.title,
+        status: "pending",
+        completion: 0,
+        checkpointOutcome: normalizedTaskCheckpoint,
+        evidence: [],
+        nextAction: "start task group",
+        targetFiles: groupMetadata.targetFiles || [],
+        fileReferences: groupMetadata.fileReferences || [],
+        verificationActions: groupMetadata.verificationActions || [],
+        verificationCommands: groupMetadata.verificationCommands || [],
+        executionIntent: groupMetadata.executionIntent || [],
+        reviewIntent: groupMetadata.reviewIntent === true,
+        testingIntent: groupMetadata.testingIntent === true,
+        codeChangeLikely: groupMetadata.codeChangeLikely === true,
+        resumeCursor: {
+          groupIndex: index,
+          nextUncheckedItem: null
+        }
+      };
+    });
   }
 
   return metadata;
@@ -474,14 +760,32 @@ function deriveWorkflowStatus(projectPathInput, options = {}) {
 
   const tasksArtifactText = activeChangeDir ? readTextIfExists(path.join(activeChangeDir, "tasks.md")) : "";
   const checkpointStatuses = activeChangeDir ? readCheckpointStatuses(activeChangeDir) : {};
-  const signalSummary = activeChangeId
-    ? summarizeSignalsBySurface(
-        readExecutionSignals(projectRoot, {
-          changeId: activeChangeId
-        })
-      )
-    : {};
+  const changeSignals = activeChangeId
+    ? readExecutionSignals(projectRoot, {
+        changeId: activeChangeId
+      })
+    : [];
+  const signalSummary = summarizeSignalsBySurface(changeSignals);
+  const disciplineState = activeChangeDir ? inspectDisciplineState(activeChangeDir) : null;
+  const freshnessArtifactPaths = activeChangeDir
+    ? {
+        proposalPath: path.join(activeChangeDir, "proposal.md"),
+        tasksPath: path.join(activeChangeDir, "tasks.md"),
+        bindingsPath: path.join(activeChangeDir, "pencil-bindings.md"),
+        pencilDesignPath: path.join(activeChangeDir, "pencil-design.md"),
+        verificationPath: path.join(activeChangeDir, "verification.md")
+      }
+    : null;
   const integrityAudit = collectIntegrityAudit(projectRoot, workflowRoot, signalSummary);
+  const designCheckpointStatus = normalizeCheckpointStatus(checkpointStatuses[CHECKPOINT_LABELS.DESIGN]);
+  const designSourceCheckpointStatus = normalizeCheckpointStatus(
+    checkpointStatuses[CHECKPOINT_LABELS.DESIGN_SOURCE]
+  );
+  const runtimeGateCheckpointStatus = normalizeCheckpointStatus(
+    checkpointStatuses[CHECKPOINT_LABELS.RUNTIME_GATE]
+  );
+  const mappingCheckpointStatus = normalizeCheckpointStatus(checkpointStatuses[CHECKPOINT_LABELS.MAPPING]);
+  const taskCheckpointStatus = normalizeCheckpointStatus(checkpointStatuses[CHECKPOINT_LABELS.TASK]);
 
   if (activeChangeId) {
     const persistedSelection = selectPersistedStateForChange(projectRoot, activeChangeId, {
@@ -513,6 +817,33 @@ function deriveWorkflowStatus(projectPathInput, options = {}) {
         persistedFindings,
         signalSummary
       );
+      applyTaskExecutionAndReviewFindings(persistedFindings, changeSignals);
+      if (disciplineState) {
+        persistedFindings.blockers.push(...disciplineState.blockers);
+        persistedFindings.warnings.push(...disciplineState.warnings);
+        persistedFindings.notes.push(...disciplineState.notes);
+        if (disciplineState.blockers.length > 0 && ["build", "verify", "complete"].includes(persistedStageId)) {
+          persistedStageId = artifactState.tasks ? "tasks" : "design";
+        }
+      }
+
+      const verificationFreshness = activeChangeId
+        ? collectVerificationFreshness(projectRoot, {
+            changeId: activeChangeId,
+            resolved: { changeDir: activeChangeDir },
+            artifactPaths: freshnessArtifactPaths
+          })
+        : null;
+      if (
+        verificationFreshness &&
+        !verificationFreshness.fresh &&
+        (persistedStageId === "verify" || persistedStageId === "complete")
+      ) {
+        persistedFindings.blockers.push(
+          "Completion-facing routing requires fresh verification evidence; stale evidence keeps the route in verify."
+        );
+        persistedStageId = "verify";
+      }
       persistedFindings.notes.push("workflow-status is using trusted persisted workflow state.");
       dedupeFindings(persistedFindings);
 
@@ -524,6 +855,39 @@ function deriveWorkflowStatus(projectPathInput, options = {}) {
         persistedGates[HANDOFF_GATES.VERIFY_TO_COMPLETE] =
           completionAudit.status === "PASS" ? STATUS.PASS : STATUS.WARN;
       }
+      if (disciplineState && disciplineState.blockers.length > 0) {
+        persistedGates[HANDOFF_GATES.TASKS_TO_BUILD] = STATUS.BLOCK;
+      }
+      if (verificationFreshness && !verificationFreshness.fresh) {
+        persistedGates[HANDOFF_GATES.VERIFY_TO_COMPLETE] = STATUS.BLOCK;
+      }
+      const persistedTaskGroups =
+        persistedTaskMetadata && Array.isArray(persistedTaskMetadata.taskGroups)
+          ? persistedTaskMetadata.taskGroups
+          : Array.isArray(persistedRecord.taskGroups)
+          ? persistedRecord.taskGroups
+          : [];
+      const executionProfile = deriveExecutionProfile({
+        stage: persistedStageId,
+        taskGroups: persistedTaskGroups
+      });
+      let worktreePreflight = null;
+      if (activeChangeId && (persistedStageId === "build" || persistedStageId === "verify")) {
+        worktreePreflight = runWorktreePreflight(projectRoot, {
+          parallelPreferred: executionProfile.mode === "bounded_parallel"
+        });
+        if (
+          executionProfile.mode === "bounded_parallel" &&
+          worktreePreflight.summary &&
+          worktreePreflight.summary.recommendedIsolation
+        ) {
+          executionProfile.effectiveMode = "serial";
+          executionProfile.rationale = dedupeMessages([
+            ...(executionProfile.rationale || []),
+            "worktree preflight recommends isolation; effective mode downgraded to serial"
+          ]);
+        }
+      }
 
       return buildWorkflowResult({
         projectRoot,
@@ -542,12 +906,11 @@ function deriveWorkflowStatus(projectPathInput, options = {}) {
           ambiguousChangeSelection
         },
         source: "persisted",
-        taskGroups:
-          persistedTaskMetadata && Array.isArray(persistedTaskMetadata.taskGroups)
-            ? persistedTaskMetadata.taskGroups
-            : Array.isArray(persistedRecord.taskGroups)
-            ? persistedRecord.taskGroups
-            : []
+        taskGroups: persistedTaskGroups,
+        discipline: disciplineState,
+        executionProfile,
+        worktreePreflight,
+        verificationFreshness
       });
     }
 
@@ -575,21 +938,86 @@ function deriveWorkflowStatus(projectPathInput, options = {}) {
     : null;
   stageId = applyAuditFindings(stageId, findings, integrityAudit, completionAudit);
   stageId = applyExecutionSignalFindings(stageId, findings, signalSummary);
+  applyTaskExecutionAndReviewFindings(findings, changeSignals);
+  if (disciplineState) {
+    findings.blockers.push(...disciplineState.blockers);
+    findings.warnings.push(...disciplineState.warnings);
+    findings.notes.push(...disciplineState.notes);
+    if (disciplineState.blockers.length > 0 && ["build", "verify", "complete"].includes(stageId)) {
+      stageId = artifactState.tasks ? "tasks" : "design";
+    }
+  }
+
+  const verificationFreshness = activeChangeId
+    ? collectVerificationFreshness(projectRoot, {
+        changeId: activeChangeId,
+        resolved: { changeDir: activeChangeDir },
+        artifactPaths: freshnessArtifactPaths
+      })
+    : null;
+  if (verificationFreshness && !verificationFreshness.fresh && (stageId === "verify" || stageId === "complete")) {
+    findings.blockers.push(
+      "Completion-facing routing requires fresh verification evidence; stale evidence keeps the route in verify."
+    );
+    stageId = "verify";
+  }
 
   const gates = {
     [HANDOFF_GATES.BREAKDOWN_TO_DESIGN]:
       artifactState.proposal && artifactState.specFiles.length > 0 ? STATUS.PASS : STATUS.BLOCK,
-    [HANDOFF_GATES.DESIGN_TO_TASKS]:
+    [HANDOFF_GATES.DESIGN_TO_TASKS]: mergeStatuses([
       artifactState.design && artifactState.pencilDesign && artifactState.pencilBindings
         ? STATUS.PASS
         : STATUS.BLOCK,
-    [HANDOFF_GATES.TASKS_TO_BUILD]: artifactState.tasks ? STATUS.PASS : STATUS.BLOCK,
+      designCheckpointStatus,
+      designSourceCheckpointStatus,
+      runtimeGateCheckpointStatus,
+      mappingCheckpointStatus
+    ]),
+    [HANDOFF_GATES.TASKS_TO_BUILD]: mergeStatuses([
+      artifactState.tasks ? STATUS.PASS : STATUS.BLOCK,
+      designCheckpointStatus,
+      designSourceCheckpointStatus,
+      runtimeGateCheckpointStatus,
+      mappingCheckpointStatus,
+      taskCheckpointStatus
+    ]),
     [HANDOFF_GATES.BUILD_TO_VERIFY]: artifactState.verification ? STATUS.PASS : STATUS.BLOCK,
     [HANDOFF_GATES.VERIFY_TO_COMPLETE]:
       completionAudit && completionAudit.status === "PASS" ? STATUS.PASS : STATUS.WARN
   };
+  if (disciplineState && disciplineState.blockers.length > 0) {
+    gates[HANDOFF_GATES.TASKS_TO_BUILD] = STATUS.BLOCK;
+  }
+  if (verificationFreshness && !verificationFreshness.fresh) {
+    gates[HANDOFF_GATES.VERIFY_TO_COMPLETE] = STATUS.BLOCK;
+  }
 
   const derivedTaskGroups = deriveTaskGroupMetadata(tasksArtifactText, checkpointStatuses);
+  const executionProfile = deriveExecutionProfile({
+    stage: stageId,
+    taskGroups: derivedTaskGroups
+  });
+  let worktreePreflight = null;
+  if (activeChangeId && (stageId === "build" || stageId === "verify")) {
+    worktreePreflight = runWorktreePreflight(projectRoot, {
+      parallelPreferred: executionProfile.mode === "bounded_parallel"
+    });
+    if (
+      executionProfile.mode === "bounded_parallel" &&
+      worktreePreflight.summary &&
+      worktreePreflight.summary.recommendedIsolation
+    ) {
+      executionProfile.effectiveMode = "serial";
+      executionProfile.rationale = dedupeMessages([
+        ...(executionProfile.rationale || []),
+        "worktree preflight recommends isolation; effective mode downgraded to serial"
+      ]);
+      findings.warnings.push(
+        "Bounded-parallel profile downgraded to serial until worktree isolation is ready or explicitly accepted."
+      );
+    }
+  }
   if (activeChangeId && !ambiguousChangeSelection && derivedTaskGroups.length > 0) {
     const metadataPayload = {
       version: 1,
@@ -625,7 +1053,11 @@ function deriveWorkflowStatus(projectPathInput, options = {}) {
       changeId: activeChangeId || requestedChangeId || "change-001",
       ambiguousChangeSelection
     },
-    taskGroups: derivedTaskGroups
+    taskGroups: derivedTaskGroups,
+    discipline: disciplineState,
+    executionProfile,
+    worktreePreflight,
+    verificationFreshness
   });
 
   if (activeChangeId && !ambiguousChangeSelection) {
@@ -685,7 +1117,11 @@ function buildWorkflowResult(params) {
     audits: params.audits,
     nextStep,
     source: params.source || "derived",
-    taskGroups: Array.isArray(params.taskGroups) ? params.taskGroups : []
+    taskGroups: Array.isArray(params.taskGroups) ? params.taskGroups : [],
+    discipline: params.discipline || null,
+    executionProfile: params.executionProfile || null,
+    worktreePreflight: params.worktreePreflight || null,
+    verificationFreshness: params.verificationFreshness || null
   };
 }
 
@@ -707,6 +1143,25 @@ function formatWorkflowStatusReport(result) {
     lines.push("Next route: none");
   }
 
+  if (result.discipline && result.discipline.designApproval) {
+    lines.push(`Discipline design approval: ${result.discipline.designApproval.state}`);
+  }
+  if (result.executionProfile) {
+    lines.push(
+      `Execution profile: ${result.executionProfile.mode}${
+        result.executionProfile.effectiveMode
+          ? ` (effective ${result.executionProfile.effectiveMode})`
+          : ""
+      }, max parallel ${result.executionProfile.maxParallel}`
+    );
+  }
+  if (result.worktreePreflight) {
+    lines.push(`Worktree preflight: ${result.worktreePreflight.status} (advisory)`);
+  }
+  if (result.verificationFreshness) {
+    lines.push(`Verification freshness: ${result.verificationFreshness.fresh ? "fresh" : "stale"}`);
+  }
+
   if (result.failures.length > 0) {
     lines.push("Blockers:");
     for (const message of result.failures) {
@@ -767,6 +1222,21 @@ function formatNextStepReport(result) {
   if (result.nextStep.reason) {
     lines.push(`Reason: ${result.nextStep.reason}`);
   }
+  if (result.executionProfile) {
+    lines.push(
+      `Execution profile: ${result.executionProfile.mode}${
+        result.executionProfile.effectiveMode
+          ? ` (effective ${result.executionProfile.effectiveMode})`
+          : ""
+      }, max parallel ${result.executionProfile.maxParallel}`
+    );
+  }
+  if (result.worktreePreflight) {
+    lines.push(`Worktree preflight: ${result.worktreePreflight.status} (advisory)`);
+  }
+  if (result.verificationFreshness && !result.verificationFreshness.fresh) {
+    lines.push("Completion evidence is stale; stay in verify until fresh evidence is recorded.");
+  }
   if (Array.isArray(result.taskGroups) && result.taskGroups.length > 0) {
     const active =
       result.taskGroups.find((group) => group.status === "in_progress") ||