@cassiomc1/forgeloop 1.3.0 → 1.6.0

package/src/core/next-action.js

@@ -16,10 +16,13 @@ import { validateEventLedger, validateCompletionRecoveryAuthorization } from "./
 import {
   NEXT_ACTIONS,
   commandFor,
+  directCommandSpec,
   decision,
   recordCheckCommandSpec,
   recordDiagnosisCommandSpec,
+  recordInterventionCommandSpec,
   recordTerminalResultCommandSpec,
+  recoveryGuidanceForClassification,
   result,
   uniqueSorted,
 } from "./next-action-model.js";
@@ -33,15 +36,196 @@ 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 { resolveCurrentCycleDiagnostic } from "./diagnostic-projection.js";
+import { buildTaskReflection } from "./reflection.js";
 import { evaluateProgress, PROGRESS_STATUS } from "./progress.js";
 import { criterionForDecision } from "./settlement-model.js";
 import { readEvents } from "./events.js";
+import { inspectTaskConflictState } from "./task-conflict-inspection.js";
+import { listActions } from "./actions.js";
+import { listApprovals, validateApprovalForAction } from "./approvals.js";
+import { evaluateActionCapability } from "./capability-policy.js";
+import { loadPolicyIdentity } from "./policy-engine.js";
 
 export { NEXT_ACTIONS } from "./next-action-model.js";
 
