@awak-app/simy-cli 0.5.71 → 0.5.73

package/src/orchestrator/evidence.js

@@ -26,7 +26,7 @@ export async function collectPrEvidence({
   const baseRefresh = await command(
     runCommand,
     "git",
-    ["fetch", "--no-tags", "origin", charter.base_branch],
+    ["fetch", "--no-tags", "origin", charter.base_branch.replace(/^(?:refs\/remotes\/)?origin\//, "")],
     repositoryPath,
   );
   const local = await collectLocalGitEvidence({
@@ -42,7 +42,8 @@ export async function collectPrEvidence({
   const latest = await collectLocalGitEvidence({ baseBranch: charter.base_branch, repositoryPath, runCommand });
   latest.base_ref_refreshed = baseRefresh.ok;
   latest.base_ref_error = baseRefresh.ok ? null : baseRefresh.error;
-  if (!latest.available || latest.head_sha !== local.head_sha || !latest.working_tree_clean) {
+  if (!latest.available || latest.head_sha !== local.head_sha || latest.base_sha !== local.base_sha ||
+      latest.base_ref !== local.base_ref || !latest.working_tree_clean) {
     minimumCompletion.status = "evidence_incomplete";
     minimumCompletion.errors = ["Checkout changed while collecting minimum evidence; verify again."];
   }
@@ -90,16 +91,17 @@ function observedEvidenceRef(ref, local, github) {
 }
 
 async function collectLocalGitEvidence({ baseBranch, repositoryPath, runCommand }) {
-  const baseRef = `origin/${baseBranch}`;
-  const [head, branch, headline, status, changed, base, mergeBase, baseAncestor] = await Promise.all([
+  const base = await resolveBaseRef(runCommand, baseBranch, repositoryPath);
+  // Pin all comparisons to the same commit, even if another process moves the ref.
+  const baseCommit = base.ok ? base.stdout : null;
+  const [head, branch, headline, status, changed, mergeBase, baseAncestor] = await Promise.all([
     command(runCommand, "git", ["rev-parse", "HEAD"], repositoryPath),
     command(runCommand, "git", ["branch", "--show-current"], repositoryPath),
     command(runCommand, "git", ["log", "-1", "--pretty=%s"], repositoryPath),
     command(runCommand, "git", ["status", "--porcelain"], repositoryPath),
-    changedFiles(runCommand, baseBranch, repositoryPath),
-    command(runCommand, "git", ["rev-parse", baseRef], repositoryPath),
-    command(runCommand, "git", ["merge-base", baseRef, "HEAD"], repositoryPath),
-    command(runCommand, "git", ["merge-base", "--is-ancestor", baseRef, "HEAD"], repositoryPath),
+    base.ok ? command(runCommand, "git", ["diff", "--name-only", "--diff-filter=ACMR", `${baseCommit}...HEAD`], repositoryPath) : base,
+    base.ok ? command(runCommand, "git", ["merge-base", baseCommit, "HEAD"], repositoryPath) : base,
+    base.ok ? command(runCommand, "git", ["merge-base", "--is-ancestor", baseCommit, "HEAD"], repositoryPath) : base,
   ]);
   const statusLines = lines(status.stdout);
   return {
@@ -110,7 +112,8 @@ async function collectLocalGitEvidence({ baseBranch, repositoryPath, runCommand
     working_tree_clean: status.ok && statusLines.length === 0,
     status_lines: statusLines,
     changed_files: lines(changed.stdout),
-    base_sha: cleanString(base.stdout) || null,
+    base_ref: base.ref || null,
+    base_sha: baseCommit,
     merge_base_sha: cleanString(mergeBase.stdout) || null,
     base_is_ancestor: baseAncestor.ok,
     errors: [head, branch, headline, status, changed, base, mergeBase]
@@ -119,18 +122,16 @@ async function collectLocalGitEvidence({ baseBranch, repositoryPath, runCommand
   };
 }
 
-async function changedFiles(runCommand, baseBranch, repositoryPath) {
-  const refs = [`origin/${baseBranch}`, baseBranch];
+async function resolveBaseRef(runCommand, baseBranch, repositoryPath) {
+  const refs = baseBranch.startsWith("refs/") ? [baseBranch] :
+    baseBranch.startsWith("origin/") ? [`refs/remotes/${baseBranch}`] :
+      [`refs/remotes/origin/${baseBranch}`, `refs/heads/${baseBranch}`];
   for (const ref of refs) {
-    const result = await command(
-      runCommand,
-      "git",
-      ["diff", "--name-only", "--diff-filter=ACMR", `${ref}...HEAD`],
-      repositoryPath,
-    );
-    if (result.ok) return result;
+    const result = await command(runCommand, "git",
+      ["rev-parse", "--verify", "--end-of-options", `${ref}^{commit}`], repositoryPath);
+    if (result.ok) return { ...result, ref };
   }
-  return { ok: false, stdout: "", error: `Could not diff against ${baseBranch}.` };
+  return { ok: false, stdout: "", error: `Could not resolve base branch ${baseBranch}.` };
 }
 
 async function collectGitHubEvidence({ charter, attempt, repositoryPath, runCommand }) {

package/src/orchestrator/independent-audit.js

@@ -108,6 +108,7 @@ export function buildIndependentAuditInstruction(charter, attempt) {
         "Required keys: passed, summary, findings, criterion_results, visual_review, coverage_review.",
         "coverage_review must contain requirements_complete (boolean), unmapped_requirements (array), observation, and user_outcome with passed, verification_method, evidence_refs, and observed_result. Independently exercise or inspect proof of the original user goal even when supplied acceptance criteria mention only tests, code, or a PR. Use passed=false if the goal is not demonstrated. Explain the comparison of the original request, frozen experience, stable criterion-ID list, implementation and raw user/system proof.",
         "Each finding candidate must contain passed, code, severity, target, explanation, and repairability.",
+        "For a failed finding, optionally identify blocker_kind as machine, human, or external. Use human when a specific user decision or credential interaction is required, external for an unavailable outside dependency, and machine when local repair or verification can proceed. One blocked criterion does not imply all remaining work is blocked.",
         "criterion_results must contain one entry per stable criterion ID with criterion_id, passed, verification_method, evidence_refs, and observed_result.",
         "visual_review must contain inspected, artifacts, and acceptance_observations.",
         "Only passed=false entries are findings. Omit passing checks, and never report passed=true evidence as a finding.",
@@ -121,6 +122,10 @@ export function buildIndependentAudit(execution, charter = null, attempt = null)
   const result = execution?.result && typeof execution.result === "object" ? execution.result : {};
   const completionContractV2 =
     charter?.completion_contract?.version === COMPLETION_CONTRACT_VERSION;
+  const objectiveBinding = {
+    objective_digest: charter?.thread_state?.objective_contract?.current_digest || null,
+    objective_version: charter?.thread_state?.objective_contract?.version || null,
+  };
   const valid =
     execution?.exitCode === 0 &&
     !execution?.error &&
@@ -132,6 +137,7 @@ export function buildIndependentAudit(execution, charter = null, attempt = null)
         typeof result.visual_review === "object"));
   if (!valid) {
     return {
+      ...objectiveBinding,
       passed: false,
       summary: cleanString(execution?.error || result.summary) || "Independent audit did not return valid evidence.",
       findings: [
@@ -159,6 +165,8 @@ export function buildIndependentAudit(execution, charter = null, attempt = null)
       target: cleanString(item.target) || "pull_request",
       explanation: cleanString(item.explanation) || "Independent audit finding.",
       repairability: item.repairability === "manual" ? "manual" : "auto",
+      blocker_kind: ["machine", "human", "external"].includes(item.blocker_kind)
+        ? item.blocker_kind : item.repairability === "manual" ? "human" : "machine",
       auto_fix_hint: cleanString(item.auto_fix_hint) || null,
     }));
   const findings = evaluations.filter((item) => item.passed === false);
@@ -243,6 +251,7 @@ export function buildIndependentAudit(execution, charter = null, attempt = null)
   }
   const requiresHuman = findings.some((item) => item.repairability === "manual");
   return {
+    ...objectiveBinding,
     passed: result.passed === true && findings.length === 0,
     summary: cleanString(result.summary) || "Independent audit completed.",
     findings,

package/src/orchestrator/instruction.js

@@ -39,9 +39,14 @@ export function buildCodingInstruction(
         `Risk level: ${charter.risk.level}`,
         `Design summary: ${charter.design_review.summary || "not required"}`,
         `Design approved by: ${charter.design_review.approved_by || "not required"}`,
-        `Attempt: ${attemptNumber}/${charter.max_attempts}`,
+        `Attempt: ${attemptNumber}/${budget?.hard_attempt_ceiling ?? charter.max_attempts}`,
         `Retry budget: ${Math.max(attemptNumber - 1, 0)}/${charter.retry_budget}`,
         `Token budget remaining: ${budget?.tokens_remaining ?? charter.token_budget}/${charter.token_budget}`,
+        ...(charter.continuation_policy === "progress" ? [
+          "Continuation policy: verified acceptance progress. Token/retry thresholds notify; they do not relax acceptance or authorize new work.",
+          `Hard Provider token ceiling: ${budget?.hard_token_ceiling}; remaining: ${budget?.hard_tokens_remaining}. Hard attempt ceiling: ${budget?.hard_attempt_ceiling}.`,
+          "Report human/external blockers as soon as observed; continue independent work within the approved objective. Changed metadata alone is not progress.",
+        ] : []),
         `Local evidence root: ${charter.ui_evidence_root || "not required"}`,
       ].join("\n"),
     ),

package/src/orchestrator/loop.js

@@ -1,3 +1,4 @@
+import { validateCharter } from "./charter-validation.js";
 import { redactExecutionText } from "./execution-io.js";
 import { minimumCharter } from "./delivery/scripts/check-minimum-completion.mjs";
 import { auditAttempt, evaluatePrReadiness } from "./audit.js";
@@ -6,7 +7,7 @@ import {
   buildIndependentAuditInstruction,
 } from "./independent-audit.js";
 import { buildCodingInstruction, buildPromptInterventions } from "./instruction.js";
-import { canStartProvider, refreshBudgetState } from "./budget.js";
+import { canStartProvider, codingAttemptCeiling, refreshBudgetState } from "./budget.js";
 import { buildAttempt, mergeTokenUsage } from "./result.js";
 import { evaluateRetryCircuit } from "./retry.js";
 import { assessOutcomeProgress, verifyObjective } from "./outcome-monitor.js";
@@ -76,7 +77,8 @@ async function runCodingLoopOwned({
 
   let previousFindings = resume ? snapshot.final_audit?.findings || [] : [];
   const firstAttempt = resume ? snapshot.attempts.length + 1 : 1;
-  const lastAttempt = resume ? firstAttempt : snapshot.charter.max_attempts;
+  const progressPolicy = snapshot.charter.continuation_policy === "progress";
+  const lastAttempt = progressPolicy ? codingAttemptCeiling(snapshot) : resume ? firstAttempt : snapshot.charter.max_attempts;
   for (
     let attemptNumber = firstAttempt;
     attemptNumber <= lastAttempt;
@@ -183,8 +185,9 @@ async function runCodingLoopOwned({
     if (shouldStop()) return stopCodingLoop(snapshot, onUpdate);
     attempt.implementation_gate = attempt.audit.implementation_gate;
     snapshot.attempts.push(attempt);
-    assessOutcomeProgress(snapshot.charter, attempt, previousAttempt);
+    assessOutcomeProgress(snapshot.charter, attempt, previousAttempt, { ...outcomeOptions(snapshot), resetUnavailableCount: resume && attemptNumber === firstAttempt });
     attempt.budget = refreshBudgetState(snapshot);
+    recordBudgetWarnings(snapshot, attempt);
 
     if (snapshot.budget.token_exhausted) {
       await stopForBudget({
@@ -234,6 +237,8 @@ async function runCodingLoopOwned({
     const auditInstruction = buildIndependentAuditInstruction(snapshot.charter, attempt);
     const reviewedMatrix = attempt.observed_evidence?.minimum_completion?.matrix_sha256;
     const reviewedEvidenceIdentity = independentAuditEvidenceIdentity(attempt);
+    const reviewedObjectiveDigest = snapshot.charter.thread_state?.objective_contract?.current_digest;
+    const reviewedObjectiveVersion = snapshot.charter.thread_state?.objective_contract?.version;
     const auditExecution = await safeExecution(() =>
       executeIndependentAudit({
         attemptNumber,
@@ -251,9 +256,16 @@ async function runCodingLoopOwned({
     );
     attempt.token_usage = mergeTokenUsage(attempt.token_usage, auditExecution.tokenUsage);
     attempt.budget = refreshBudgetState(snapshot);
+    recordBudgetWarnings(snapshot, attempt);
+    if (attempt.budget.token_exhausted) {
+      await stopForBudget({ snapshot, attempt, reason: "token_budget_exhausted", onUpdate });
+      return snapshot;
+    }
 
     attempt.independent_audit.minimum_matrix_sha256 = reviewedMatrix;
     attempt.independent_audit.evidence_identity_sha256 = reviewedEvidenceIdentity;
+    attempt.independent_audit.objective_digest = reviewedObjectiveDigest;
+    attempt.independent_audit.objective_version = reviewedObjectiveVersion;
 
     // Re-collect after the read-only auditor to catch any mutated HEAD or working tree.
     attempt.observed_evidence = await safeEvidence(collectEvidence, attempt);
@@ -265,7 +277,7 @@ async function runCodingLoopOwned({
     });
     if (shouldStop()) return stopCodingLoop(snapshot, onUpdate);
     attempt.implementation_gate = attempt.audit.implementation_gate;
-    assessOutcomeProgress(snapshot.charter, attempt, previousAttempt);
+    assessOutcomeProgress(snapshot.charter, attempt, previousAttempt, { ...outcomeOptions(snapshot), resetUnavailableCount: resume && attemptNumber === firstAttempt });
 
     const independentFindings = attempt.independent_audit.findings || [];
     if (!attempt.audit.passed || !attempt.independent_audit.passed) {
@@ -308,6 +320,10 @@ async function runCodingLoopOwned({
   return snapshot;
 }
 
+function outcomeOptions(snapshot) {
+  return { policy: snapshot.charter.continuation_policy || "bounded", maxNoProgressAttempts: snapshot.charter.max_no_progress_attempts || 3 };
+}
+
 async function stopCodingLoop(snapshot, onUpdate) {
   if (snapshot.state === "stopped") return snapshot;
   appendEvent(snapshot, "stopped", "Agentic loop stopped by the local human operator.", {
@@ -354,6 +370,7 @@ async function recheckPrReadinessOwned({ snapshot, collectEvidence, checkSqm = n
   });
   attempt.outcome_progress = assessOutcomeProgress(
     snapshot.charter, attempt, snapshot.attempts.at(-2) ?? null,
+    outcomeOptions(snapshot),
   );
   snapshot.implementation_gate_passed = attempt.audit.passed;
   attempt.pr_readiness = evaluatePrReadiness(snapshot.charter, attempt);
@@ -372,38 +389,6 @@ async function recheckPrReadinessOwned({ snapshot, collectEvidence, checkSqm = n
   return snapshot;
 }
 
-function validateCharter(charter) {
-  const findings = [];
-  if (charter.risk.requires_design_review && charter.acceptance_criteria_source !== "explicit") {
-    findings.push({
-      code: "EXPLICIT_ACCEPTANCE_CRITERIA_REQUIRED",
-      severity: "blocker",
-      target: "acceptance_criteria",
-      explanation: "High-risk work requires explicit acceptance criteria.",
-      repairability: "manual",
-    });
-  }
-  if (charter.design_review.required && charter.design_review.status !== "approved") {
-    findings.push({
-      code: "DESIGN_REVIEW_REQUIRED",
-      severity: "blocker",
-      target: "design_review",
-      explanation:
-        "High-risk work requires a design summary, approval owner, and review evidence before implementation.",
-      repairability: "manual",
-    });
-  }
-  if (charter.risk.requires_design_review && charter.required_checks.length === 0) {
-    findings.push({
-      code: "REQUIRED_CI_CHECKS_MISSING",
-      severity: "blocker",
-      target: "required_checks",
-      explanation: "High-risk work requires explicit CI and security check names.",
-      repairability: "manual",
-    });
-  }
-  return findings;
-}
 
 async function safeExecution(callback) {
   try {
@@ -515,7 +500,7 @@ async function handleFailedAudit({
     previousAttempt: snapshot.attempts.at(-2) ?? null,
     findings,
   });
-  if (retryCircuit.open) {
+  if (retryCircuit.open && !attempt.outcome_progress?.has_progress) {
     const avoidedAttempts = Math.max(snapshot.charter.max_attempts - attemptNumber, 0);
     const circuitState = {
       state: "open",
@@ -546,7 +531,7 @@ async function handleFailedAudit({
     await publish(snapshot, "blocked", onUpdate);
     return true;
   }
-  if (attemptNumber >= snapshot.charter.max_attempts) {
+  if (attemptNumber >= codingAttemptCeiling(snapshot)) {
     await stopForBudget({
       snapshot,
       attempt,
@@ -555,6 +540,34 @@ async function handleFailedAudit({
     });
     return true;
   }
+  if (attempt.outcome_progress?.assessment_unavailable) {
+    const progress = attempt.outcome_progress;
+    snapshot.final_audit = {
+      ...(snapshot.final_audit || {}),
+      passed: false,
+      summary: "Outcome progress could not be assessed across consecutive attempts.",
+      findings: [...(snapshot.final_audit?.findings || []), {
+        passed: false,
+        code: "OUTCOME_ASSESSMENT_UNAVAILABLE",
+        severity: "blocker",
+        target: "outcome_monitor",
+        explanation: "Two consecutive attempts could not establish an independent outcome assessment. Resolve the recorded verification failures and continue this run; this does not prove the work has stalled.",
+        repairability: "manual",
+      }],
+      auto_repairable: false,
+      requires_human: true,
+    };
+    appendEvent(snapshot, "waiting_human", "Outcome assessment needs recovery before further automatic work.", {
+      code: "outcome_assessment_unavailable",
+      finding_codes: ["OUTCOME_ASSESSMENT_UNAVAILABLE"],
+      attempt_number: attemptNumber,
+      consecutive_unassessed_attempts: progress.consecutive_unassessed_attempts,
+      unavailable_reason: progress.unavailable_reason,
+      unproven_ids: progress.unproven_ids,
+    });
+    await publish(snapshot, "waiting_human", onUpdate);
+    return true;
+  }
   if (requiresHuman) {
     appendEvent(snapshot, "waiting_human", "PR audit requires human input.", {
       finding_codes: findings.map((finding) => finding.code),
@@ -562,7 +575,7 @@ async function handleFailedAudit({
     await publish(snapshot, "waiting_human", onUpdate);
     return true;
   }
-  if (attemptNumber < snapshot.charter.max_attempts) {
+  if (attemptNumber < codingAttemptCeiling(snapshot)) {
     appendEvent(snapshot, "re_instructing", "PR audit produced a repair instruction.", {
       attempt_number: attemptNumber,
       finding_codes: findings.map((finding) => finding.code),
@@ -573,6 +586,18 @@ async function handleFailedAudit({
   return false;
 }
 
+function recordBudgetWarnings(snapshot, attempt) {
+  if (snapshot.charter.continuation_policy !== "progress") return;
+  snapshot.budget_notifications ??= {};
+  for (const kind of ["token", "retry"]) {
+    if (!snapshot.budget[`${kind}_warning`] || snapshot.budget_notifications[kind]) continue;
+    snapshot.budget_notifications[kind] = { attempt_number: attempt.attempt_number, at: new Date().toISOString() };
+    appendEvent(snapshot, "budget_warning", "The continuation notification threshold was reached; acceptance progress and hard ceilings still govern further work.", {
+      kind, attempt_number: attempt.attempt_number, budget: snapshot.budget,
+    });
+  }
+}
+
 async function stopForBudget({ snapshot, attempt, reason, onUpdate }) {
   const budget = refreshBudgetState(snapshot);
   const finding = budgetFinding(reason, budget);
@@ -611,7 +636,7 @@ function budgetFinding(reason, budget) {
       code: "TOKEN_BUDGET_EXHAUSTED",
       severity: "blocker",
       target: "provider_token_budget",
-      explanation: `The run used ${budget.tokens_used} of ${budget.token_budget} Provider tokens, so no additional executor or reviewer call can start until the Provider token budget is increased. Provider tokens are not billed as SIMY tokens.`,
+      explanation: `The run used ${budget.tokens_used} of ${budget.hard_token_ceiling} Provider tokens. The ${budget.continuation_policy === "progress" ? "hard safety ceiling" : "budget"} prevents another provider call. Preserve this run and review its remaining acceptance conditions before resuming. Provider tokens are not billed as SIMY tokens.`,
       repairability: "manual",
       auto_fix_hint: null,
     };
@@ -621,7 +646,7 @@ function budgetFinding(reason, budget) {
     code: "RETRY_BUDGET_EXHAUSTED",
     severity: "blocker",
     target: "retry_budget",
-    explanation: `The run used ${budget.retries_used} of ${budget.retry_budget} automatic retries.`,
+    explanation: budget.continuation_policy === "progress" ? `The run reached its hard ceiling of ${budget.hard_attempt_ceiling} attempts. Preserve the checkpoint and review remaining acceptance conditions before resuming.` : `The run used ${budget.retries_used} of ${budget.retry_budget} automatic retries.`,
     repairability: "manual",
     auto_fix_hint: null,
   };

package/src/orchestrator/outcome-monitor.js

@@ -1,6 +1,8 @@
 import { createHash } from "node:crypto";
 
-import { acceptanceCriterionRows, hasUserOutcomeProof } from "./completion-contract.js";
+import { acceptanceCriterionRows } from "./completion-contract.js";
+import { evaluateOutcomeProgress } from "./outcome-progress.js";
+import { independentAuditEvidenceIdentity } from "./pr-preparation.js";
 
 function objective(charter) {
   return {
@@ -17,17 +19,31 @@ function objective(charter) {
   };
 }
 
-function digest(value) {
-  return createHash("sha256").update(JSON.stringify(value)).digest("hex");
+const CANONICAL_DIGEST = "sha256-canonical-json-v1";
+
+function canonicalValue(value) {
+  if (Array.isArray(value)) return value.map(canonicalValue);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonicalValue(value[key])]));
+  }
+  return value;
 }
 
+export function objectiveValueDigest(value, algorithm) {
+  return createHash("sha256").update(JSON.stringify(
+    algorithm === CANONICAL_DIGEST ? canonicalValue(value) : value,
+  )).digest("hex");
+}
+const digest = objectiveValueDigest;
+
 export function freezeObjective(charter) {
   const value = objective(charter);
   charter.thread_state.objective_contract = {
     version: 1,
+    digest_algorithm: CANONICAL_DIGEST,
     baseline: structuredClone(value),
     current: structuredClone(value),
-    current_digest: digest(value),
+    current_digest: digest(value, CANONICAL_DIGEST),
     revisions: [],
   };
 }
@@ -36,7 +52,7 @@ export function reviseObjective(charter, source) {
   const contract = charter.thread_state.objective_contract;
   if (!contract) return;
   const next = objective(charter);
-  const nextDigest = digest(next);
+  const nextDigest = digest(next, contract.digest_algorithm);
   if (nextDigest === contract.current_digest) return;
   contract.revisions.push({
     version: contract.version + 1,
@@ -55,6 +71,10 @@ export function verifyObjective(charter) {
   const contract = charter.thread_state?.objective_contract;
   if (!contract) return { valid: true, legacy: true };
   try {
+    if (contract.digest_algorithm && contract.digest_algorithm !== CANONICAL_DIGEST) {
+      return { valid: false, legacy: false, digest: null };
+    }
+    const contractDigest = (value) => digest(value, contract.digest_algorithm);
     const current = objective(charter);
     const revisions = contract.revisions;
     const valid = Boolean(
@@ -62,15 +82,15 @@ export function verifyObjective(charter) {
       contract.baseline &&
       Array.isArray(revisions) &&
       revisions.length === contract.version - 1 &&
-      digest(contract.current) === contract.current_digest &&
-      digest(current) === contract.current_digest &&
+      contractDigest(contract.current) === contract.current_digest &&
+      contractDigest(current) === contract.current_digest &&
       revisions.every((revision, index) =>
         revision.version === index + 2 &&
-        revision.previous_digest === digest(revision.previous) &&
-        revision.next_digest === digest(revision.next) &&
-        (index === 0 ? revision.previous_digest === digest(contract.baseline) :
+        revision.previous_digest === contractDigest(revision.previous) &&
+        revision.next_digest === contractDigest(revision.next) &&
+        (index === 0 ? revision.previous_digest === contractDigest(contract.baseline) :
           revision.previous_digest === revisions[index - 1].next_digest)) &&
-      (revisions.length === 0 ? digest(contract.baseline) === contract.current_digest :
+      (revisions.length === 0 ? contractDigest(contract.baseline) === contract.current_digest :
         revisions.at(-1).next_digest === contract.current_digest)
     );
     return { valid, legacy: false, digest: contract.current_digest };
@@ -81,43 +101,74 @@ export function verifyObjective(charter) {
 
 // The monitor reads independent criterion assessments, not executor test counts.
 // It records insufficient evidence when the independent review was not reached.
-export function assessOutcomeProgress(charter, attempt, previousAttempt = null) {
-  const criteria = acceptanceCriterionRows(charter);
+export function assessOutcomeProgress(charter, attempt, previousAttempt = null, options = {}) {
   const assessment = attempt.independent_audit;
-  const results = Array.isArray(assessment?.criterion_results)
-    ? assessment.criterion_results : [];
-  const completeAssessment = Boolean(attempt.audit?.passed === true && assessment &&
-    criteria.every((criterion) => results.filter((row) => row.criterion_id === criterion.id).length === 1) &&
-    results.length === criteria.length &&
-    !(assessment.findings || []).some((finding) => finding.code === "INDEPENDENT_AUDIT_UNAVAILABLE"));
-  const reviewed = new Set();
-  for (const criterion of criteria) {
-    const matches = results.filter((row) => row.criterion_id === criterion.id);
-    const row = matches[0];
-    if (matches.length === 1 && row.passed === true && row.verification_method &&
-        row.observed_result && Array.isArray(row.evidence_refs) && row.evidence_refs.length > 0) {
-      reviewed.add(criterion.id);
-    }
+  const objectiveState = verifyObjective(charter);
+  const contract = charter.thread_state?.objective_contract;
+  const objectiveDigest = contract?.current_digest || null;
+  const boundObjective = assessment?.objective_digest || attempt.outcome_progress?.objective_digest;
+  let assessmentReason = null;
+  if (!objectiveState.valid) assessmentReason = "objective_contract_invalid";
+  else if (boundObjective && boundObjective !== objectiveDigest ||
+      assessment?.objective_version != null && assessment.objective_version !== contract?.version) {
+    assessmentReason = "independent_objective_stale";
+  } else if (assessment?.objective_digest && !assessment.evidence_identity_sha256) {
+    assessmentReason = "independent_candidate_unbound";
+  } else if (assessment?.evidence_identity_sha256 &&
+      assessment.evidence_identity_sha256 !== independentAuditEvidenceIdentity(attempt)) {
+    assessmentReason = "independent_candidate_stale";
+  } else if (!assessment || (assessment.findings || []).some((finding) =>
+    finding.code === "INDEPENDENT_AUDIT_UNAVAILABLE")) {
+    assessmentReason = "independent_assessment_unavailable";
   }
-  if (hasUserOutcomeProof(assessment?.coverage_review)) {
-    reviewed.add("USER-GOAL");
+  const result = evaluateOutcomeProgress({
+    criteria: acceptanceCriterionRows(charter),
+    objectiveDigest,
+    objectiveVersion: contract?.version || null,
+    criterionResults: assessment?.criterion_results,
+    userOutcome: assessment?.coverage_review?.user_outcome,
+    assessmentAvailable: assessmentReason === null,
+    assessmentReason,
+    findings: [...(attempt.audit?.findings || []), ...(assessment?.findings || [])],
+    previous: previousAttempt?.outcome_progress || null,
+    maxNoProgressAttempts: options.maxNoProgressAttempts ?? 3,
+  });
+  // Existing runs keep their original stopping policy until the controller opts
+  // into progress continuation. The richer measurement is persisted in both.
+  if (options.policy !== "progress") {
+    const criteria = acceptanceCriterionRows(charter);
+    const rows = Array.isArray(assessment?.criterion_results) ? assessment.criterion_results : [];
+    const completeAssessment = assessmentReason === null && attempt.audit?.passed === true &&
+      rows.length === criteria.length && criteria.every((criterion) =>
+        rows.filter((row) => row.criterion_id === criterion.id).length === 1);
+    const previous = previousAttempt?.outcome_progress;
+    result.status = completeAssessment ? "assessed" : "insufficient_evidence";
+    result.stalled = Boolean(completeAssessment && previous?.status === "assessed" &&
+      previous.objective_digest === result.objective_digest && result.unproven_ids.length > 0 &&
+      result.assessed_ids.every((id) => previous.assessed_ids.includes(id)) &&
+      result.unproven_ids.every((id) => previous.unproven_ids.includes(id)));
+    result.stall_reason = result.stalled ? "no_new_verified_outcome" : null;
+    result.next_actions = result.next_actions.filter((action) => action !== "reassess_approach");
+    if (result.stalled) result.next_actions.push("reassess_approach");
+    result.next_action = result.stalled ? "reassess_approach" : result.next_actions[0] || "repair_or_verify";
   }
-  const result = {
-    objective_digest: charter.thread_state?.objective_contract?.current_digest || null,
-    status: completeAssessment ? "assessed" : "insufficient_evidence",
-    assessed_ids: [...reviewed].sort(),
-    unproven_ids: ["USER-GOAL", ...criteria.map((row) => row.id)].filter((id) => !reviewed.has(id)),
-    evidence_identity: assessment?.evidence_identity_sha256 || null,
-    stalled: false,
-  };
+  result.evidence_identity = assessment?.evidence_identity_sha256 || null;
+  const completeAssessment = result.status === "assessed";
   const previous = previousAttempt?.outcome_progress;
-  result.stalled = Boolean(
-    completeAssessment && previous?.status === "assessed" &&
-    previous.objective_digest === result.objective_digest &&
-    result.unproven_ids.length > 0 &&
-    result.assessed_ids.every((id) => previous.assessed_ids.includes(id)) &&
-    result.unproven_ids.every((id) => previous.unproven_ids.includes(id))
-  );
+  const sameObjective = previous?.objective_digest === result.objective_digest;
+  const previousUnavailableCount = !options.resetUnavailableCount && sameObjective && previous?.status === "insufficient_evidence"
+    ? previous.consecutive_unassessed_attempts || 1 : 0;
+  result.consecutive_unassessed_attempts = completeAssessment ? 0 : previousUnavailableCount + 1;
+  result.unavailable_reason = completeAssessment ? null : attempt.audit?.passed !== true
+    ? "local_verification_incomplete" : "independent_assessment_incomplete";
+  const previousMissingAssessments = !options.resetUnavailableCount && sameObjective &&
+    previous?.unavailable_reason === "independent_assessment_incomplete"
+    ? previous.consecutive_unavailable_assessments || 1 : 0;
+  result.consecutive_unavailable_assessments = result.unavailable_reason === "independent_assessment_incomplete"
+    ? previousMissingAssessments + 1 : 0;
+  // Local repair can improve without reaching independent review. Only a repeatedly
+  // missing independent assessment after local readiness opens this recovery gate.
+  result.assessment_unavailable = options.policy !== "progress" && result.consecutive_unavailable_assessments >= 2;
   attempt.outcome_progress = result;
   return result;
 }

package/src/orchestrator/outcome-progress.js

@@ -0,0 +1,2 @@
+// The installed provider plugins use the same dependency-free implementation.
+export { evaluateOutcomeProgress } from "../codex-plugins/simy/hooks/outcome-progress.mjs";

package/src/orchestrator/recovery.js

@@ -114,6 +114,7 @@ function recoveryReasonCode(state, message, detail) {
   if (code === "retry_circuit_open" || detail.reason === "identical_commit_and_findings") {
     return "retry_strategy_unchanged";
   }
+  if (code === "outcome_assessment_unavailable") return "outcome_assessment_unavailable";
   if (code === "token_budget_exhausted") return "token_budget_exhausted";
   if (code === "retry_budget_exhausted") return "retry_budget_exhausted";
   const findings = strings(detail.finding_codes);
@@ -148,6 +149,8 @@ function recoveryMessage(reasonCode) {
     requirements_incomplete:
       "SIMY needs the missing requirement or approval before implementation can start.",
     human_input_required: "SIMY needs your decision or clarification before it can continue.",
+    outcome_assessment_unavailable:
+      "SIMY could not assess outcome progress across consecutive attempts. Repair the recorded verification failure and continue this run.",
     token_budget_exhausted:
       "This run reached its Provider token safety limit. Provider tokens are not billed by SIMY. Increase the limit to continue this run.",
     retry_budget_exhausted: