loopforge 3.9.2 → 4.0.7

package/dist/self-eval.js

@@ -4,7 +4,8 @@
 import { makeExecutionReport, makeSelfEvaluation, } from "./protocol.js";
 import { retiredFieldDetail, submittedFieldPaths, unknownExecutionReportEntryFields, unknownTopLevelFields, } from "./submission-guidance.js";
 import { DIAG_ALL_ENTRIES_DROPPED, DIAG_EMPTY_VALUE, } from "./submission-diagnostics.js";
-import { criterionRefMatches } from "./token-utils.js";
+import { canonicalContractItemText, criterionRefMatches, isCriterionId, } from "./token-utils.js";
+import { isOpenQuestionId } from "./open-question.js";
 const DIAGNOSTICS_LIMIT = 100;
 class DiagnosticsCollector {
     entries = [];
@@ -93,19 +94,6 @@ export const EMERGED_LIMITS = { items: 50, chars: 500 };
 export function boundedEmergedSubtasks(value, sink) {
     return boundedStringArray(value, EMERGED_LIMITS.items, EMERGED_LIMITS.chars, sink, "emerged_subtasks");
 }
-function nonNegativeInteger(value, sink, path = "") {
-    if (typeof value !== "number" || !Number.isFinite(value)) {
-        if (value !== undefined && value !== null) {
-            sink?.push(path, "invalid_value", "normalized", "expected a finite number; defaulted to 0");
-        }
-        return 0;
-    }
-    const normalized = Math.max(0, Math.trunc(value));
-    if (normalized !== value) {
-        sink?.push(path, "normalized", "normalized", `expected a non-negative integer; normalized to ${normalized}`);
-    }
-    return normalized;
-}
 /** v2.12: Parse retroactive claims — {round ≥ 1, claim non-empty}, capped at
  *  20 entries. Invalid entries are silently dropped (lenient parsing). */
 function parseRetroactiveClaims(raw, sink) {
@@ -156,61 +144,44 @@ export function parseExecutionReport(raw, sink, knownCriterionRefs) {
         return undefined;
     }
     for (const key of unknownExecutionReportEntryFields(raw)) {
-        sink?.push(`execution_report.${key}`, "unknown_field", "dropped", "not a declared execution_report field; it was dropped");
-    }
-    const testResults = raw.tests_reported && typeof raw.tests_reported === "object" &&
-        !Array.isArray(raw.tests_reported)
-        ? raw.tests_reported
-        : undefined;
-    let tests = null;
-    if (raw.tests_reported !== undefined && raw.tests_reported !== null) {
-        if (!testResults) {
-            sink?.push("execution_report.tests_reported", "invalid_entry", "dropped", "expected { passed, failed, skipped }; the value was dropped");
-        }
-        else if (typeof testResults.passed !== "number" ||
-            !Number.isFinite(testResults.passed)) {
-            sink?.push("execution_report.tests_reported", "invalid_value", "dropped", "`passed` must be a finite number; the whole object was dropped");
-        }
-        else {
-            for (const key of Object.keys(testResults)) {
-                if (key !== "passed" && key !== "failed" && key !== "skipped") {
-                    sink?.push(`execution_report.tests_reported.${key}`, "unknown_field", "dropped", "not a declared test-count field; it was dropped");
-                }
-            }
-            tests = {
-                passed: nonNegativeInteger(testResults.passed, sink, "execution_report.tests_reported.passed"),
-                failed: nonNegativeInteger(testResults.failed, sink, "execution_report.tests_reported.failed"),
-                skipped: nonNegativeInteger(testResults.skipped, sink, "execution_report.tests_reported.skipped"),
-            };
-        }
+        const path = `execution_report.${key}`;
+        sink?.push(path, "unknown_field", "dropped", retiredFieldDetail(path) ?? "not a declared execution_report field; it was dropped");
     }
     return makeExecutionReport({
         files_changed: boundedStringArray(raw.files_changed, 200, 500, sink, "execution_report.files_changed"),
-        tests_reported: tests,
-        criterion_claims: parseCriterionClaims(raw.criterion_claims, sink, knownCriterionRefs),
-        contract_item_claims: parseContractItemClaims(raw.contract_item_claims, sink),
+        claims: parseExecutionClaims(raw.claims, sink, knownCriterionRefs),
     });
 }
-/** v3.8: The criterion ids the agent claims met this round. */
+const CLAIM_ID_RE = /^(cr|rci)-[a-f0-9]{8}$/;
+function isCriterionClaimId(id) {
+    return id.startsWith("cr-");
+}
+/** v4.0.6: the claimed `cr-` criterion ids with the given outcome. */
+function claimedCriteria(report, outcome) {
+    return (report?.claims ?? [])
+        .filter((claim) => claim.outcome === outcome && isCriterionClaimId(claim.id))
+        .map((claim) => claim.id);
+}
+/** v4.0.6: The criterion ids the agent claims met this round. */
 export function claimedMetCriteria(report) {
-    return (report?.criterion_claims ?? [])
-        .filter((claim) => claim.outcome === "met")
-        .map((claim) => claim.criterion_id);
+    return claimedCriteria(report, "met");
 }
-/** v3.8: The criterion ids the agent declares still outstanding. */
+/** v4.0.6: The criterion ids the agent declares still outstanding. */
 export function claimedRemainingCriteria(report) {
-    return (report?.criterion_claims ?? [])
-        .filter((claim) => claim.outcome === "remaining")
-        .map((claim) => claim.criterion_id);
+    return claimedCriteria(report, "remaining");
 }
-/** v3.8: LENIENT parse of advisory criterion claims — unknown or malformed
- *  entries are dropped, never a rejection (the contract item layer is the
- *  strict one). */
-function parseCriterionClaims(raw, sink, knownCriterionRefs) {
+/** v4.0.6: LENIENT parse of the ONE claims channel.
+ *
+ *  `cr-` claims are advisory: unknown/malformed entries are dropped with a
+ *  diagnostic, never a rejection. `rci-` claims are STRICT at the submission
+ *  boundary (`validateContractShape` checks format, uniqueness and the ACTIVE
+ *  item set); this parser only normalizes what reaches the read model and
+ *  drops structurally malformed entries on library paths. */
+function parseExecutionClaims(raw, sink, knownCriterionRefs) {
     if (raw === undefined || raw === null)
         return [];
     if (!Array.isArray(raw)) {
-        sink?.push("execution_report.criterion_claims", "not_array", "dropped", "expected an array of claims; the value was dropped");
+        sink?.push("execution_report.claims", "not_array", "dropped", "expected an array of { id, outcome } claims; the value was dropped");
         return [];
     }
     const claims = [];
@@ -225,29 +196,30 @@ function parseCriterionClaims(raw, sink, knownCriterionRefs) {
             continue;
         }
         const entry = item;
-        if (typeof entry.criterion_id !== "string" ||
-            entry.criterion_id.trim().length === 0 ||
+        if (typeof entry.id !== "string" ||
             (entry.outcome !== "met" && entry.outcome !== "remaining")) {
             invalid++;
             continue;
         }
-        const trimmed = entry.criterion_id.trim();
-        if (trimmed !== entry.criterion_id) {
-            sink?.push(`execution_report.criterion_claims[${index}].criterion_id`, "normalized", "normalized", "leading/trailing whitespace was trimmed");
+        const trimmed = entry.id.trim();
+        if (trimmed !== entry.id) {
+            sink?.push(`execution_report.claims[${index}].id`, "normalized", "normalized", "leading/trailing whitespace was trimmed");
         }
-        if (trimmed.length > 500) {
-            sink?.push(`execution_report.criterion_claims[${index}].criterion_id`, "truncated", "truncated", "longer than 500 chars; truncated to the limit");
+        if (trimmed.length > 64) {
+            sink?.push(`execution_report.claims[${index}].id`, "truncated", "truncated", "longer than 64 chars; truncated to the limit");
         }
-        const criterionId = trimmed.slice(0, 500);
-        if (knownCriterionRefs !== undefined && knownCriterionRefs !== null &&
-            !knownCriterionRefs.some((criterion) => criterionRefMatches(criterionId, criterion))) {
+        const id = trimmed.slice(0, 64);
+        if (!CLAIM_ID_RE.test(id)) {
+            invalid++;
+            continue;
+        }
+        if (isCriterionClaimId(id) && knownCriterionRefs !== undefined &&
+            knownCriterionRefs !== null &&
+            !knownCriterionRefs.some((criterion) => criterionRefMatches(id, criterion))) {
             unknown++;
             continue;
         }
-        claims.push({
-            criterion_id: criterionId,
-            outcome: entry.outcome,
-        });
+        claims.push({ id, outcome: entry.outcome });
     }
     if (invalid > 0 || unknown > 0) {
         if (claims.length === 0) {
@@ -256,104 +228,24 @@ function parseCriterionClaims(raw, sink, knownCriterionRefs) {
                 parts.push(`${invalid} malformed`);
             if (unknown > 0)
                 parts.push(`${unknown} unknown criterion`);
-            sink?.push("execution_report.criterion_claims", DIAG_ALL_ENTRIES_DROPPED, "dropped", `all ${invalid + unknown} claims were dropped (${parts.join(", ")}; advisory)`);
+            sink?.push("execution_report.claims", DIAG_ALL_ENTRIES_DROPPED, "dropped", `all ${invalid + unknown} claims were dropped (${parts.join(", ")}; ` +
+                "malformed/unreferenced claims never reject a round)");
         }
         else {
             if (invalid > 0) {
-                sink?.push("execution_report.criterion_claims", "invalid_entry", "dropped", `${invalid} malformed claim${invalid === 1 ? "" : "s"} dropped (advisory)`);
+                sink?.push("execution_report.claims", "invalid_entry", "dropped", `${invalid} malformed claim${invalid === 1 ? "" : "s"} dropped`);
             }
             if (unknown > 0) {
-                sink?.push("execution_report.criterion_claims", "unknown_id", "dropped", `${unknown} claim${unknown === 1 ? "" : "s"} cited a criterion the ` +
+                sink?.push("execution_report.claims", "unknown_id", "dropped", `${unknown} cr- claim${unknown === 1 ? "" : "s"} cited a criterion the ` +
                     "prompt did not render; dropped (advisory)");
             }
         }
     }
     if (raw.length > 100) {
-        sink?.push("execution_report.criterion_claims", "too_many", "truncated", "only the first 100 claims are kept");
-    }
-    return claims;
-}
-/** v3.8: LENIENT parse of contract item claims. Referential validity is the
- *  strict pre-advance boundary in validateContractShape — this parser only
- *  normalizes what reaches the read model. */
-function parseContractItemClaims(raw, sink) {
-    if (raw === undefined || raw === null)
-        return [];
-    if (!Array.isArray(raw)) {
-        sink?.push("execution_report.contract_item_claims", "not_array", "dropped", "expected an array of claims; the value was dropped");
-        return [];
-    }
-    const claims = [];
-    let invalid = 0;
-    for (let index = 0; index < raw.length; index++) {
-        if (claims.length >= 20)
-            break;
-        const item = raw[index];
-        if (typeof item !== "object" || item === null || Array.isArray(item)) {
-            invalid++;
-            continue;
-        }
-        const entry = item;
-        if (typeof entry.item_id !== "string" ||
-            (entry.outcome !== "met" && entry.outcome !== "remaining")) {
-            invalid++;
-            continue;
-        }
-        const trimmed = entry.item_id.trim();
-        if (trimmed !== entry.item_id) {
-            sink?.push(`execution_report.contract_item_claims[${index}].item_id`, "normalized", "normalized", "leading/trailing whitespace was trimmed");
-        }
-        if (trimmed.length > 64) {
-            sink?.push(`execution_report.contract_item_claims[${index}].item_id`, "truncated", "truncated", "longer than 64 chars; truncated to the limit");
-        }
-        claims.push({
-            item_id: trimmed.slice(0, 64),
-            outcome: entry.outcome,
-        });
-    }
-    if (invalid > 0) {
-        sink?.push("execution_report.contract_item_claims", claims.length === 0 ? DIAG_ALL_ENTRIES_DROPPED : "invalid_entry", "dropped", claims.length === 0
-            ? `all ${invalid} claims were malformed; the value was dropped`
-            : `${invalid} malformed claim${invalid === 1 ? "" : "s"} dropped`);
-    }
-    if (raw.length > 20) {
-        sink?.push("execution_report.contract_item_claims", "too_many", "truncated", "only the first 20 claims are kept");
+        sink?.push("execution_report.claims", "too_many", "truncated", "only the first 100 claims are kept");
     }
     return claims;
 }
-/** Parse CriterionRevision[] from a raw JSON array. */
-export function parseCriterionRevisions(raw, sink) {
-    if (raw === undefined || raw === null)
-        return [];
-    if (!Array.isArray(raw)) {
-        sink?.push("revised_success_criteria", "not_array", "dropped", "expected an array of { old, new }; the value was dropped");
-        return [];
-    }
-    const valid = raw.filter((v) => typeof v === "object" && v !== null &&
-        typeof v.old === "string" &&
-        typeof v.new === "string");
-    const invalid = raw.length - valid.length;
-    if (invalid > 0) {
-        sink?.push("revised_success_criteria", valid.length === 0 ? DIAG_ALL_ENTRIES_DROPPED : "invalid_entry", "dropped", valid.length === 0
-            ? `all ${invalid} entries lacked string old/new; the value was dropped`
-            : `${invalid} entr${invalid === 1 ? "y" : "ies"} without string old/new dropped`);
-    }
-    if (valid.length > 20) {
-        sink?.push("revised_success_criteria", "too_many", "truncated", "only the first 20 revisions are kept");
-    }
-    return valid.slice(0, 20).map((v, index) => {
-        const r = v;
-        for (const key of ["old", "new"]) {
-            if (r[key].length > 500) {
-                sink?.push(`revised_success_criteria[${index}].${key}`, "truncated", "truncated", "longer than 500 chars; truncated to the limit");
-            }
-        }
-        return {
-            old: r.old.slice(0, 500),
-            new: r.new.slice(0, 500),
-        };
-    });
-}
 /** Parse SubGoalUpdate[] from a raw JSON array.
  *  v3.7.1: lenient per-entry filtering (id/status shape) with fixed caps
  *  (20 entries, id ≤ 64, note ≤ 300). Referential validity — unknown IDs
@@ -445,16 +337,12 @@ export function parseWorkerResults(raw, sink) {
     return valid.slice(0, 20).map((v, index) => {
         const w = v;
         for (const key of Object.keys(w)) {
-            if (!["agentId", "subAgentType", "subTask", "resultSummary", "outcome",
-                "discoveredConstraints"].includes(key)) {
+            if (!["agentId", "subTask", "resultSummary", "outcome"].includes(key)) {
                 sink?.push(`worker_results[${index}].${key}`, "unknown_field", "dropped", "not a declared worker-result field; it was dropped");
             }
         }
-        if (w.subAgentType !== undefined && typeof w.subAgentType !== "string") {
-            sink?.push(`worker_results[${index}].subAgentType`, "invalid_value", "normalized", "expected a string; defaulted to general-purpose");
-        }
         for (const [key, cap] of [
-            ["agentId", 200], ["subAgentType", 100], ["subTask", 500], ["resultSummary", 1000],
+            ["agentId", 200], ["subTask", 500], ["resultSummary", 1000],
         ]) {
             const value = w[key];
             if (typeof value === "string" && value.length > cap) {
@@ -463,56 +351,34 @@ export function parseWorkerResults(raw, sink) {
         }
         return {
             agentId: (w.agentId.slice(0, 200)),
-            subAgentType: typeof w.subAgentType === "string"
-                ? w.subAgentType.slice(0, 100)
-                : "general-purpose",
             subTask: (w.subTask.slice(0, 500)),
             resultSummary: (w.resultSummary.slice(0, 1000)),
             outcome: w.outcome,
-            discoveredConstraints: boundedStringArray(w.discoveredConstraints, 50, 500, sink, `worker_results[${index}].discoveredConstraints`),
         };
     });
 }
-/** v2.12: The effective round outcome — declared outcome wins, otherwise
- *  derived from `success`. "partial" can only be declared explicitly (never
- *  silently derived from success=false, which would quietly change the
- *  success-class enforcement surface). */
-export function effectiveOutcome(selfEval) {
-    if (selfEval.outcome === "success" || selfEval.outcome === "partial" ||
-        selfEval.outcome === "failed" || selfEval.outcome === "blocked") {
-        return selfEval.outcome;
-    }
-    return selfEval.success ? "success" : "failed";
-}
-/** v2.12: Whether the effective outcome is a success claim. Shared by the
- *  verification gate (success-class checks) and enforcement gate (R3). */
-export function effectiveSuccess(selfEval) {
-    return effectiveOutcome(selfEval) === "success";
-}
-/** v3.8.3: The ONE definition of "this round declares itself blocked".
- *
- *  A declared `outcome: "blocked"` and a `stop_reason` of `blocked` or
- *  `needs_human_input` say the same thing — the agent is stopping because it
- *  cannot continue, not because it finished. The stop decision
- *  (round-coordinator) and the scope-drift waiver (enforcement gate) both read
- *  this function, so "declared blocked" cannot mean two different things at
- *  two different boundaries. `effectiveOutcome` alone is NOT this predicate:
- *  it reads `outcome` only. */
-export function declaresBlocked(selfEval) {
-    return selfEval.outcome === "blocked" ||
-        selfEval.stop_reason === "blocked" ||
-        selfEval.stop_reason === "needs_human_input";
-}
+// v3.9.7: the outcome predicates live in round-outcome.ts so contract
+// closure, the walker, the verification gate and the coordinator share one
+// definition. Re-exported for the existing public surface.
+export { effectiveOutcome, effectiveSuccess, declaresBlocked, } from "./round-outcome.js";
+export const OBJECTIVE_REFINEMENT_MAX = 1000;
+export const BLOCKER_MAX = 500;
 export function validateCoreSelfEvaluation(raw) {
     const missing = [];
     const invalid = [];
-    const required = ["success", "output_summary", "constraint_violations", "should_continue"];
+    const required = ["outcome", "output_summary", "constraint_violations", "should_continue"];
     for (const field of required) {
         if (!(field in raw))
             missing.push(field);
     }
-    if ("success" in raw && typeof raw.success !== "boolean") {
-        invalid.push({ field: "success", expected: "boolean" });
+    const outcome = raw.outcome;
+    if ("outcome" in raw &&
+        (outcome !== "success" && outcome !== "partial" &&
+            outcome !== "failed" && outcome !== "blocked")) {
+        invalid.push({
+            field: "outcome",
+            expected: "success | partial | failed | blocked",
+        });
     }
     if ("output_summary" in raw && typeof raw.output_summary !== "string") {
         invalid.push({ field: "output_summary", expected: "string" });
@@ -525,13 +391,56 @@ export function validateCoreSelfEvaluation(raw) {
     if ("should_continue" in raw && typeof raw.should_continue !== "boolean") {
         invalid.push({ field: "should_continue", expected: "boolean" });
     }
+    // v4.0.6: strict outcome/blocker combinations. A non-blocked blocker is NOT
+    // rejected — it is dropped with a diagnostic by the parser.
+    if (outcome === "success" && raw.should_continue === true) {
+        invalid.push({
+            field: "outcome",
+            expected: "outcome=success requires should_continue=false",
+        });
+    }
+    if (outcome === "blocked") {
+        if (raw.should_continue === true) {
+            invalid.push({
+                field: "outcome",
+                expected: "outcome=blocked requires should_continue=false",
+            });
+        }
+        if (typeof raw.blocker !== "string" || raw.blocker.trim().length === 0) {
+            invalid.push({
+                field: "blocker",
+                expected: "a non-empty blocker string is required when outcome=blocked",
+            });
+        }
+        else if (raw.blocker.length > BLOCKER_MAX) {
+            invalid.push({
+                field: "blocker",
+                expected: `a string of at most ${BLOCKER_MAX} chars when outcome=blocked`,
+            });
+        }
+    }
+    if (raw.objective_refinement !== undefined) {
+        const refinement = raw.objective_refinement;
+        if (typeof refinement !== "string" || refinement.trim().length === 0) {
+            invalid.push({
+                field: "objective_refinement",
+                expected: "a non-empty string",
+            });
+        }
+        else if (refinement.length > OBJECTIVE_REFINEMENT_MAX) {
+            invalid.push({
+                field: "objective_refinement",
+                expected: `a string of at most ${OBJECTIVE_REFINEMENT_MAX} chars`,
+            });
+        }
+    }
     return { missing, invalid };
 }
 /** v3.7.1: Strict structural checks for the sub-goal protocol fields
  *  (subgoal_updates / emerged_subtasks). Runs in the same pre-advance
  *  evaluation_invalid boundary as the four core fields: an error here is a
  *  payload defect, never a work-quality rejection — no session state, no
- *  gates, no rejection counters, retry with the same roundId.
+ *  gates, no rejection counters, retry with the same submissionHandle.
  *
  *  Shape-only (no vault): entry shape, id pattern, status enum, caps, and
  *  the sg-XXXXXXXX creation prohibition on emerged_subtasks. Referential
@@ -606,47 +515,51 @@ export function validateSubGoalUpdatesShape(raw) {
     });
     return errors;
 }
-const SUBGOAL_ID_RE = /^sg-[a-f0-9]{8}$/;
-/** v3.8: `scope` is the round's declared file boundary, so containment is a
- *  trust boundary like every other workspace path — a declaration that names
- *  `/etc` or `../outside` is rejected, not silently normalized into a string
- *  the drift check can never match. */
-function validateContractScope(scope, checkScopeEntry, errors) {
-    if (scope === undefined)
-        return;
-    if (!Array.isArray(scope)) {
-        errors.push({
-            field: "round_contract",
-            reason: "invalid_scope",
-            detail: "scope must be an array of workspace-relative paths",
-        });
-        return;
+const CONTRACT_ID_RE = /^rc-[a-f0-9]{8}$/;
+export const CONTRACT_SUPERSEDE_REASON_MAX = 500;
+function declaresBlockedRaw(raw) {
+    return raw.outcome === "blocked";
+}
+/** v4.0.6: LENIENT parser for the `supersedes` modifier inside a committed
+ *  Round Contract proposal. Historical/externally written data produces a
+ *  diagnostic and is dropped; it never closes a contract and never throws.
+ *  The strict submission boundary is the only commit check. */
+export function parseContractSupersede(raw, sink, path = "round_contract.supersedes") {
+    if (raw === undefined)
+        return undefined;
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+        sink?.push(path, "invalid_entry", "dropped", "expected a { contract_id, reason? } object; the value was dropped");
+        return undefined;
     }
-    if (scope.length > CONTRACT_LIMITS.scope) {
-        errors.push({
-            field: "round_contract",
-            reason: "too_many_scope_entries",
-            detail: `scope may list at most ${CONTRACT_LIMITS.scope} entries (got ${scope.length})`,
-        });
+    const obj = raw;
+    for (const key of Object.keys(obj)) {
+        if (key !== "contract_id" && key !== "reason") {
+            sink?.push(`${path}.${key}`, "unknown_field", "dropped", "not a declared supersedes field; it was dropped");
+        }
     }
-    scope.forEach((entry, index) => {
-        if (typeof entry !== "string" || entry.trim().length === 0) {
-            errors.push({
-                field: "round_contract",
-                reason: "invalid_scope_entry",
-                detail: `scope entry ${index} must be a non-empty string`,
-            });
-            return;
+    if (typeof obj.contract_id !== "string" ||
+        !CONTRACT_ID_RE.test(obj.contract_id.trim())) {
+        sink?.push(path, "invalid_id", "dropped", "contract_id must be an rc-XXXXXXXX id; the redirect was dropped");
+        return undefined;
+    }
+    const contractId = obj.contract_id.trim();
+    let reason;
+    if (obj.reason !== undefined) {
+        if (typeof obj.reason !== "string") {
+            sink?.push(`${path}.reason`, "invalid_value", "dropped", "expected a string; the reason was dropped");
         }
-        const detail = checkScopeEntry(entry.trim());
-        if (detail) {
-            errors.push({
-                field: "round_contract",
-                reason: "scope_outside_workspace",
-                detail: `scope entry ${index} "${entry.trim()}" ${detail}`,
-            });
+        else if (obj.reason.length > CONTRACT_SUPERSEDE_REASON_MAX) {
+            sink?.push(`${path}.reason`, "truncated", "truncated", `longer than ${CONTRACT_SUPERSEDE_REASON_MAX} chars; truncated to the limit`);
+            reason = obj.reason.slice(0, CONTRACT_SUPERSEDE_REASON_MAX);
         }
-    });
+        else {
+            reason = obj.reason;
+        }
+    }
+    return {
+        contract_id: contractId,
+        ...(reason !== undefined ? { reason } : {}),
+    };
 }
 function validateContractItem(item, index, context, errors) {
     if (typeof item !== "object" || item === null || Array.isArray(item)) {
@@ -658,6 +571,15 @@ function validateContractItem(item, index, context, errors) {
         return;
     }
     const entry = item;
+    for (const key of Object.keys(entry)) {
+        if (!["description", "criterion_refs", "verify_with"].includes(key)) {
+            errors.push({
+                field: "round_contract",
+                reason: "unknown_field",
+                detail: `item ${index} has unknown field "${key}"`,
+            });
+        }
+    }
     if (typeof entry.description !== "string" || entry.description.trim().length === 0) {
         errors.push({
             field: "round_contract",
@@ -665,6 +587,14 @@ function validateContractItem(item, index, context, errors) {
             detail: `item ${index} needs a non-empty description`,
         });
     }
+    else if (entry.description.trim().length > CONTRACT_LIMITS.itemDescription) {
+        errors.push({
+            field: "round_contract",
+            reason: "item_description_too_long",
+            detail: `item ${index} description may be at most ` +
+                `${CONTRACT_LIMITS.itemDescription} chars`,
+        });
+    }
     const verifyWith = entry.verify_with;
     if (!Array.isArray(verifyWith) || verifyWith.length === 0) {
         errors.push({
@@ -711,62 +641,155 @@ function validateContractItem(item, index, context, errors) {
                         `${CONTRACT_LIMITS.criterionRefs} ids (got ${criterionRefs.length})`,
                 });
             }
+            const seen = new Set();
             criterionRefs.forEach((ref, refIndex) => {
-                if (typeof ref !== "string" || ref.trim().length === 0) {
+                if (typeof ref !== "string" || !isCriterionId(ref.trim())) {
                     errors.push({
                         field: "round_contract",
                         reason: "invalid_criterion_ref",
-                        detail: `item ${index} criterion_refs entry ${refIndex} must be a non-empty string`,
+                        detail: `item ${index} criterion_refs entry ${refIndex} must be a cr-XXXXXXXX id`,
                     });
-                }
-            });
-        }
-    }
-    const subgoalRefs = entry.subgoal_refs;
-    if (subgoalRefs !== undefined) {
-        if (!Array.isArray(subgoalRefs)) {
-            errors.push({
-                field: "round_contract",
-                reason: "invalid_subgoal_refs",
-                detail: `item ${index} subgoal_refs must be an array of sg-XXXXXXXX ids`,
-            });
-        }
-        else {
-            if (subgoalRefs.length > CONTRACT_LIMITS.subgoalRefs) {
-                errors.push({
-                    field: "round_contract",
-                    reason: "too_many_subgoal_refs",
-                    detail: `item ${index} subgoal_refs may list at most ` +
-                        `${CONTRACT_LIMITS.subgoalRefs} ids (got ${subgoalRefs.length})`,
-                });
-            }
-            const seen = new Set();
-            for (const ref of subgoalRefs) {
-                if (typeof ref !== "string" || !SUBGOAL_ID_RE.test(ref.trim())) {
-                    errors.push({
-                        field: "round_contract",
-                        reason: "invalid_subgoal_ref",
-                        detail: `item ${index} subgoal_refs entry "${String(ref)}" must be an sg-XXXXXXXX id`,
-                    });
-                    continue;
+                    return;
                 }
                 const id = ref.trim();
                 if (seen.has(id)) {
                     errors.push({
                         field: "round_contract",
-                        reason: "duplicate_subgoal_ref",
-                        detail: `item ${index} subgoal_refs repeats ${id}`,
+                        reason: "duplicate_criterion_ref",
+                        detail: `item ${index} criterion_refs repeats ${id}`,
                     });
                 }
                 seen.add(id);
-                if (context.knownSubGoalIds && !context.knownSubGoalIds.has(id)) {
+                if (context.knownCriterionIds && !context.knownCriterionIds.has(id)) {
                     errors.push({
                         field: "round_contract",
-                        reason: "unknown_subgoal_ref",
-                        detail: `item ${index} references ${id}, which is not a sub-goal of this loop`,
+                        reason: "unknown_criterion_ref",
+                        detail: `item ${index} references ${id}, which is not an active criterion of this loop`,
                     });
                 }
-            }
+            });
+        }
+    }
+}
+/** v3.9.4: the normalized content identity of a RAW proposal item. Malformed
+ *  items return null (their own shape errors already fire); valid items use
+ *  the same canonical text as `deriveContractItemIds`. */
+function rawContractItemIdentity(item) {
+    if (typeof item !== "object" || item === null || Array.isArray(item))
+        return null;
+    const entry = item;
+    const strings = (value) => Array.isArray(value) ? value.filter((v) => typeof v === "string") : [];
+    return canonicalContractItemText({
+        description: typeof entry.description === "string" ? entry.description : "",
+        criterion_refs: strings(entry.criterion_refs),
+        verify_with: strings(entry.verify_with),
+    });
+}
+/** v4.0.6: strict `round_contract.supersedes` boundary. Every failure is
+ *  `contract_invalid`; the same submissionHandle may retry with a corrected
+ *  payload. The rules migrated from the former standalone
+ *  `contract_transition` field:
+ *  - the target must exist and equal the ACTIVE contract id;
+ *  - the successor (this same proposal) must carry different acceptance items;
+ *  - a redirect cannot be combined with a blocked outcome or a stop.
+ *  `scope`/`work_item` differences alone are not a new slice. */
+function validateContractSupersede(raw, proposal, context, errors) {
+    const value = proposal.supersedes;
+    if (value === undefined)
+        return;
+    const field = "round_contract.supersedes";
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        errors.push({
+            field,
+            reason: "not_object",
+            detail: "round_contract.supersedes must be a { contract_id, reason? } object",
+        });
+        return;
+    }
+    const obj = value;
+    for (const key of Object.keys(obj)) {
+        if (key !== "contract_id" && key !== "reason") {
+            errors.push({
+                field,
+                reason: "unknown_field",
+                detail: `round_contract.supersedes has unknown field "${key}"`,
+            });
+        }
+    }
+    const contractId = typeof obj.contract_id === "string"
+        ? obj.contract_id.trim()
+        : "";
+    if (!CONTRACT_ID_RE.test(contractId)) {
+        errors.push({
+            field,
+            reason: "invalid_contract_id",
+            detail: "round_contract.supersedes.contract_id must be an rc-XXXXXXXX id",
+        });
+    }
+    if (obj.reason !== undefined &&
+        (typeof obj.reason !== "string" ||
+            obj.reason.length > CONTRACT_SUPERSEDE_REASON_MAX)) {
+        errors.push({
+            field,
+            reason: "invalid_reason",
+            detail: `round_contract.supersedes.reason must be a string of at most ` +
+                `${CONTRACT_SUPERSEDE_REASON_MAX} chars`,
+        });
+    }
+    if (declaresBlockedRaw(raw)) {
+        errors.push({
+            field,
+            reason: "supersede_conflicts_with_blocked",
+            detail: "a contract redirect cannot be combined with a blocked outcome",
+        });
+    }
+    if (raw.should_continue === false) {
+        errors.push({
+            field,
+            reason: "supersede_on_stop",
+            detail: "a contract redirect activates a successor next round; it cannot be submitted with should_continue=false",
+        });
+    }
+    if (context.observed === false)
+        return;
+    if (context.activeContractId === undefined)
+        return;
+    if (context.activeContractId === null) {
+        errors.push({
+            field,
+            reason: "no_active_contract",
+            detail: "there is no active contract to supersede",
+        });
+        return;
+    }
+    if (contractId !== context.activeContractId) {
+        errors.push({
+            field,
+            reason: "supersede_target_mismatch",
+            detail: `round_contract.supersedes.contract_id must equal the active contract ` +
+                `(${context.activeContractId})`,
+        });
+    }
+    // "Substantive change" means the ACCEPTANCE CONTENT changed. A new
+    // work_item/scope label alone is not a new slice.
+    const activeIdentities = context.activeItemIdentities;
+    const rawItems = proposal.items;
+    if (activeIdentities && Array.isArray(rawItems)) {
+        const identities = new Set();
+        for (const item of rawItems) {
+            const identity = rawContractItemIdentity(item);
+            if (identity !== null)
+                identities.add(identity);
+        }
+        if (identities.size > 0 &&
+            identities.size === activeIdentities.size &&
+            [...identities].every((identity) => activeIdentities.has(identity))) {
+            errors.push({
+                field,
+                reason: "supersede_without_change",
+                detail: "the successor's acceptance items are identical to the active " +
+                    "contract's; changing only work_item/scope is not a new slice",
+            });
         }
     }
 }
@@ -774,13 +797,14 @@ function validateContractItem(item, index, context, errors) {
  *  the contract item claims — the same pre-advance contract as
  *  subgoal_updates: an error here is a payload defect, never a work-quality
  *  rejection (no session state, no gates, no rejection counters, retry with
- *  the same roundId as `contract_invalid`).
+ *  the same submissionHandle as `contract_invalid`).
  *
  *  Declaration strictness: items must exist and stay within CONTRACT_LIMITS;
  *  every item must bind at least one configured, enabled, after-capable
- *  command; scope entries must stay inside the workspace; criterion and
- *  sub-goal references must be well-formed, and sub-goal references must name
- *  a sub-goal that actually exists. The limits are enforced HERE rather than
+ *  command; criterion and sub-goal references must be well-formed, and
+ *  sub-goal references must name a sub-goal that actually exists. `scope` is
+ *  deliberately NOT part of this boundary (v3.9.9): it is optional,
+ *  report-only intent and is normalized leniently. The limits are enforced HERE rather than
  *  by silently truncating in the lenient parser — a declaration is a
  *  boundary, not a suggestion.
  *
@@ -799,7 +823,47 @@ export function validateContractShape(raw, context) {
         }
         else {
             const obj = contract;
-            validateContractScope(obj.scope, context.checkScopeEntry, errors);
+            for (const key of Object.keys(obj)) {
+                if (!["work_item", "scope", "supersedes", "items"].includes(key)) {
+                    errors.push({
+                        field: "round_contract",
+                        reason: "unknown_field",
+                        detail: `round_contract has unknown field "${key}"`,
+                    });
+                }
+            }
+            if (obj.work_item === undefined) {
+                errors.push({
+                    field: "round_contract",
+                    reason: "missing_work_item",
+                    detail: "a contract must name the deliverable in work_item",
+                });
+            }
+            else if (typeof obj.work_item !== "string") {
+                errors.push({
+                    field: "round_contract",
+                    reason: "invalid_work_item",
+                    detail: "work_item must be a string",
+                });
+            }
+            else if (obj.work_item.trim().length === 0) {
+                errors.push({
+                    field: "round_contract",
+                    reason: "empty_work_item",
+                    detail: "work_item must not be empty",
+                });
+            }
+            else if (obj.work_item.trim().length > CONTRACT_LIMITS.workItem) {
+                errors.push({
+                    field: "round_contract",
+                    reason: "work_item_too_long",
+                    detail: `work_item may be at most ${CONTRACT_LIMITS.workItem} chars`,
+                });
+            }
+            // v3.9.9: `scope` is optional, report-only intent. It is normalized
+            // leniently by parseRoundContract (trim, cap, drop non-strings) and no
+            // longer participates in this strict boundary — no required key, no
+            // workspace containment, no whole-contract rejection.
             const items = obj.items;
             if (!Array.isArray(items) || items.length === 0) {
                 errors.push({
@@ -816,21 +880,42 @@ export function validateContractShape(raw, context) {
                 });
             }
             else {
+                const seenItems = new Map();
                 items.forEach((item, index) => {
                     validateContractItem(item, index, context, errors);
+                    // v3.9.4: two identical normalized items would derive two rci- ids
+                    // for one semantic object. Reject the restatement instead of
+                    // letting a citation become ambiguous.
+                    const identity = rawContractItemIdentity(item);
+                    if (identity === null)
+                        return;
+                    const first = seenItems.get(identity);
+                    if (first !== undefined) {
+                        errors.push({
+                            field: "round_contract",
+                            reason: "duplicate_contract_item",
+                            detail: `item ${index} duplicates item ${first} by normalized content`,
+                        });
+                        return;
+                    }
+                    seenItems.set(identity, index);
                 });
             }
+            validateContractSupersede(raw, obj, context, errors);
         }
     }
+    // v4.0.6: `execution_report.claims` is the ONE claims channel. Only `rci-`
+    // entries are STRICT here (format, uniqueness, ACTIVE item membership);
+    // `cr-` entries stay advisory and are normalized by the lenient parser.
     const report = raw.execution_report;
     if (typeof report === "object" && report !== null && !Array.isArray(report)) {
-        const claims = report.contract_item_claims;
+        const claims = report.claims;
         if (claims !== undefined) {
             if (!Array.isArray(claims)) {
                 errors.push({
-                    field: "execution_report.contract_item_claims",
+                    field: "execution_report.claims",
                     reason: "not_array",
-                    detail: "contract_item_claims must be an array of { item_id, outcome } entries",
+                    detail: "execution_report.claims must be an array of { id, outcome } entries",
                 });
             }
             else {
@@ -838,41 +923,44 @@ export function validateContractShape(raw, context) {
                 claims.forEach((claim, index) => {
                     if (typeof claim !== "object" || claim === null || Array.isArray(claim)) {
                         errors.push({
-                            field: "execution_report.contract_item_claims",
+                            field: "execution_report.claims",
                             reason: "invalid_entry",
                             detail: `entry ${index} is not an object`,
                         });
                         return;
                     }
                     const entry = claim;
-                    const id = typeof entry.item_id === "string" ? entry.item_id.trim() : "";
-                    if (!/^rci-[a-f0-9]{8}$/.test(id)) {
-                        errors.push({
-                            field: "execution_report.contract_item_claims",
-                            reason: "invalid_item_id",
-                            detail: `entry ${index} must reference an rci-XXXXXXXX contract item id`,
-                        });
-                    }
-                    else {
-                        if (seen.has(id)) {
+                    const rawId = typeof entry.id === "string" ? entry.id.trim() : "";
+                    const strictItem = rawId.startsWith("rci-");
+                    if (strictItem) {
+                        if (!/^rci-[a-f0-9]{8}$/.test(rawId)) {
                             errors.push({
-                                field: "execution_report.contract_item_claims",
-                                reason: "duplicate_item_id",
-                                detail: `entry ${index} repeats item id ${id}`,
+                                field: "execution_report.claims",
+                                reason: "invalid_item_id",
+                                detail: `entry ${index} must reference an rci-XXXXXXXX contract item id`,
                             });
                         }
-                        seen.add(id);
-                        if (context.activeItemIds && !context.activeItemIds.has(id)) {
-                            errors.push({
-                                field: "execution_report.contract_item_claims",
-                                reason: "unknown_item_id",
-                                detail: `entry ${index} references ${id}, which is not an item of the ACTIVE contract`,
-                            });
+                        else {
+                            if (seen.has(rawId)) {
+                                errors.push({
+                                    field: "execution_report.claims",
+                                    reason: "duplicate_item_id",
+                                    detail: `entry ${index} repeats item id ${rawId}`,
+                                });
+                            }
+                            seen.add(rawId);
+                            if (context.activeItemIds && !context.activeItemIds.has(rawId)) {
+                                errors.push({
+                                    field: "execution_report.claims",
+                                    reason: "unknown_item_id",
+                                    detail: `entry ${index} references ${rawId}, which is not an item of the ACTIVE contract`,
+                                });
+                            }
                         }
                     }
                     if (entry.outcome !== "met" && entry.outcome !== "remaining") {
                         errors.push({
-                            field: "execution_report.contract_item_claims",
+                            field: "execution_report.claims",
                             reason: "invalid_outcome",
                             detail: `entry ${index} outcome must be "met" or "remaining"`,
                         });
@@ -891,12 +979,18 @@ export function validateContractShape(raw, context) {
 export function buildSelfEvaluation(raw, sink, facts) {
     const executionReport = parseExecutionReport(raw.execution_report, sink, facts?.knownCriterionRefs);
     const retractedConstraints = boundedStringArray(raw.retracted_constraints, 50, 500, sink, "retracted_constraints");
-    const revisedCriteria = parseCriterionRevisions(raw.revised_success_criteria, sink);
     const wrongAssumptions = boundedStringArray(raw.wrong_assumptions, 50, 500, sink, "wrong_assumptions");
+    // v4.0.2: strictly report-only. The window/caps are the field's contract,
+    // not policy: at most 3 entries, 300 chars each.
+    const openQuestions = boundedStringArray(raw.open_questions, 3, 300, sink, "open_questions");
+    const resolvedOpenQuestionIds = boundedStringArray(raw.resolved_open_question_ids, 20, 80, sink, "resolved_open_question_ids")
+        .filter((value) => {
+        if (isOpenQuestionId(value))
+            return true;
+        sink?.push("resolved_open_question_ids", "invalid_value", "dropped", `invalid open-question id: ${value}`);
+        return false;
+    });
     const workerResults = parseWorkerResults(raw.worker_results, sink);
-    if (raw.success !== undefined && typeof raw.success !== "boolean") {
-        sink?.push("success", "invalid_value", "dropped", "expected a boolean; normalized to false (core validation rejects it)");
-    }
     if (raw.output_summary !== undefined && typeof raw.output_summary !== "string") {
         sink?.push("output_summary", "invalid_value", "dropped", "expected a string; normalized to the empty string (core validation rejects it)");
     }
@@ -919,29 +1013,38 @@ export function buildSelfEvaluation(raw, sink, facts) {
     if (raw.should_continue !== undefined && typeof raw.should_continue !== "boolean") {
         sink?.push("should_continue", "invalid_value", "dropped", "expected a boolean; normalized to true (core validation rejects it)");
     }
-    if (raw.stop_reason !== undefined &&
-        raw.stop_reason !== "gave_up" && raw.stop_reason !== "blocked" &&
-        raw.stop_reason !== "needs_human_input") {
-        sink?.push("stop_reason", "invalid_enum", "dropped", "expected gave_up | blocked | needs_human_input; the value was dropped");
-    }
     if (raw.outcome !== undefined &&
         raw.outcome !== "success" && raw.outcome !== "partial" &&
         raw.outcome !== "failed" && raw.outcome !== "blocked") {
-        sink?.push("outcome", "invalid_enum", "dropped", "expected success | partial | failed | blocked; the value was dropped");
+        sink?.push("outcome", "invalid_enum", "dropped", "expected success | partial | failed | blocked; the value was dropped (core validation rejects it)");
+    }
+    if (raw.objective_refinement !== undefined) {
+        if (typeof raw.objective_refinement !== "string") {
+            sink?.push("objective_refinement", "invalid_value", "dropped", "expected a string; the value was dropped (core validation rejects it)");
+        }
+        else if (raw.objective_refinement.trim().length === 0) {
+            sink?.push("objective_refinement", DIAG_EMPTY_VALUE, "dropped", "empty objective_refinement was dropped (core validation rejects it)");
+        }
+        else if (raw.objective_refinement.length > OBJECTIVE_REFINEMENT_MAX) {
+            sink?.push("objective_refinement", "truncated", "truncated", `longer than ${OBJECTIVE_REFINEMENT_MAX} chars; truncated to the limit (core validation rejects it)`);
+        }
     }
-    if (raw.compression_checkpoint !== undefined &&
-        typeof raw.compression_checkpoint !== "boolean") {
-        sink?.push("compression_checkpoint", "invalid_value", "dropped", "expected a boolean; normalized to false");
+    if (raw.subtask_boundary !== undefined &&
+        typeof raw.subtask_boundary !== "boolean") {
+        sink?.push("subtask_boundary", "invalid_value", "dropped", "expected a boolean; normalized to false");
     }
     if (raw.blocker !== undefined) {
-        if (typeof raw.blocker !== "string") {
-            sink?.push("blocker", "invalid_value", "dropped", "expected a string; the value was dropped");
+        if (raw.outcome !== "blocked") {
+            sink?.push("blocker", "not_applicable", "dropped", `blocker is meaningful only when outcome=blocked (outcome=${typeof raw.outcome === "string" ? raw.outcome : "missing"}); the value was dropped`);
+        }
+        else if (typeof raw.blocker !== "string") {
+            sink?.push("blocker", "invalid_value", "dropped", "expected a string; the value was dropped (core validation rejects it)");
         }
         else if (raw.blocker.trim().length === 0) {
-            sink?.push("blocker", DIAG_EMPTY_VALUE, "dropped", "empty blocker was dropped");
+            sink?.push("blocker", DIAG_EMPTY_VALUE, "dropped", "empty blocker was dropped (core validation rejects it)");
         }
-        else if (raw.blocker.length > 500) {
-            sink?.push("blocker", "truncated", "truncated", "longer than 500 chars; truncated to the limit");
+        else if (raw.blocker.length > BLOCKER_MAX) {
+            sink?.push("blocker", "truncated", "truncated", `longer than ${BLOCKER_MAX} chars; truncated to the limit (core validation rejects it)`);
         }
     }
     const noChangeReason = boundedString(raw.no_change_reason, 200, sink, "no_change_reason");
@@ -949,35 +1052,35 @@ export function buildSelfEvaluation(raw, sink, facts) {
         sink?.push("no_change_reason", DIAG_EMPTY_VALUE, "dropped", "empty reason was dropped");
     }
     return makeSelfEvaluation({
-        success: typeof raw.success === "boolean" ? raw.success : false,
+        outcome: raw.outcome === "success" || raw.outcome === "partial" ||
+            raw.outcome === "failed" || raw.outcome === "blocked"
+            ? raw.outcome
+            : "failed",
         output_summary: typeof raw.output_summary === "string" ? raw.output_summary : "",
         constraint_violations: constraintViolations,
         should_continue: typeof raw.should_continue === "boolean" ? raw.should_continue : true,
-        discovered_constraints: boundedStringArray(raw.discovered_constraints, 50, 500, sink, "discovered_constraints"),
-        objective_refinement: boundedString(raw.objective_refinement, 1000, sink, "objective_refinement") ?? "",
+        discovered_constraints: boundedStringArray(raw.discovered_constraints, facts?.maxDiscoveredConstraints ?? 50, 500, sink, "discovered_constraints"),
         emerged_subtasks: boundedEmergedSubtasks(raw.emerged_subtasks, sink),
         execution_report: executionReport,
         retracted_constraints: retractedConstraints,
-        revised_success_criteria: revisedCriteria,
         wrong_assumptions: wrongAssumptions,
+        open_questions: openQuestions,
+        resolved_open_question_ids: resolvedOpenQuestionIds,
         worker_results: workerResults,
-        compression_checkpoint: typeof raw.compression_checkpoint === "boolean" ? raw.compression_checkpoint : false,
-        checkpoint_label: boundedString(raw.checkpoint_label, 200, sink, "checkpoint_label") ?? "",
+        subtask_boundary: typeof raw.subtask_boundary === "boolean" ? raw.subtask_boundary : false,
+        subtask_boundary_label: boundedString(raw.subtask_boundary_label, 200, sink, "subtask_boundary_label") ?? "",
         subgoal_updates: parseSubGoalUpdates(raw.subgoal_updates, sink),
-        stop_reason: raw.stop_reason === "gave_up" || raw.stop_reason === "blocked" || raw.stop_reason === "needs_human_input"
-            ? raw.stop_reason
-            : undefined,
-        outcome: raw.outcome === "success" || raw.outcome === "partial" ||
-            raw.outcome === "failed" || raw.outcome === "blocked"
-            ? raw.outcome
+        objective_refinement: typeof raw.objective_refinement === "string" &&
+            raw.objective_refinement.trim().length > 0
+            ? raw.objective_refinement.trim().slice(0, OBJECTIVE_REFINEMENT_MAX)
             : undefined,
-        blocker: typeof raw.blocker === "string" && raw.blocker.trim().length > 0
-            ? raw.blocker.slice(0, 500)
+        blocker: raw.outcome === "blocked" &&
+            typeof raw.blocker === "string" && raw.blocker.trim().length > 0
+            ? raw.blocker.slice(0, BLOCKER_MAX)
             : undefined,
         gate_ids: boundedStringArray(raw.gate_ids, 20, 64, sink, "gate_ids"),
         retroactiveClaims: parseRetroactiveClaims(raw.retroactiveClaims, sink),
         no_change_reason: noChangeReason || undefined,
-        prompt_requests: parsePromptRequests(raw.prompt_requests, sink),
         round_contract: parseRoundContract(raw.round_contract, sink),
     });
 }
@@ -1000,10 +1103,11 @@ export function normalizeSelfEvaluation(raw, facts) {
  *  (the lenient path, reached only after the strict boundary passed) truncates
  *  to the same numbers. One source, so the two can never drift. */
 export const CONTRACT_LIMITS = {
+    workItem: 200,
+    itemDescription: 200,
     items: 20,
     scope: 50,
     criterionRefs: 20,
-    subgoalRefs: 20,
     verifyWith: 20,
 };
 /** Parse a Round Contract PROPOSAL from raw JSON input. Lenient on shapes
@@ -1024,7 +1128,7 @@ export function parseRoundContract(raw, sink) {
     }
     const obj = raw;
     for (const key of Object.keys(obj)) {
-        if (!["work_item", "scope", "items"].includes(key)) {
+        if (!["work_item", "scope", "supersedes", "items"].includes(key)) {
             sink?.push(`round_contract.${key}`, "unknown_field", "dropped", "not a declared contract field; it was dropped");
         }
     }
@@ -1074,7 +1178,7 @@ export function parseRoundContract(raw, sink) {
         .slice(0, CONTRACT_LIMITS.items)
         .map((item, index) => {
         for (const key of Object.keys(item)) {
-            if (!["description", "criterion_refs", "subgoal_refs", "verify_with"].includes(key)) {
+            if (!["description", "criterion_refs", "verify_with"].includes(key)) {
                 sink?.push(`round_contract.items[${index}].${key}`, "unknown_field", "dropped", "not a declared contract-item field; it was dropped");
             }
         }
@@ -1082,15 +1186,14 @@ export function parseRoundContract(raw, sink) {
             sink?.push(`round_contract.items[${index}].description`, "invalid_value", "dropped", "expected a string; the description was dropped");
         }
         if (typeof item.description === "string" &&
-            item.description.trim().length > 200) {
-            sink?.push(`round_contract.items[${index}].description`, "truncated", "truncated", "longer than 200 chars; truncated to the limit");
+            item.description.trim().length > CONTRACT_LIMITS.itemDescription) {
+            sink?.push(`round_contract.items[${index}].description`, "truncated", "truncated", `longer than ${CONTRACT_LIMITS.itemDescription} chars; truncated to the limit`);
         }
         return {
             description: typeof item.description === "string"
-                ? item.description.trim().slice(0, 200)
+                ? item.description.trim().slice(0, CONTRACT_LIMITS.itemDescription)
                 : "",
             criterion_refs: capStrings(item.criterion_refs, 200, CONTRACT_LIMITS.criterionRefs, `round_contract.items[${index}].criterion_refs`),
-            subgoal_refs: capStrings(item.subgoal_refs, 64, CONTRACT_LIMITS.subgoalRefs, `round_contract.items[${index}].subgoal_refs`),
             verify_with: capStrings(item.verify_with, 200, CONTRACT_LIMITS.verifyWith, `round_contract.items[${index}].verify_with`),
         };
     });
@@ -1107,52 +1210,20 @@ export function parseRoundContract(raw, sink) {
     else if (typeof obj.work_item === "string" && obj.work_item.trim().length === 0) {
         sink?.push("round_contract.work_item", DIAG_EMPTY_VALUE, "dropped", "empty work_item was dropped");
     }
-    else if (typeof obj.work_item === "string" && obj.work_item.trim().length > 200) {
-        sink?.push("round_contract.work_item", "truncated", "truncated", "longer than 200 chars; truncated to the limit");
+    else if (typeof obj.work_item === "string" &&
+        obj.work_item.trim().length > CONTRACT_LIMITS.workItem) {
+        sink?.push("round_contract.work_item", "truncated", "truncated", `longer than ${CONTRACT_LIMITS.workItem} chars; truncated to the limit`);
     }
+    const supersedes = parseContractSupersede(obj.supersedes, sink);
     return {
         work_item: typeof obj.work_item === "string" && obj.work_item.trim().length > 0
-            ? obj.work_item.trim().slice(0, 200)
+            ? obj.work_item.trim().slice(0, CONTRACT_LIMITS.workItem)
             : undefined,
         scope: capStrings(obj.scope, 500, CONTRACT_LIMITS.scope, "round_contract.scope"),
+        ...(supersedes !== undefined ? { supersedes } : {}),
         items,
     };
 }
-/** Parse a PromptRequests object from raw JSON input.
- *  Lenient: missing or invalid fields get sensible defaults.
- *  Returns undefined if the raw value is absent or not an object,
- *  so makeSelfEvaluation can distinguish "not set" from "empty".
- *  Exported for the engine's last_round_result rebuild — the MCP
- *  lifecycle assembles prompt_requests into the request, but every
- *  compile path funnels through engine.invokeLoopCompile, whose
- *  field-by-field reconstruction must preserve them (v3.3.1). */
-export function parsePromptRequests(raw, sink) {
-    if (raw === undefined)
-        return undefined;
-    if (raw === null) {
-        sink?.push("prompt_requests", "invalid_value", "dropped", "expected an object with emphasize/confusion_points; null was dropped");
-        return undefined;
-    }
-    if (typeof raw !== "object" || Array.isArray(raw)) {
-        sink?.push("prompt_requests", "invalid_entry", "dropped", "expected an object with emphasize/confusion_points; the value was dropped");
-        return undefined;
-    }
-    const obj = raw;
-    for (const key of Object.keys(obj)) {
-        if (key !== "emphasize" && key !== "confusion_points") {
-            sink?.push(`prompt_requests.${key}`, "unknown_field", "dropped", "not a declared prompt-request field; it was dropped");
-        }
-    }
-    const emphasize = boundedStringArray(obj.emphasize, 5, 500, sink, "prompt_requests.emphasize");
-    const confusionPoints = boundedStringArray(obj.confusion_points, 3, 200, sink, "prompt_requests.confusion_points");
-    // Return undefined when all fields are empty — semantically equivalent
-    // to "not set", avoids carrying an empty object through the pipeline.
-    if (emphasize.length === 0 && confusionPoints.length === 0) {
-        sink?.push("prompt_requests", DIAG_EMPTY_VALUE, "dropped", "emphasize and confusion_points are both empty; treated as not set");
-        return undefined;
-    }
-    return { emphasize, confusion_points: confusionPoints };
-}
 // Free-text inference is intentionally absent. Invalid core fields are
 // rejected before round advancement and may be resubmitted with the same
 // roundId without changing session, gate, metric, or vault state.