@awak-app/simy-cli 0.7.15 → 0.7.17

package/src/orchestrator/audit.js

@@ -1,24 +1,6 @@
-import { minimumCompletionCheck } from "./minimum-completion.js";
-import { open, readdir, stat } from "node:fs/promises";
-import path from "node:path";
-
-import {
-  bullets,
-  evidenceKind,
-  hasAllowedPrefix,
-  stringArray,
-} from "./shared.js";
-import { evaluateRetryProblemSolving } from "./problem-solving.js";
-import {
-  evaluatePrPreparation,
-  independentAuditEvidenceIdentity,
-  skippedChecksDisclosure,
-} from "./pr-preparation.js";
-import {
-  completionEvidenceChecks,
-  hasUserOutcomeProof,
-  normalizeVisualReview,
-} from "./completion-contract.js";
+import { bullets } from "./shared.js";
+import { independentAuditEvidenceIdentity } from "./pr-preparation.js";
+import { completionEvidenceChecks } from "./completion-contract.js";
 
 export async function auditAttempt(charter, attempt, { previousAttempt = null, sqm = null } = {}) {
   const checks = [];
@@ -97,127 +79,18 @@ export async function auditAttempt(charter, attempt, { previousAttempt = null, s
   addCheck(
     "tests_recorded_and_passing",
     "Expected tests are recorded as passing",
-    attempt.tests_run.length > 0 &&
-      attempt.tests_passed === true &&
+    (charter.expected_tests.length === 0 && attempt.tests_run.length === 0 || attempt.tests_passed === true) &&
       missingExpectedTests.length === 0,
     missingExpectedTests.length > 0
       ? `Missing expected tests: ${missingExpectedTests.join(", ")}`
       : attempt.tests_run.join(", ") || "No passing test command recorded.",
   );
-  addCheck(
-    "commit_headline_prefix",
-    "Observed commit headline uses an allowed prefix",
-    hasAllowedPrefix(local.commit_headline),
-    local.commit_headline || "Local commit headline missing.",
-  );
-  const changedFiles = stringArray(local.changed_files);
-  const reportedFiles = stringArray(attempt.raw_output.changed_files);
-  addCheck(
-    "changed_files_match_git",
-    "Reported changed files match the local diff",
-    local.available === true && sameStrings(changedFiles, reportedFiles),
-    `Reported: ${reportedFiles.join(", ") || "none"}; local: ${changedFiles.join(", ") || "none"}.`,
-  );
-  const unintendedArtifacts = changedFiles.filter((file) =>
-    /(^|\/)(\.evidence|evidence|screenshots?|videos?)(\/|$)|\.(png|jpe?g|webp|gif|mp4|mov|webm)$/i.test(
-      file,
-    ),
-  );
-  addCheck(
-    "no_unintended_artifacts",
-    "No local evidence artifacts committed",
-    unintendedArtifacts.length === 0,
-    unintendedArtifacts.length > 0
-      ? `Unexpected artifacts: ${unintendedArtifacts.join(", ")}`
-      : "No committed local evidence artifacts reported.",
-  );
-
-  const retryProblemSolving = evaluateRetryProblemSolving(attempt, previousAttempt);
-  for (const check of retryProblemSolving.checks) {
-    addCheck(check.id, check.label, check.passed, check.detail, check.severity);
-  }
-  attempt.retry_problem_solving = retryProblemSolving;
-
-  const prPreparation = evaluatePrPreparation(charter, attempt);
-  for (const preparationCheck of prPreparation.checks) {
-    addCheck(
-      `pr_preparation_${preparationCheck.id}`,
-      preparationCheck.label,
-      preparationCheck.passed,
-      preparationCheck.detail,
-    );
-  }
-  attempt.pr_preparation_gate = prPreparation;
-
-  for (const check of [...completionEvidenceChecks(charter, attempt), minimumCompletionCheck(charter, attempt)]) {
-    addCheck(
-      check.id,
-      check.label,
-      check.passed,
-      check.detail,
-      "blocker",
-      "auto",
-      check.evidence_refs,
-    );
-  }
-
-  if (attempt.independent_audit) {
-    addCheck("minimum_review_current", "Independent review covers the current evidence",
-      Boolean(attempt.independent_audit.evidence_identity_sha256 &&
-        attempt.independent_audit.evidence_identity_sha256 === independentAuditEvidenceIdentity(attempt)),
-      "Changed head, base, CI, skip disclosure, PR preparation, companion revision, or minimum evidence requires a fresh independent review.");
-  }
-
-  const evidenceRequired = charter.expected_evidence.includes("ui_evidence_path");
-  const evidenceArtifact = await inspectEvidence(charter, attempt.ui_evidence_path);
-  if (evidenceRequired || attempt.ui_evidence_path) {
-    addCheck(
-      "evidence_exists_local_only",
-      "Local evidence exists under the required root",
-      Boolean(
-        evidenceArtifact?.exists &&
-          evidenceArtifact.under_required_root &&
-          evidenceArtifact.size_bytes > 0,
-      ),
-      evidenceArtifact?.summary || "Local evidence path missing.",
-    );
-  }
-  if (charter.evidence_policy?.browser_required) {
-    addCheck(
-      "browser_visual_evidence_present",
-      "Browser screenshot or video evidence is present",
-      Boolean(evidenceArtifact?.visual_file_count > 0),
-      evidenceArtifact?.visual_file_count > 0
-        ? `${evidenceArtifact.visual_file_count} screenshot or video artifact(s) found.`
-        : "UI and browser-extension work requires a real screenshot or video; a path, text file, or empty directory is not sufficient.",
-    );
-    const visualReview = normalizeVisualReview(attempt.visual_review);
-    const visualArtifactReview = await inspectVisualReviewArtifacts(charter, visualReview);
-    addCheck(
-      "visual_content_inspected",
-      "Visual evidence content was inspected against acceptance criteria",
-      Boolean(
-        visualReview.inspected &&
-          visualReview.artifacts.length > 0 &&
-          visualReview.acceptance_observations.length > 0,
-      ),
-      visualReview.inspected && visualReview.acceptance_observations.length > 0
-        ? visualReview.acceptance_observations.join("; ")
-        : "UI evidence must be opened and inspected; record the artifact paths and concrete acceptance observations.",
-      "blocker",
-      "auto",
-      visualReview.artifacts,
-    );
-    addCheck(
-      "visual_review_artifacts_verified",
-      "Claimed visual-review artifacts are real local media",
-      visualArtifactReview.valid,
-      visualArtifactReview.summary,
-      "blocker",
-      "auto",
-      visualArtifactReview.verified,
-    );
+  // Completion depends on the requested behavior, not preparation matrices,
+  // uncertainty forms, screenshots in a prescribed folder or audit receipts.
+  for (const check of completionEvidenceChecks(charter, attempt)) {
+    addCheck(check.id, check.label, check.passed, check.detail);
   }
+  const evidenceArtifact = null;
 
   const findings = checks
     .filter((check) => !check.passed && check.severity !== "advisory")
@@ -234,7 +107,7 @@ export async function auditAttempt(charter, attempt, { previousAttempt = null, s
       auto_fix_hint:
         check.id === "executor_succeeded" && attempt.raw_output.blocked
           ? null
-          : `Repair ${check.label.toLowerCase()} and report fresh evidence.`,
+          : `Resolve ${check.label.toLowerCase()} and check the result.`,
     }));
   const passed = findings.length === 0;
   const requiresHuman = findings.some((finding) => finding.repairability === "manual");
@@ -250,17 +123,16 @@ export async function auditAttempt(charter, attempt, { previousAttempt = null, s
   return {
     passed,
     summary: passed
-      ? "Implementation is ready for independent audit."
-      : "Implementation did not satisfy local evidence gates.",
+      ? "Requested behavior and relevant tests passed."
+      : "Requested behavior or relevant checks remain incomplete.",
     evaluations: [
       {
         kind: "intent_fit",
         passed,
-        score:
-          checks.length === 0 ? 1 : checks.filter((check) => check.passed).length / checks.length,
+        score: null,
         summary: passed
-          ? "Structured evidence matches the charter."
-          : "Structured evidence is incomplete.",
+          ? "Requested behavior checks passed."
+          : "Requested behavior checks remain incomplete.",
         findings,
         evidence_refs: [attempt.pr_url, attempt.commit_sha, attempt.ui_evidence_path].filter(
           Boolean,
@@ -330,26 +202,12 @@ export function evaluatePrReadiness(charter, attempt) {
   const github = attempt.observed_evidence?.github || {};
   const local = attempt.observed_evidence?.local || {};
   const independentAudit = attempt.independent_audit;
-  const minimum = minimumCompletionCheck(charter, attempt);
-  const preparation = evaluatePrPreparation(charter, attempt);
-  const skippedDisclosure = skippedChecksDisclosure(
-    github.checks,
-    attempt.skipped_checks,
-  );
   const checks = [
-    readinessCheck(minimum.id, minimum.passed, minimum.detail),
-    readinessCheck("minimum_independent_binding",
-      Boolean(independentAudit?.evidence_identity_sha256 && independentAudit.evidence_identity_sha256 === independentAuditEvidenceIdentity(attempt)),
-      "Independent review must cover the current head, base, CI, skips, preparation rows, companion revisions, and minimum evidence."),
-    readinessCheck("user_outcome_proven", hasUserOutcomeProof(independentAudit?.coverage_review),
-      "Independent review must observe the original user outcome and cite its evidence."),
-    readinessCheck("implementation_gate", attempt.audit?.passed === true, "Implementation gate must pass."),
-    readinessCheck("pr_preparation_gate", preparation.passed, preparation.detail),
-    readinessCheck(
-      "independent_ai_audit",
-      independentAudit?.passed === true,
-      independentAudit?.summary || "Independent AI audit has not passed.",
-    ),
+    readinessCheck("implementation_gate", attempt.audit?.passed === true, "Requested behavior and relevant tests must pass."),
+    ...(charter.independent_review_required === true ? [
+      readinessCheck("requested_review", independentAudit?.passed === true && independentAudit.evidence_identity_sha256 === independentAuditEvidenceIdentity(attempt),
+        "The explicitly requested review has not passed."),
+    ] : []),
     readinessCheck(
       "github_evidence",
       github.available === true,
@@ -361,11 +219,7 @@ export function evaluatePrReadiness(charter, attempt) {
       `Reported ${attempt.pr_url || "missing"}; GitHub reports ${github.url || "missing"}.`,
     ),
     readinessCheck("pr_not_draft", github.available && github.is_draft === false, "PR is still draft."),
-    readinessCheck(
-      "pr_title_prefix",
-      hasAllowedPrefix(github.title),
-      github.title || "GitHub PR title is missing.",
-    ),
+
     readinessCheck(
       "pr_repository_matches",
       normalizeRepository(github.repository) === normalizeRepository(charter.repository),
@@ -408,11 +262,7 @@ export function evaluatePrReadiness(charter, attempt) {
     ),
     readinessCheck("status_checks_present", github.checks_present === true, "No PR status checks found."),
     readinessCheck("status_checks_passing", github.checks_passing === true, "PR checks are pending or failing."),
-    readinessCheck(
-      "skipped_checks_disclosed",
-      skippedDisclosure.passed,
-      skippedDisclosure.detail,
-    ),
+
     readinessCheck(
       "required_checks_present",
       github.required_checks_present === true,
@@ -429,8 +279,8 @@ export function evaluatePrReadiness(charter, attempt) {
     ready,
     state: ready ? "merge_ready" : "pr_ready_for_review",
     summary: ready
-      ? "PR has independently verified evidence, passing checks, and required approval."
-      : attempt.audit?.passed && minimum.passed
+      ? "PR behavior and required checks pass."
+      : attempt.audit?.passed
         ? "Implementation is verified, but the PR is not merge-ready."
         : "Implementation verification is incomplete; resolve the pending evidence before promotion.",
     checks,
@@ -442,12 +292,6 @@ function readinessCheck(id, passed, detail) {
   return { id, passed: Boolean(passed), detail };
 }
 
-function sameStrings(left, right) {
-  const a = [...new Set(left)].sort();
-  const b = [...new Set(right)].sort();
-  return a.length === b.length && a.every((value, index) => value === b[index]);
-}
-
 function normalizeRepository(value) {
   return String(value || "")
     .trim()
@@ -455,146 +299,3 @@ function normalizeRepository(value) {
     .replace(/\.git$/, "")
     .toLowerCase();
 }
-
-async function inspectEvidence(charter, evidencePath) {
-  if (!evidencePath) return null;
-  const resolved = path.resolve(evidencePath);
-  const root = charter.ui_evidence_root ? path.resolve(charter.ui_evidence_root) : null;
-  let fileStat = null;
-  try {
-    fileStat = await stat(resolved);
-  } catch {
-    // Missing evidence is represented in the returned artifact.
-  }
-  const underRoot = Boolean(
-    root && (resolved === root || resolved.startsWith(`${root}${path.sep}`)),
-  );
-  const directoryEvidence = fileStat?.isDirectory()
-    ? await scanEvidenceDirectory(resolved)
-    : null;
-  const directKind = fileStat?.isFile() ? evidenceKind(resolved) : "unknown";
-  const visualFileCount = fileStat?.isFile()
-    ? (await isVisualEvidenceFile(resolved))
-      ? 1
-      : 0
-    : directoryEvidence?.visualFileCount ?? 0;
-  const sizeBytes = fileStat?.isDirectory()
-    ? directoryEvidence?.sizeBytes ?? 0
-    : fileStat?.size ?? 0;
-  return {
-    path: resolved,
-    kind: fileStat?.isDirectory() ? "directory" : directKind,
-    exists: Boolean(fileStat),
-    under_required_root: underRoot,
-    size_bytes: sizeBytes,
-    file_count: fileStat?.isFile() ? 1 : directoryEvidence?.fileCount ?? 0,
-    visual_file_count: visualFileCount,
-    git_tracked: false,
-    summary:
-      fileStat && underRoot && sizeBytes > 0
-        ? `Evidence exists under the required local root; ${visualFileCount} visual artifact(s) found.`
-        : "Evidence is missing, empty, or outside the required local root.",
-  };
-}
-
-async function scanEvidenceDirectory(directory) {
-  const pending = [directory];
-  let fileCount = 0;
-  let visualFileCount = 0;
-  let sizeBytes = 0;
-  while (pending.length > 0 && fileCount < 500) {
-    const current = pending.shift();
-    if (!current) break;
-    let entries;
-    try {
-      entries = await readdir(current, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    for (const entry of entries) {
-      if (entry.isSymbolicLink()) continue;
-      const candidate = path.join(current, entry.name);
-      if (entry.isDirectory()) {
-        pending.push(candidate);
-        continue;
-      }
-      if (!entry.isFile()) continue;
-      fileCount += 1;
-      if (await isVisualEvidenceFile(candidate)) visualFileCount += 1;
-      try {
-        sizeBytes += (await stat(candidate)).size;
-      } catch {
-        // A file disappearing during inspection is simply not counted toward its size.
-      }
-      if (fileCount >= 500) break;
-    }
-  }
-  return { fileCount, visualFileCount, sizeBytes };
-}
-
-async function isVisualEvidenceFile(filePath) {
-  if (!["image", "video"].includes(evidenceKind(filePath))) return false;
-  const header = Buffer.alloc(16);
-  let handle;
-  try {
-    handle = await open(filePath, "r");
-    const { bytesRead } = await handle.read(header, 0, header.length, 0);
-    if (bytesRead === 0) return false;
-  } catch {
-    return false;
-  } finally {
-    try {
-      await handle?.close();
-    } catch {
-      // The evidence file may disappear while it is being inspected.
-    }
-  }
-  const ascii = header.toString("ascii");
-  return (
-    header.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])) ||
-    header.subarray(0, 3).equals(Buffer.from([255, 216, 255])) ||
-    ascii.startsWith("GIF87a") ||
-    ascii.startsWith("GIF89a") ||
-    (ascii.startsWith("RIFF") && ascii.slice(8, 12) === "WEBP") ||
-    ascii.slice(4, 8) === "ftyp" ||
-    header.subarray(0, 4).equals(Buffer.from([26, 69, 223, 163]))
-  );
-}
-
-async function inspectVisualReviewArtifacts(charter, visualReview) {
-  const root = charter.ui_evidence_root ? path.resolve(charter.ui_evidence_root) : null;
-  const verified = [];
-  const invalid = [];
-  for (const artifact of visualReview.artifacts) {
-    const resolved = path.resolve(artifact);
-    const underRoot = Boolean(
-      root && (resolved === root || resolved.startsWith(`${root}${path.sep}`)),
-    );
-    let fileStat = null;
-    try {
-      fileStat = await stat(resolved);
-    } catch {
-      // The invalid reason below covers missing files.
-    }
-    if (
-      !underRoot ||
-      !fileStat?.isFile() ||
-      fileStat.size <= 0 ||
-      !(await isVisualEvidenceFile(resolved))
-    ) {
-      invalid.push(artifact);
-      continue;
-    }
-    verified.push(resolved);
-  }
-  return {
-    valid: visualReview.artifacts.length > 0 && invalid.length === 0,
-    verified,
-    summary:
-      visualReview.artifacts.length === 0
-        ? "No inspected visual artifact paths were recorded."
-        : invalid.length > 0
-          ? `Missing, non-visual, or out-of-root artifacts: ${invalid.join(", ")}`
-          : `${verified.length} inspected visual artifact(s) exist under the required local root with valid media signatures.`,
-  };
-}

package/src/orchestrator/budget.js

@@ -67,7 +67,7 @@ export function extendProgressCeilings(snapshot, changes = {}) {
   const provided = Object.entries(changes).filter(([, value]) => value !== undefined);
   if (!provided.length) throw new Error("Explicitly increase at least one hard ceiling.");
   for (const [field, value] of provided) {
-    const previous = field === "provider_token_ceiling" ? snapshot.charter.provider_token_ceiling : snapshot.charter.attempt_ceiling;
+    const previous = field === "provider_token_ceiling" ? current.hard_token_ceiling : current.hard_attempt_ceiling;
     const used = field === "provider_token_ceiling" ? current.tokens_used : (snapshot.attempts || []).length;
     if (!Number.isSafeInteger(value) || value <= previous || value <= used) {
       throw new Error("Each requested hard ceiling must be an integer higher than its current limit and recorded usage.");
@@ -98,11 +98,12 @@ export function budgetState(snapshot, pendingAttempt = null) {
   const retriesUsed = Math.max(attemptsUsed - 1, 0);
   const policy = progressLimits(snapshot?.charter);
   // Persisted thresholds remain readable for old contracts and usage reports.
-  // Local work stops on failed progress/approval, never on consumption counters.
-  const hardTokenCeiling = null;
-  const hardAttemptCeiling = null;
-  const tokenExhausted = false;
-  const retryExhausted = false;
+  // Warning thresholds never prevent useful work. Separate safety ceilings
+  // bound subsequent provider calls without interrupting an active process.
+  const hardTokenCeiling = policy.provider_token_ceiling;
+  const hardAttemptCeiling = policy.attempt_ceiling;
+  const tokenExhausted = tokensUsed >= hardTokenCeiling;
+  const retryExhausted = attemptsUsed >= hardAttemptCeiling;
   return {
     schema_version: 1,
     token_budget: tokenBudget,
@@ -115,17 +116,18 @@ export function budgetState(snapshot, pendingAttempt = null) {
     retry_exhausted: retryExhausted,
     exhausted: tokenExhausted || retryExhausted,
     exhausted_reason: tokenExhausted
-      ? "token_budget_exhausted"
+      ? "provider_token_ceiling_reached"
       : retryExhausted
-        ? "retry_budget_exhausted"
+        ? "attempt_ceiling_reached"
         : null,
     continuation_policy: policy.continuation_policy,
     local_limits_removed: true,
+    safety_ceilings_enforced: true,
     token_warning: tokensUsed >= tokenBudget,
     retry_warning: attemptsUsed >= retryBudget + 1,
     hard_token_ceiling: hardTokenCeiling,
     hard_attempt_ceiling: hardAttemptCeiling,
-    hard_tokens_remaining: null,
+    hard_tokens_remaining: Math.max(hardTokenCeiling - tokensUsed, 0),
   };
 }
 
@@ -146,8 +148,17 @@ export function refreshBudgetState(snapshot, pendingAttempt = null) {
   return state;
 }
 
-export function canStartProvider(snapshot) {
-  return { allowed: true, reason: null, budget: refreshBudgetState(snapshot) };
+export function canStartProvider(snapshot, { attemptNumber, phase = "executor" } = {}) {
+  const budget = refreshBudgetState(snapshot);
+  if (budget.token_exhausted) {
+    return { allowed: false, reason: "provider_token_ceiling_reached", budget };
+  }
+  // The reviewer belongs to the existing attempt, including the last allowed
+  // attempt. Only a new executor attempt consumes another attempt allowance.
+  if (phase === "executor" && (budget.retry_exhausted || attemptNumber > budget.hard_attempt_ceiling)) {
+    return { allowed: false, reason: "attempt_ceiling_reached", budget };
+  }
+  return { allowed: true, reason: null, budget };
 }
 
 export function codingAttemptCeiling() {

package/src/orchestrator/charter-validation.js

@@ -1,41 +1,3 @@
-import { verifyObjective } from './outcome-monitor.js';
-import { charterPreparationIdentity } from './charter-repair.js';
-export function validateCharter(charter) {
-  const findings = [];
-  const objective = verifyObjective(charter);
-  const reviewedAI = objective.valid && charter.acceptance_criteria_source === 'ai_reviewed' && charter.ai_preparation?.review?.passed === true &&
-    charter.ai_preparation.objective_digest === objective.digest && charter.ai_preparation.context_digest === charterPreparationIdentity(charter);
-  if (charter.risk.requires_design_review && charter.acceptance_criteria_source !== "explicit" && !reviewedAI) {
-    findings.push({
-      code: "EXPLICIT_ACCEPTANCE_CRITERIA_REQUIRED",
-      severity: "blocker",
-      target: "acceptance_criteria",
-      explanation: "AI must derive explicit, source-grounded acceptance criteria from the original objective before implementation.",
-      repairability: "auto",
-      blocker_kind: "machine",
-    });
-  }
-  if (charter.design_review.required && charter.design_review.status !== "approved") {
-    findings.push({
-      code: "DESIGN_REVIEW_REQUIRED",
-      severity: "blocker",
-      target: "design_review",
-      explanation:
-        "AI must obtain an independent design review, reviewer identity and evidence before implementation. Do not fabricate review approval.",
-      repairability: "auto",
-      blocker_kind: "machine",
-    });
-  }
-  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: "auto",
-      blocker_kind: "machine",
-    });
-  }
-  return findings;
-}
-
+// A request does not need a design approval, named CI inventory or acceptance
+// paperwork before useful work can begin. Authority is checked at execution.
+export function validateCharter() { return []; }

package/src/orchestrator/checklist-continuation.js

@@ -9,18 +9,6 @@ export const DELIVERY_STATE_MODEL_PATH = fileURLToPath(
   new URL("./delivery/references/state-model.md", import.meta.url),
 );
 
-export function buildChecklistContinuationInstruction({ auditor = false } = {}) {
-  return section("checklist_continuation_contract", [
-    `Read the integrated delivery state model: ${DELIVERY_STATE_MODEL_PATH}. Keep proven delivery milestones, controller execution states, and final dispositions distinct. Follow the repair/reverify and evidence-invalidation branches; a PR readiness state never proves deployment or overall completion. The model documents the existing controller and executor duties, not an automatic scheduler or new transition validator.`,
-    `The table is a progress checkpoint, not the deliverable or a stopping condition. Read: ${ACCEPTANCE_EVIDENCE_PATH}`,
-    "Maintain the complete 依頼チェックリスト with columns #, ご依頼, 現状, 判定 in the evidence record after chartering, each evaluated attempt, and in the final receipt. User-facing reporting follows workflow_reporting_contract; show the full table only when requested or when it is the most useful requested answer, never as mandatory commentary. Preserve stable criterion IDs, all rows and both applicable evidence layers. ✅ requires current valid passing evidence for every applicable layer; ❌ means an observed failure; 🟡 means pending, missing, stale, blocked or unverifiable evidence. Retain counts and highest proven state in that record.",
-    "After observing any non-green row, classify its cause and immediately take the next safe authorized action: implement missing behavior, repair a failure, exercise an untested path, collect missing evidence, or rerun stale verification. Re-observe the same criterion against the current candidate, run the validator, update the table, and repeat until every applicable requested outcome and gate for the authorized endpoint is verified. A next-action list without performing feasible actions is not completion. Never require another continue request merely because a table was shown.",
-    "For CI or other in-progress dependencies, use the available bounded wait/recheck or approved monitoring mechanism and maintain progress communication. Unchanged external state is not itself a blocker. Do not start duplicate jobs or busy-poll. Recheck current revision/results, repair authorized failures, and keep waiting only within the authorized scope and external service availability. If waiting cannot continue, report the concrete limit and explicit resumption condition; do not silently abandon it or promise an unscheduled follow-up.",
-    "If a row genuinely requires new authority, credentials, an irreversible or explicitly user-reserved decision, an unavailable dependency or a repeated-failure or no-progress safety circuit, retain it as non-green and record affected IDs, evidence of the blocker, safe alternatives attempted, exact missing input, owner and resumption trigger. Continue independent in-scope work. Stop with blocked, best_available, failed or cancelled as appropriate, explicitly unfinished, not verified_complete. Never bypass a manual stop, approval, or expand authority to force green.",
-    "Do not end successfully while a safe authorized repair, verification or bounded wait remains. All-green applies to the frozen authorized endpoint: PR-only work does not authorize merge/deploy, but a PR URL, an improvement PR, an issue, a narrower test or a future plan does not satisfy an unmet outcome. Never drop/merge away rows, weaken criteria, relabel applicable checks as not_applicable, recolor unknowns, or copy new digests onto old evidence to force green. Do not change the requested endpoint to match the work already completed.",
-    "Before the final response, independently reconcile the original request with all criterion IDs and current evidence, check remaining endpoint gates, and preserve the full table and explicit disposition in the evidence record. Distinguish a partial artifact from verified completion and disclose material remaining outcomes in the requested response format; keep yellow/red counts in the record. A pr_ready_for_review or blocked controller state is not proof of overall completion. These instructions strengthen continuation and reporting; they do not add a background scheduler or remove approval, manual-stop and progress protections.",
-    auditor
-      ? "Remain read-only. Check that the executor performed feasible follow-up actions after non-green tables. Report premature stopping, omitted rows, unsupported green claims, or a blocker without evidence as findings, alongside exact criterion IDs and the necessary next action. Do not approve from a table's colors or the executor's completion wording."
-      : "Execute the continuation within this attempt instead of merely returning a yellow table or delegating feasible remaining work to the requester. Return control honestly at a genuine boundary; never fabricate completion evidence.",
-  ].join("\n"));
+export function buildChecklistContinuationInstruction() {
+  return section("requested_outcome", 'Continue unfinished requested work and repair concrete failures without waiting for another continue request. Do not maintain a mandatory checklist or evidence table. Verify the actual result; if an external dependency blocks progress, continue independent work and state the real resumption condition. Preserve user stops, permissions and budgets.');
 }

package/src/orchestrator/completion-contract.js

@@ -7,8 +7,7 @@ const criterionIdPattern = /^[A-Za-z][A-Za-z0-9]*(?:[-_.][A-Za-z0-9]+)*$/;
 export function hasUserOutcomeProof(coverage) {
   const proof = coverage?.user_outcome;
   return proof?.passed === true && Boolean(cleanString(proof.verification_method)) &&
-    Boolean(cleanString(proof.observed_result)) && Array.isArray(proof.evidence_refs) &&
-    proof.evidence_refs.some((ref) => Boolean(cleanString(ref)));
+    Boolean(cleanString(proof.observed_result));
 }
 
 export function buildCompletionContract({
@@ -35,7 +34,6 @@ export function buildCompletionContract({
     ...productionContract,
     non_goals: stringArray(nonGoals),
     proof_required: uniqueStrings([
-      "criterion_evidence",
       ...proofRequired,
       ...stringArray(expectedEvidence),
     ]),
@@ -135,53 +133,11 @@ export function completionEvidenceChecks(charter, attempt) {
   const contract = record(charter?.completion_contract);
   if (contract.version !== COMPLETION_CONTRACT_VERSION) return [check("completion_contract_version", "Supported completion contract required", false, "Missing or unsupported completion contract; re-charter and verify before promotion.")];
 
-  const uncertainty = normalizeUncertaintyVerification(attempt?.uncertainty_verification);
   const rows = acceptanceCriterionRows(charter);
   const criterionEvidence = normalizeCriterionEvidence(attempt?.criterion_evidence);
-  const expectedCriterionIds = new Set(rows.map((row) => row.id));
-  const unexpectedCriterionIds = uniqueStrings(
-    criterionEvidence
-      .map((item) => item.criterion_id)
-      .filter((criterionId) => !expectedCriterionIds.has(criterionId)),
-  );
-  const checks = [
-    check(
-      "top_uncertainty_recorded",
-      "Highest uncertainty is explicit",
-      Boolean(uncertainty.top_uncertainty),
-      uncertainty.top_uncertainty || "No highest uncertainty was recorded.",
-    ),
-    check(
-      "first_verification_recorded",
-      "First discriminating verification is explicit",
-      Boolean(uncertainty.first_verification),
-      uncertainty.first_verification || "No first verification was recorded.",
-    ),
-    check(
-      "uncertainty_evidence_recorded",
-      "Uncertainty verification records concrete evidence",
-      uncertainty.evidence_checked.length > 0 && Boolean(uncertainty.observed_result),
-      uncertainty.evidence_checked.length > 0 && uncertainty.observed_result
-        ? `${uncertainty.evidence_checked.length} evidence item(s): ${uncertainty.observed_result}`
-        : "The uncertainty check needs evidence_checked and an observed_result.",
-    ),
-    check(
-      "top_uncertainty_resolved",
-      "Highest uncertainty is resolved before completion",
-      uncertainty.resolved,
-      uncertainty.resolved
-        ? "The executor marked the highest uncertainty resolved with observed evidence."
-        : uncertainty.fallback || "The highest uncertainty remains unresolved.",
-    ),
-    check(
-      "criterion_evidence_scope",
-      "Criterion evidence matches the charter acceptance criteria",
-      unexpectedCriterionIds.length === 0,
-      unexpectedCriterionIds.length === 0
-        ? "Every criterion evidence row references a chartered acceptance criterion."
-        : `Unexpected criterion evidence: ${unexpectedCriterionIds.join(", ")}.`,
-    ),
-  ];
+  const known = new Set(rows.map(row => row.id));
+  const checks = [check("criterion_evidence_scope", "Results belong to the requested behavior",
+    criterionEvidence.every(row => known.has(row.criterion_id)), "Do not substitute an unrelated result for the request.")];
 
   for (const row of rows) {
     const matches = criterionEvidence.filter((item) => item.criterion_id === row.id);
@@ -194,7 +150,6 @@ export function completionEvidenceChecks(charter, attempt) {
           matches.length === 1 &&
             evidence?.passed &&
             evidence.verification_method &&
-            evidence.evidence_refs.length > 0 &&
             evidence.observed_result,
         ),
         matches.length > 1