+function capabilityDecisionMetadata(action, capability, approvalId = null) {
+  return {
+    capability: action.capability,
+    decision: capability.decision,
+    reasonCode: capability.reasonCode ?? null,
+    policyFingerprint: capability.policyFingerprint ?? null,
+    ...(capability.authority?.authorityRef ? { authorityRef: capability.authority.authorityRef } : {}),
+    ...(capability.approval?.approvalId
+      ? { approvalId: capability.approval.approvalId }
+      : approvalId ? { approvalId } : {}),
+  };
+}
+
+function authorizeActionGuidance({ context, state, action, capability, eventsRel }) {
+  const approvalId = capability.approval?.approvalId ?? null;
+  const approvalSuffix = approvalId ? ` --approval ${approvalId}` : "";
+  return result({
+    ...context,
+    nextAction: NEXT_ACTIONS.AUTHORIZE_ACTION,
+    commands: [`forgeloop action-authorize --task ${state.taskId} --action ${action.actionId}${approvalSuffix}`],
+    reasons: [artifactError(
+      "E_ACTION_AUTHORIZATION_REQUIRED",
+      `Required action ${action.actionId} is PROPOSED and is authorizable under the canonical capability policy.`,
+    )],
+    capabilityDecision: capabilityDecisionMetadata(action, capability),
+    requiredArtifacts: [taskArtifactPath(state.taskId, "actions"), eventsRel],
+  });
+}
+
+function actionApprovalGuidance({ context, state, action, capability, eventsRel }) {
+  return result({
+    ...context,
+    nextAction: NEXT_ACTIONS.REQUEST_ACTION_APPROVAL,
+    commands: [
+      `forgeloop approval-request --task ${state.taskId} --action ${action.actionId} --approval <approval-id> --reason <reason>`,
+    ],
+    commandSpecs: [{
+      ...directCommandSpec("approval-request", state.taskId, [
+        { name: "approvalId", option: "--approval=<approval-id>" },
+        { name: "actionId", option: "--action=<action-id>" },
+        { name: "reason", option: "--reason=<text>" },
+      ]),
+    }],
+    reasons: [artifactError(
+      "E_ACTION_APPROVAL_REQUIRED",
+      `Capability policy requires a current approval before required action ${action.actionId} can be authorized.`,
+    )],
+    approvalRequired: {
+      actionId: action.actionId,
+      capability: action.capability,
+      reason: "Capability policy requires approval before authorization.",
+    },
+    capabilityDecision: capabilityDecisionMetadata(action, capability),
+    requiredArtifacts: [taskArtifactPath(state.taskId, "actions"), eventsRel],
+  });
+}
+
+function actionAuthorityGuidance({ context, state, action, capability, eventsRel }) {
+  return result({
+    ...context,
+    nextAction: NEXT_ACTIONS.AUTHORIZE_ACTION,
+    commands: [],
+    reasons: [artifactError(
+      capability.reasonCode ?? "E_ACTION_AUTHORITY_REQUIRED",
+      `Required action ${action.actionId} needs trusted host authority before it can be authorized.`,
+    )],
+    authorityRequired: {
+      kind: "HOST_ATTESTED",
+      actionId: action.actionId,
+      capability: action.capability,
+      reason: capability.allowed
+        ? "Authorization must be performed by a trusted host boundary that preserves authority context."
+        : "Capability policy requires trusted host authority; no standalone CLI command can create it.",
+    },
+    hostActionRequired: {
+      action: "action-authorize",
+      actionId: action.actionId,
+      executionBoundary: "HOST",
+      requiresAuthorityContext: true,
+    },
+    capabilityDecision: capabilityDecisionMetadata(action, capability),
+    requiredArtifacts: [taskArtifactPath(state.taskId, "actions"), eventsRel],
+  });
+}
+
+function actionApprovalResolutionGuidance({ context, state, action, approval, eventsRel }) {
+  return result({
+    ...context,
+    nextAction: NEXT_ACTIONS.RESOLVE_ACTION_APPROVAL,
+    commands: [],
+    reasons: [artifactError(
+      "E_ACTION_APPROVAL_REQUIRED",
+      `Required action ${action.actionId} is waiting for approval.`,
+    )],
+    requiredArtifacts: [taskArtifactPath(state.taskId, "approvals"), eventsRel],
+    authorityRequired: {
+      kind: "HOST_ATTESTED",
+      approvalId: approval.approvalId,
+      actionId: action.actionId,
+      reason: "This approval must be resolved by a trusted host/operator boundary.",
+    },
+  });
+}
+
+function actionDeniedGuidance({ context, state, action, capability, eventsRel }) {
+  return result({
+    ...context,
+    nextAction: NEXT_ACTIONS.RESOLVE_BLOCKER,
+    commands: [],
+    reasons: [artifactError(
+      capability.reasonCode ?? "E_ACTION_CAPABILITY_DENIED",
+      `Capability policy does not authorize required action ${action.actionId}: ${capability.decision}.`,
+    )],
+    capabilityDecision: capabilityDecisionMetadata(action, capability),
+    requiredArtifacts: [taskArtifactPath(state.taskId, "actions"), eventsRel],
+  });
+}
+
+function actionPolicyEpochGuidance({ context, state, action, policyIdentity, eventsRel }) {
+  const code = policyIdentity.code ?? "E_ACTION_POLICY_LOCK_REQUIRED";
+  const recoveryAction = policyRecoveryAction([{ code }]);
+  return result({
+    ...context,
+    nextAction: recoveryAction ?? NEXT_ACTIONS.RESOLVE_BLOCKER,
+    commands: [],
+    reasons: [artifactError(
+      code,
+      policyIdentity.message
+        ?? `Required action ${action.actionId} cannot be evaluated because the capability policy is not bound to the active task policy epoch.`,
+      [taskArtifactPath(state.taskId, "actions"), eventsRel],
+    )],
+    requiredArtifacts: [taskArtifactPath(state.taskId, "actions"), eventsRel],
+  });
+}
+
+async function evaluateProposedActionCapability({ target, packageRoot, action, approvals, authorityContext }) {
+  const current = await evaluateActionCapability({ target, packageRoot, action, authorityContext });
+  if (current.decision !== "REQUIRE_APPROVAL" || !approvals) return current;
+  const approved = approvals.filter((approval) => approval.actionId === action.actionId && approval.status === "APPROVED");
+  for (const approval of approved) {
+    const evaluated = await evaluateActionCapability({
+      target,
+      packageRoot,
+      action,
+      authorityContext,
+      approval: { approvalId: approval.approvalId },
+    });
+    if (evaluated.allowed) return evaluated;
+  }
+  return current;
+}
+
+async function findApplicablePendingApproval({ target, packageRoot, taskId, action, approvals }) {
+  for (const approval of approvals) {
+    if (approval.status !== "PENDING" || approval.actionId !== action.actionId) continue;
+    try {
+      return await validateApprovalForAction(target, {
+        packageRoot,
+        taskId,
+        action,
+        approvalId: approval.approvalId,
+        requireApproved: false,
+      });
+    } catch (error) {
+      if (["E_APPROVAL_STALE", "E_APPROVAL_INVALID"].includes(error.code)) continue;
+      throw error;
+    }
+  }
+  return null;
+}
+
 export function policyRecoveryAction(errors = []) {
-  if (errors.some((e) => e.code === "E_POLICY_WEAKENING" || e.code === "E_POLICY_LOCK_MISMATCH")) {
+  if (errors.some((e) => [
+    "E_POLICY_WEAKENING",
+    "E_POLICY_LOCK_MISMATCH",
+    "E_ACTION_POLICY_DRIFT",
+  ].includes(e.code))) {
     return NEXT_ACTIONS.RESTORE_POLICY;
   }
   if (errors.some((e) => e.code === "E_CHECK_MUTATION_EXECUTION_ERROR" || e.code === "E_CHECK_MUTATION_NOT_DETECTED")) {
@@ -145,6 +329,269 @@ async function computeNextAction(targetOrOptions = {}, packageRootOption) {
 
   const state = workState.value;
   const context = { taskId: state.taskId, currentPhase: state.phase };
+  if (explicitTaskId) {
+    let inspection;
+    try {
+      inspection = await inspectTaskConflictState(target, {
+        taskId: explicitTaskId,
+        packageRoot,
+      });
+    } catch (error) {
+      inspection = {
+        classification: "INCONSISTENT",
+        reasonCodes: [error.code ?? "E_TASK_RECOVERY_INCONSISTENT"],
+      };
+    }
+    if (!["ACTIVE", "COMPLETE"].includes(inspection.classification)) {
+      const guidance = recoveryGuidanceForClassification(inspection.classification, explicitTaskId);
+      return result({
+        ...context,
+        nextAction: guidance.nextAction,
+        commands: guidance.commands,
+        commandSpecs: guidance.commandSpecs,
+        reasons: inspection.reasonCodes.map((code) => artifactError(
+          code,
+          `Task conflict state is ${inspection.classification}; follow the structured recovery guidance.`,
+          [stateRel, eventsRel, taskArtifactPath(explicitTaskId, "recovery")],
+        )),
+        requiredArtifacts: [stateRel, eventsRel],
+      });
+    }
+  }
+  let actionsForApproval;
+  try {
+    actionsForApproval = await listActions(target, { packageRoot, taskId: state.taskId });
+  } catch (error) {
+    if (error.code === "E_ACTION_INVALID") {
+      return result({
+        ...context,
+        nextAction: NEXT_ACTIONS.RESOLVE_BLOCKER,
+        commands: [],
+        reasons: [artifactError(
+          error.code,
+          `A durable action artifact is invalid and cannot be offered for authorization: ${error.message}`,
+          [taskArtifactPath(state.taskId, "actions"), eventsRel],
+        )],
+        requiredArtifacts: [taskArtifactPath(state.taskId, "actions"), eventsRel],
+      });
+    }
+    throw error;
+  }
+  const ambiguousAction = actionsForApproval.find((action) => action.state === "COMMIT_UNKNOWN");
+  if (ambiguousAction) {
+    return result({ ...context, nextAction: NEXT_ACTIONS.RECONCILE_ACTION,
+      commands: [`forgeloop action-reconcile --task ${state.taskId} --action ${ambiguousAction.actionId} --outcome UNKNOWN`],
+      reasons: [artifactError("E_ACTION_RECONCILIATION_REQUIRED",
+        `Action ${ambiguousAction.actionId} has an unknown external commit outcome; retry is forbidden until reconciliation.`)],
+      reconciliationAuthorityRequired: {
+        outcomesRequiringTrust: ["COMMITTED", "NOT_COMMITTED"],
+        reason: "Recording an UNKNOWN observation is safe from any surface; settling COMMITTED or NOT_COMMITTED requires a trusted host boundary and evidence.",
+      },
+      requiredArtifacts: [taskArtifactPath(state.taskId, "actions"), eventsRel] });
+  }
+  // A PROPOSED required action ready for authorization should use the
+  // canonical authorization surface; host/approval blockers remain structured.
+  const authorizableAction = actionsForApproval.find((action) => action.requiredForCompletion
+    && action.state === "PROPOSED");
+  if (authorizableAction) {
+    let policyIdentity;
+    try {
+      policyIdentity = await loadPolicyIdentity(target, packageRoot, state.taskId);
+    } catch (error) {
+      return actionPolicyEpochGuidance({
+        context,
+        state,
+        action: authorizableAction,
+        policyIdentity: {
+          code: error.code ?? "E_POLICY_INVALID",
+          message: `Capability policy epoch validation failed for required action ${authorizableAction.actionId}: ${error.message}`,
+        },
+        eventsRel,
+      });
+    }
+    if (policyIdentity.status !== "VALID") {
+      return actionPolicyEpochGuidance({
+        context,
+        state,
+        action: authorizableAction,
+        policyIdentity,
+        eventsRel,
+      });
+    }
+
+    let capability;
+    try {
+      capability = await evaluateProposedActionCapability({
+        target,
+        packageRoot,
+        action: authorizableAction,
+        authorityContext,
+      });
+    } catch (error) {
+      return result({
+        ...context,
+        nextAction: NEXT_ACTIONS.RESOLVE_BLOCKER,
+        commands: [],
+        reasons: [artifactError(
+          error.code ?? "E_ACTION_CAPABILITY_INVALID",
+          `Capability policy evaluation failed for required action ${authorizableAction.actionId}: ${error.message}`,
+          [taskArtifactPath(state.taskId, "actions"), eventsRel],
+        )],
+        capabilityDecision: {
+          capability: authorizableAction.capability,
+          decision: "DENY",
+          reasonCode: error.code ?? "E_ACTION_CAPABILITY_INVALID",
+          policyFingerprint: null,
+        },
+        requiredArtifacts: [taskArtifactPath(state.taskId, "actions"), eventsRel],
+      });
+    }
+    if (capability.decision === "REQUIRE_AUTHORITY") {
+      return actionAuthorityGuidance({
+        context,
+        state,
+        action: authorizableAction,
+        capability,
+        eventsRel,
+      });
+    }
+    if (capability.allowed) {
+      return authorizeActionGuidance({
+        context,
+        state,
+        action: authorizableAction,
+        capability,
+        eventsRel,
+      });
+    }
+    if (capability.decision === "REQUIRE_APPROVAL") {
+      let approvals;
+      try {
+        approvals = await listApprovals(target, { packageRoot, taskId: state.taskId });
+      } catch (error) {
+        return result({
+          ...context,
+          nextAction: NEXT_ACTIONS.RESOLVE_BLOCKER,
+          commands: [],
+          reasons: [artifactError(
+            error.code ?? "E_APPROVAL_INVALID",
+            `Approval artifact inspection failed for required action ${authorizableAction.actionId}: ${error.message}`,
+            [taskArtifactPath(state.taskId, "approvals"), eventsRel],
+          )],
+          capabilityDecision: capabilityDecisionMetadata(authorizableAction, capability),
+          requiredArtifacts: [taskArtifactPath(state.taskId, "approvals"), eventsRel],
+        });
+      }
+      try {
+        capability = await evaluateProposedActionCapability({
+          target,
+          packageRoot,
+          action: authorizableAction,
+          approvals,
+          authorityContext,
+        });
+      } catch (error) {
+        return result({
+          ...context,
+          nextAction: NEXT_ACTIONS.RESOLVE_BLOCKER,
+          commands: [],
+          reasons: [artifactError(
+            error.code ?? "E_ACTION_CAPABILITY_INVALID",
+            `Capability policy evaluation failed for required action ${authorizableAction.actionId}: ${error.message}`,
+            [taskArtifactPath(state.taskId, "actions"), eventsRel],
+          )],
+          capabilityDecision: {
+            capability: authorizableAction.capability,
+            decision: "DENY",
+            reasonCode: error.code ?? "E_ACTION_CAPABILITY_INVALID",
+            policyFingerprint: null,
+          },
+          requiredArtifacts: [taskArtifactPath(state.taskId, "actions"), eventsRel],
+        });
+      }
+      if (capability.allowed) {
+        return authorizeActionGuidance({
+          context,
+          state,
+          action: authorizableAction,
+          capability,
+          eventsRel,
+        });
+      }
+      if (capability.decision !== "REQUIRE_APPROVAL") {
+        if (capability.decision === "REQUIRE_AUTHORITY") {
+          return actionAuthorityGuidance({
+            context,
+            state,
+            action: authorizableAction,
+            capability,
+            eventsRel,
+          });
+        }
+        if (capability.allowed) {
+          return authorizeActionGuidance({
+            context,
+            state,
+            action: authorizableAction,
+            capability,
+            eventsRel,
+          });
+        }
+        return actionDeniedGuidance({
+          context,
+          state,
+          action: authorizableAction,
+          capability,
+          eventsRel,
+        });
+      }
+      const pendingApproval = await findApplicablePendingApproval({
+        target,
+        packageRoot,
+        taskId: state.taskId,
+        action: authorizableAction,
+        approvals,
+      });
+      if (pendingApproval) {
+        return actionApprovalResolutionGuidance({
+          context,
+          state,
+          action: authorizableAction,
+          approval: pendingApproval,
+          eventsRel,
+        });
+      }
+      return actionApprovalGuidance({
+        context,
+        state,
+        action: authorizableAction,
+        capability,
+        eventsRel,
+      });
+    }
+    return actionDeniedGuidance({
+      context,
+      state,
+      action: authorizableAction,
+      capability,
+      eventsRel,
+    });
+  }
+  // Committed-but-unverified required action needs canonical postcondition
+  // evidence before it can satisfy completion.
+  const committedActions = actionsForApproval;
+  const unverifiedRequired = committedActions.find((action) => action.requiredForCompletion
+    && action.state === "COMMITTED");
+  if (unverifiedRequired) {
+    return result({ ...context, nextAction: NEXT_ACTIONS.VERIFY_EXTERNAL_ACTION,
+      commands: [
+        `forgeloop run-check --task ${state.taskId} --id check-postcondition --requirement <requirement> -- <independent verification argv>`,
+        `forgeloop action-verify --task ${state.taskId} --action ${unverifiedRequired.actionId} --evidence <execution-ref>`,
+      ],
+      reasons: [artifactError("E_ACTION_VERIFICATION_REQUIRED",
+        `Committed action ${unverifiedRequired.actionId} requires independent canonical postcondition evidence; exit code 0 alone is not verification.`)],
+      requiredArtifacts: [taskArtifactPath(state.taskId, "actions"), eventsRel] });
+  }
   if (state.phase === "RECEIVED") {
     return decision(
       context,
@@ -498,7 +945,7 @@ async function computeNextAction(targetOrOptions = {}, packageRootOption) {
   if (state.phase === "DIAGNOSING") {
     const ledger = await validateEventLedger(target, packageRoot, { taskId: normalized.taskId ?? null });
     const cycle = state.verificationCycle ?? 1;
-    const diagEvent = currentCycleDiagnosis(ledger.events, state.taskId, cycle);
+    const diagEvent = resolveCurrentCycleDiagnostic(ledger.events, state.taskId, cycle);
     if (!diagEvent) {
       return result({
         ...context,
@@ -516,6 +963,13 @@ async function computeNextAction(targetOrOptions = {}, packageRootOption) {
     }
     const progress = evaluateProgress({ state, events: ledger.events });
     if (progress.status === PROGRESS_STATUS.STALLED) {
+      let oscillating = false;
+      try {
+        const reflection = await buildTaskReflection({ target, packageRoot, taskId: normalized.taskId ?? null });
+        oscillating = reflection.oscillation.detected;
+      } catch {
+        // Reflection is advisory guidance; stall handling must not depend on it.
+      }
       return result({
         ...context,
         nextAction: NEXT_ACTIONS.CHANGE_STRATEGY,
@@ -527,6 +981,11 @@ async function computeNextAction(targetOrOptions = {}, packageRootOption) {
           ),
         ],
         progress,
+        diagnosticGuidance: {
+          action: oscillating ? NEXT_ACTIONS.INTRODUCE_NEW_OBSERVATION : NEXT_ACTIONS.REQUIRE_NEW_DIAGNOSTIC_INFORMATION,
+          signals: oscillating ? ["OSCILLATING_STRATEGY"] : ["NO_INFORMATION_GAIN", ...progress.signals.map((signal) => signal.code)],
+          errorCodes: oscillating ? ["E_STRATEGY_OSCILLATION", "E_PROGRESS_STALLED"] : ["E_PROGRESS_STALLED"],
+        },
         requiredArtifacts,
       });
     }
@@ -542,6 +1001,34 @@ async function computeNextAction(targetOrOptions = {}, packageRootOption) {
     });
   }
   if (state.phase === "CORRECTING") {
+    const ledgerForCorrection = await validateEventLedger(target, packageRoot, { taskId: normalized.taskId ?? null });
+    const correctionCycle = state.verificationCycle ?? 1;
+    const hasStructuredCase = ledgerForCorrection.events.some(
+      (event) => event.event === "DIAGNOSTIC_CASE_RECORDED"
+        && event.taskId === state.taskId
+        && event.details?.verificationCycle === correctionCycle,
+    );
+    const hasIntervention = ledgerForCorrection.events.some(
+      (event) => event.event === "INTERVENTION_RECORDED"
+        && event.taskId === state.taskId
+        && event.details?.verificationCycle === correctionCycle,
+    );
+    if (hasStructuredCase && !hasIntervention) {
+      return result({
+        ...context,
+        nextAction: NEXT_ACTIONS.ENTER_VERIFYING,
+        reasons: [
+          artifactError("PHASE_CORRECTING", "A structured diagnostic case is awaiting a recorded intervention"),
+        ],
+        diagnosticGuidance: {
+          action: NEXT_ACTIONS.RECORD_INTERVENTION,
+          signals: ["INTERVENTION_NOT_BOUND_TO_HYPOTHESIS"],
+          errorCodes: [],
+          commandSpecs: [recordInterventionCommandSpec(normalized.taskId)],
+        },
+        requiredArtifacts,
+      });
+    }
     return decision(context, NEXT_ACTIONS.ENTER_VERIFYING, artifactError("PHASE_CORRECTING", "Correction is ready for verification"));
   }
   if (state.phase === "REVIEWING") {

package/src/core/phase.js

@@ -3,13 +3,13 @@ import { readContract } from "./contract.js";
 import {
   appendProtocolEvent,
   LIFECYCLE_MILESTONES,
-  validateCompletionRecoveryAuthorization,
   validateEventLedger,
   validateStateLedgerCoherence,
 } from "./events.js";
 import { readPersistedRoute } from "./route-artifact.js";
 import { assertWorkPhase, isValidTransition } from "./protocol.js";
 import { readWorkState, mutateWorkState } from "./work-state.js";
+import { authorizeCompletionRecoveryOrRebind } from "./completion-recovery-rebind.js";
 import { evaluateCompletion } from "./completion.js";
 import { evaluatePreflight } from "./preflight.js";
 import { requiredEvidenceForTarget } from "./completion-artifacts.js";
@@ -21,7 +21,11 @@ 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";
+import { resolveCurrentCycleDiagnostic } from "./diagnostic-projection.js";
+import {
+  buildInformationGainProjection,
+  evaluateStructuredDiagnosticStall,
+} from "./information-gain-projection.js";
 
 function phaseError(code, message, artifacts = []) {
   const error = new Error(message);
@@ -164,10 +168,9 @@ export async function advanceWorkState(target, toPhase, options = {}) {
   } = normalizedOptions;
   assertWorkPhase(toPhase);
 
-  const state = await readWorkState(target, { packageRoot, taskId, statePath });
+  let state = await readWorkState(target, { packageRoot, taskId, statePath });
   const stateRel = statePath ?? (taskId ? taskArtifactPath(taskId, "state") : ARTIFACT_PATHS.state);
   if (!state) throw phaseError("E_PHASE_PREREQUISITE_MISSING", "Cannot advance without work state", [stateRel]);
-
   const eventsRel = eventsPath ?? (taskId ? taskArtifactPath(taskId, "events") : ARTIFACT_PATHS.events);
   const receiptRel = receiptPath ?? (taskId ? taskArtifactPath(taskId, "receipt") : ARTIFACT_PATHS.receipt);
 
@@ -187,7 +190,8 @@ export async function advanceWorkState(target, toPhase, options = {}) {
 
     const nonCompleteTasks = discovered.filter((t) => t.phase !== "COMPLETE");
     if (nonCompleteTasks.length > 1) {
-      const claims = descriptor?.writeClaims ?? [];
+      const currentTask = discovered.find((task) => task.taskId === taskId && task.healthy !== false);
+      const claims = currentTask?.writeClaims ?? [];
       if (claims.length === 0) {
         throw phaseError(
           E_TASK_SCOPE_REQUIRED,
@@ -222,30 +226,33 @@ export async function advanceWorkState(target, toPhase, options = {}) {
   const eventType = PHASE_EVENTS[toPhase];
   const reenteringVerification = toPhase === "VERIFYING" && ["CORRECTING", "REVIEWING"].includes(state.phase);
   if (toPhase === "VERIFYING" && state.phase === "REVIEWING") {
-    let currentReceipt = null;
-    try {
-      const receiptArtifact = await readJsonArtifact(target, receiptRel, "execution-receipt", packageRoot);
-      currentReceipt = receiptArtifact?.value;
-    } catch {
-      // If receipt is not present, pass null
-    }
-    const recoveryAuth = validateCompletionRecoveryAuthorization({
-      state,
-      receipt: currentReceipt,
-      events: ledger.events,
+    const recovery = await authorizeCompletionRecoveryOrRebind({
+      target,
+      packageRoot,
+      taskId,
+      statePath,
+      contractPath,
+      routePath,
+      receiptPath,
+      eventsPath,
+      authorityContext,
+      runtimeContext,
     });
-    if (!recoveryAuth.authorized) {
-      const firstError = recoveryAuth.errors[0] ?? {};
+    if (!recovery.recoveryAuth.authorized) {
+      const firstError = recovery.recoveryAuth.errors[0] ?? {};
       throw phaseError(
         firstError.code ?? "E_COMPLETION_RECOVERY_UNAUTHORIZED",
         firstError.message ?? "REVIEWING -> VERIFYING requires authorized completion recovery",
         [stateRel, eventsRel],
       );
     }
+    if (recovery.rebound) {
+      state = recovery.state;
+    }
   }
   if (toPhase === "CORRECTING" && state.phase === "DIAGNOSING") {
     const cycle = state.verificationCycle ?? 1;
-    const diagEvent = currentCycleDiagnosis(ledger.events, state.taskId, cycle);
+    const diagEvent = resolveCurrentCycleDiagnostic(ledger.events, state.taskId, cycle);
     if (!diagEvent) {
       throw phaseError(
         "E_DIAGNOSIS_REQUIRED",
@@ -253,8 +260,21 @@ export async function advanceWorkState(target, toPhase, options = {}) {
         [eventsRel],
       );
     }
-    const details = diagEvent.details;
-    if (!details || details.informationGain === "NONE") {
+    let stalledNoGain = false;
+    if (diagEvent.sourceModel === "STRUCTURED_DIAGNOSTIC_CASE_V1") {
+      // One canonical structured-stall truth, shared with progress/reflect.
+      const stall = evaluateStructuredDiagnosticStall(
+        buildInformationGainProjection(ledger.events, state.taskId),
+        { verificationCycle: cycle },
+      );
+      stalledNoGain = stall.stalled;
+    }
+    const gainClassification = diagEvent.sourceModel === "STRUCTURED_DIAGNOSTIC_CASE_V1"
+      ? null
+      : diagEvent.details?.informationGain;
+    if (!diagEvent.details
+      || stalledNoGain
+      || (diagEvent.sourceModel !== "STRUCTURED_DIAGNOSTIC_CASE_V1" && gainClassification === "NONE")) {
       throw phaseError(
         "E_DIAGNOSIS_NO_NEW_INFORMATION",
         "The proposed retry repeats the previous hypothesis with the same evidence without new information",
@@ -264,7 +284,7 @@ export async function advanceWorkState(target, toPhase, options = {}) {
   }
   if (toPhase === "VERIFYING" && state.phase === "CORRECTING") {
     const cycle = state.verificationCycle ?? 1;
-    const diagEvent = currentCycleDiagnosis(ledger.events, state.taskId, cycle);
+    const diagEvent = resolveCurrentCycleDiagnostic(ledger.events, state.taskId, cycle);
     if (!diagEvent) {
       throw phaseError(
         "E_DIAGNOSIS_REQUIRED",