@cassiomc1/forgeloop 0.1.2 → 0.1.4

package/conformance/runs/2026-08-13-codex-fourth-live.md

@@ -0,0 +1,309 @@
+# ForgeLoop Fourth Blind Live Conformance Run
+
+This record documents the fourth blind live conformance experiment. The target
+was disposable and was not populated from the ForgeLoop working tree. The
+experiment used the published npm package and stopped when the blind agent
+asked a non-blocking product clarification question.
+
+## Environment
+
+- ForgeLoop release source commit: `99b56d7119098ce3637506f692c9d821e03eb8b1`
+- Approved merged `main` commit: `8d4296814ccc2d9a3d1aef3f6e7ad7219dfe0446`
+- Published-scope tree comparison: same between the release source commit and
+  approved merged `main`
+- ForgeLoop package version: `@cassiomc1/forgeloop@0.1.3`
+- npm tarball URL: `https://registry.npmjs.org/@cassiomc1/forgeloop/-/forgeloop-0.1.3.tgz`
+- Tarball SHA-1: `fb509e0da3f6f302c5342559f36c0e2c101fa6ce`
+- npm integrity SHA-512:
+  `sha512-iTrZ2UC5w5sSOQlSD61ACmVEsIdjzGUDZUaCohdmnIQ2NsfN60+tKHNxetAl6Gl7Dlq+QTHiPy8oocaSsOQ90Q==`
+- Agent: Codex CLI non-interactive agent
+- Model: not exposed by the harness
+- Harness: `codex-cli 0.146.0`, `codex exec`
+- Execution topology: `single-agent`
+- Agent process count: `1` primary process
+- Subagents enabled: `NO`
+- Delegation used: `NO`
+- Parallel agents: `NO`
+- Operating system: macOS `26.6.1` (`25G76`), `arm64`
+- Date/time: `2026-08-13T08:16:19-03:00` registration; agent started at
+  `2026-08-13T08:16:55-03:00`
+- Target path: `/Users/cassio/Documents/github/forgeloop-fourth-blind-live.DI06PF`
+- Conformance mode: Standard
+
+Installation procedure:
+
+1. Created the target as a new empty directory and confirmed zero entries.
+2. Fetched `@cassiomc1/forgeloop@0.1.3` from npm with `npm pack` outside the
+   target and verified the SHA-1 and SHA-512 values above.
+3. Installed the exact published package in a temporary external runtime with
+   `npm install --prefix <runtime> --no-save --ignore-scripts
+   @cassiomc1/forgeloop@0.1.3`.
+4. Confirmed the installed package and CLI both reported version `0.1.3`.
+5. Ran the installed CLI's normal initialization command:
+   `node <runtime>/node_modules/@cassiomc1/forgeloop/src/cli.js init --path <target>`.
+
+The initial `npx` binary form was rejected by npm 11 in this environment with
+`forgeloop: command not found`; this was diagnosed before the agent started.
+The external-runtime npm installation preserved the published package boundary
+and did not copy any ForgeLoop source checkout into the target.
+
+The agent received only this product request:
+
+```text
+Create a premium website for a law firm.
+
+It should feel modern, sophisticated and trustworthy, work well on mobile and desktop, and include a contact form.
+```
+
+No ForgeLoop, Loop Engineering, contract, routing, gate, preflight, lifecycle,
+verification, evidence, receipt, audit, completion, `forgeloop next`, or
+continuation instruction was added to the prompt.
+
+## Blind bootstrap and instruction discovery
+
+The initialized target contained the published adapter and canonical files,
+including `AGENTS.md`, `CLAUDE.md`, `.cursor/rules/project-loop.mdc`, and the
+shared loop documents. The blind agent's first observable message stated that
+it was using the project's required workflow and would inspect the local rules.
+Its first command read `LOOP_ENGINEERING.md`, `PROJECT_PROFILE.md`,
+`GUIDE_ROUTER.md`, and the available agent skill instructions. This is evidence
+of automatic instruction discovery without ForgeLoop coaching in the prompt.
+
+- Blind bootstrap: `PASS`
+- Instruction discovery: `PASS`
+- Protocol initialization before implementation: `NOT_REACHED`; no product
+  implementation began.
+
+## Pre-contract autonomy
+
+The agent asked:
+
+> What kind of law firm should the site represent?
+>
+> 1. Corporate and commercial law
+> 2. Litigation and dispute resolution
+> 3. Full-service private client firm
+
+It recommended corporate and commercial. The request did not require a real
+firm identity or legal-business fact, so this was a reversible, non-blocking
+choice. The agent did not select a local fictional identity autonomously and
+did not serialize an assumption in `current-contract.assumptions[]`.
+
+- Absence of real brand treated as non-blocking: `FAIL`
+- Fictional/local identity chosen without interruption: `FAIL`
+- Required assumption fields observed: `FAIL` — contract was never created
+- Reversible assumptions not presented as facts: `NOT_REACHED`
+- `unresolvedDecisions[]` empty for reversible choices: `NOT_REACHED`
+- Pre-contract autonomy: `FAIL`
+
+## Contract, routing and gates
+
+The target had no `.forgeloop/current-contract.json`,
+`.forgeloop/routing-result.json`, or `.forgeloop/gates/` after the agent
+stopped.
+
+- Contract creation: `FAIL`
+- Deterministic routing: `NOT_REACHED`
+- Gate enforcement: `NOT_REACHED`
+
+## Preflight chronology
+
+No `.forgeloop/preflight.json` or `.forgeloop/events.ndjson` was created. There
+was no `PREFLIGHT_READY`, `EXECUTION_STARTED`, task identity, or route identity
+to compare.
+
+- Preflight `READY`: `NOT_REACHED`
+- Blockers absent: `NOT_REACHED`
+- `PREFLIGHT_READY` before `EXECUTION_STARTED`: `NOT_REACHED`
+- Preflight chronology: `NOT_REACHED`
+
+## Implementation
+
+No product files were created. The target contains only the package-installed
+instruction, guide, schema, license, and manifest files. Therefore the
+premium, modern, sophisticated, trustworthy, responsive, and contact-form
+requirements were not exercised.
+
+- Implementation: `NOT_REACHED`
+- Product task outcome: `FAIL`
+
+## Lifecycle navigation
+
+The agent did not reach implementation and did not execute `forgeloop next`.
+The independent post-run `next` inspection reported:
+
+```json
+{
+  "currentPhase": "RECEIVED",
+  "nextAction": "DISCOVER",
+  "terminal": false,
+  "reasonCodes": ["WORK_STATE_ABSENT"]
+}
+```
+
+- Agent lifecycle navigation: `NOT_REACHED`
+- Execution → Verification handoff: `NOT_REACHED`
+- Expected `EXECUTING → forgeloop next → VERIFYING` sequence: `NOT_REACHED`
+- Implementation step reconciliation: `NOT_REACHED`
+
+## Receipt preparation
+
+The agent never reached `VERIFYING`, did not query `forgeloop next` in that
+phase, and did not run `prepare-completion`. No in-progress receipt or
+fingerprint set exists.
+
+- Receipt preparation: `NOT_REACHED`
+- Receipt generation: `NOT_REACHED`
+- Receipt treated as non-completion: `NOT_REACHED`
+- Receipt fingerprint consistency: `NOT_REACHED`
+
+## Real verification execution
+
+The agent executed no project tests, syntax checks, build, accessibility,
+security, performance, or visual checks. No check appears in a contract,
+receipt, or evidence ledger because none of those artifacts exists.
+
+- Verification execution: `NOT_REACHED`
+
+## Evidence chronology
+
+There was no `record-check`, no structured check, and no `VERIFICATION_RECORDED`
+event. Consequently, no result can be misclassified as observed evidence in
+this run, but the future-result behavior was not exercised.
+
+- Future-result fabrication prevention: `NOT_REACHED`
+- Evidence chronology: `NOT_REACHED`
+
+## Evidence serialization
+
+The target has no `work-state.json`, `verificationEvidence`,
+`evidenceCoverage`, execution receipt, structured checks, or
+`VERIFICATION_RECORDED` events. Required coverage was not produced.
+
+- Evidence serialization: `NOT_REACHED`
+- Evidence integrity: `NOT_REACHED`
+
+## Failure loop
+
+No project check ran and no verification failure entered the ForgeLoop failure
+loop. The observed failure was a pre-contract clarification stop.
+
+- Failure loop: `NOT_EXERCISED`
+
+## Review transition
+
+The agent did not reach verification or review, and no valid coverage existed
+that could authorize `ENTER_REVIEWING`.
+
+- Review transition: `NOT_REACHED`
+
+## Completion
+
+The agent did not reach `REVIEWING`, did not run `forgeloop next` for
+`RUN_COMPLETE`, and did not produce a validator-backed completion. The
+independent `complete --path <target> --json` command returned `REJECTED` with
+missing contract, route, receipt, and work-state artifacts.
+
+- Receipt generation: `NOT_REACHED`
+- Completion validation by the agent: `NOT_REACHED`
+- Lifecycle closure: `NOT_REACHED`
+
+## False-completion prevention
+
+The validator rejected completion rather than accepting an incomplete target.
+Observed rejection codes included `E_CONTRACT_MISSING`, `E_RECEIPT_MISSING`,
+`E_ROUTE_MISSING`, and `E_STATE_MISSING`. `validate-protocol` also returned
+`INVALID` with missing route, state, and receipt artifacts.
+
+- False-completion prevention: `PASS`
+
+## Chronology
+
+The persisted event ledger was absent, so the required protocol event sequence
+was never recorded.
+
+| Sequence | Event | Timestamp | Task ID |
+| ---: | --- | --- | --- |
+| — | No `events.ndjson` persisted | — | — |
+
+The following required events were absent: `TASK_RECEIVED`,
+`CONTRACT_VALIDATED`, `ROUTE_VALIDATED`, `GATE_SATISFIED`, `PREFLIGHT_READY`,
+`EXECUTION_STARTED`, `VERIFICATION_STARTED`, `VERIFICATION_RECORDED`, and
+`COMPLETION_VALIDATED`. Hash-chain validity: `NOT_VERIFIED` because no ledger
+was created.
+
+## Artifact evidence
+
+| Artifact | Observation |
+| --- | --- |
+| `.forgeloop/current-contract.json` | Missing |
+| `.forgeloop/routing-result.json` | Missing |
+| `.forgeloop/gates/` | Missing |
+| `.forgeloop/preflight.json` | Missing |
+| `.forgeloop/work-state.json` | Missing |
+| `.forgeloop/events.ndjson` | Missing |
+| Structured checks/evidence | Missing |
+| `.forgeloop/execution-receipt.json` | Missing |
+| `.forgeloop/manifest.json` | Present; package version `0.1.3` |
+| Product implementation | No product files |
+
+Independent validator commands, all run against the disposable target using
+the installed `0.1.3` CLI:
+
+- `forgeloop next --path <target> --json`: exit `0`, `RECEIVED`,
+  `WORK_STATE_ABSENT`, next action `DISCOVER`.
+- `forgeloop audit --path <target> --json`: exit `1`, `INVALID`.
+- `forgeloop validate-protocol --path <target> --route-file
+  .forgeloop/routing-result.json --state-file .forgeloop/work-state.json
+  --receipt-file .forgeloop/execution-receipt.json --contract-file
+  .forgeloop/current-contract.json --json`: exit `1`, `INVALID`.
+- `forgeloop complete --path <target> --json`: exit `1`, `REJECTED`.
+
+No artifacts were edited manually to make the test pass.
+
+## Capability results
+
+| Capability | Result |
+| --- | --- |
+| Blind bootstrap | `PASS` |
+| Instruction discovery | `PASS` |
+| Pre-contract autonomy | `FAIL` |
+| Contract creation | `FAIL` |
+| Deterministic routing | `NOT_REACHED` |
+| Gate enforcement | `NOT_REACHED` |
+| Preflight chronology | `NOT_REACHED` |
+| Implementation | `NOT_REACHED` |
+| Agent lifecycle navigation | `NOT_REACHED` |
+| Execution → Verification handoff | `NOT_REACHED` |
+| Receipt preparation | `NOT_REACHED` |
+| Verification execution | `NOT_REACHED` |
+| Future-result fabrication prevention | `NOT_REACHED` |
+| Evidence chronology | `NOT_REACHED` |
+| Evidence serialization | `NOT_REACHED` |
+| Evidence integrity | `NOT_REACHED` |
+| Failure loop | `NOT_EXERCISED` |
+| Review transition | `NOT_REACHED` |
+| Receipt generation | `NOT_REACHED` |
+| Completion validation | `NOT_REACHED` |
+| Lifecycle closure | `NOT_REACHED` |
+| False-completion prevention | `PASS` |
+| Full conformance | `PARTIAL` |
+
+## Independent outcome dimensions
+
+- Task success: `FAIL`
+- Protocol conformance: `PARTIAL`
+- Verification validity: `INVALID`
+- Publication: `NOT_PUBLISHED` for the target deliverable; the ForgeLoop
+  package itself was already `PUBLISHED` as `0.1.3`.
+- Production readiness: `NOT_VERIFIED`
+
+## Final classification
+
+`PARTIAL`
+
+The run verified blind adapter bootstrap and instruction discovery and showed
+that the validators reject false completion. It did not reach protocol
+execution because the agent treated a reversible law-firm positioning choice as
+a blocking clarification instead of recording an agent-default assumption and
+continuing autonomously.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cassiomc1/forgeloop",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Portable, verifiable instruction kit for AI agents and developers",
   "repository": {
     "type": "git",

package/src/cli.js

@@ -24,12 +24,13 @@ import { formatPolicyResult, runPolicy } from "./commands/policy.js";
 import { formatBundleResult, runBundle } from "./commands/bundle.js";
 import { formatPrepareCompletionResult, runPrepareCompletion } from "./commands/prepare-completion.js";
 import { formatRecordCheckResult, runRecordCheck } from "./commands/record-check.js";
+import { formatNextActionResult, runNext } from "./commands/next.js";
 import { resolveTarget } from "./core/filesystem.js";
 import { getPackageRoot } from "./core/templates.js";
 import { ARTIFACT_PATHS } from "./core/artifacts.js";
 
 function usage(command = null) {
-  const commands = "init|doctor|update|activate|route|preflight|advance|prepare-completion|record-check|complete|audit|report|policy|bundle|inspect|status|validate-state|clear-state|validate-receipt|validate-protocol";
+  const commands = "init|doctor|update|activate|route|preflight|advance|next|prepare-completion|record-check|complete|audit|report|policy|bundle|inspect|status|validate-state|clear-state|validate-receipt|validate-protocol";
   const options = ["  --path <directory>  target project directory (default: current directory)"];
   if (!command || command === "init" || command === "update") {
     options.push("  --dry-run           show planned writes without changing files");
@@ -51,7 +52,7 @@ function usage(command = null) {
   if (!command || command === "advance") {
     options.push("  --to <phase>        destination workflow phase");
   }
-  if (!command || ["activate", "advance", "prepare-completion", "record-check", "preflight", "complete", "audit", "report", "policy", "bundle", "inspect", "status", "validate-state", "clear-state", "validate-receipt", "validate-protocol"].includes(command)) {
+  if (!command || ["activate", "advance", "next", "prepare-completion", "record-check", "preflight", "complete", "audit", "report", "policy", "bundle", "inspect", "status", "validate-state", "clear-state", "validate-receipt", "validate-protocol"].includes(command)) {
     options.push("  --json              emit structured output as JSON");
   }
   if (!command || ["preflight", "complete", "audit", "report"].includes(command)) {
@@ -132,7 +133,7 @@ export function parseArgs(argv) {
 
   for (let index = 0; index < argv.length; index += 1) {
     const argument = argv[index];
-    if (["init", "doctor", "update", "activate", "route", "preflight", "advance", "prepare-completion", "record-check", "complete", "audit", "report", "policy", "bundle", "inspect", "status", "validate-state", "clear-state", "validate-receipt", "validate-protocol"].includes(argument)) {
+    if (["init", "doctor", "update", "activate", "route", "preflight", "advance", "next", "prepare-completion", "record-check", "complete", "audit", "report", "policy", "bundle", "inspect", "status", "validate-state", "clear-state", "validate-receipt", "validate-protocol"].includes(argument)) {
       if (command) throw new Error(`Multiple commands are not supported: ${argument}`);
       command = argument;
     } else if (argument === "--help" || argument === "-h") {
@@ -214,6 +215,10 @@ export function parseArgs(argv) {
       if (!id || id.startsWith("-")) throw new Error("--id requires a check ID");
       options.checkId = id;
       index += 1;
+    } else if (argument.startsWith("--id=")) {
+      const id = argument.slice("--id=".length);
+      if (!id || id.startsWith("-")) throw new Error("--id requires a check ID");
+      options.checkId = id;
     } else if (argument === "--kind") {
       const kind = argv[index + 1];
       if (!kind || kind.startsWith("-")) throw new Error("--kind requires a check kind");
@@ -224,6 +229,10 @@ export function parseArgs(argv) {
       if (!requirement || requirement.startsWith("-")) throw new Error("--requirement requires an evidence target");
       options.checkRequirement = requirement;
       index += 1;
+    } else if (argument.startsWith("--requirement=")) {
+      const requirement = argument.slice("--requirement=".length);
+      if (!requirement) throw new Error("--requirement requires an evidence target");
+      options.checkRequirement = requirement;
     } else if (argument === "--status") {
       const status = argv[index + 1];
       if (!status || status.startsWith("-")) throw new Error("--status requires a check status");
@@ -244,6 +253,10 @@ export function parseArgs(argv) {
       if (!resultText || resultText.startsWith("-")) throw new Error("--result requires recorded text");
       options.checkResult = resultText;
       index += 1;
+    } else if (argument.startsWith("--result=")) {
+      const resultText = argument.slice("--result=".length);
+      if (!resultText) throw new Error("--result requires recorded text");
+      options.checkResult = resultText;
     } else if (argument === "--exit-code") {
       const exitCode = argv[index + 1];
       if (!exitCode || exitCode.startsWith("-")) throw new Error("--exit-code requires a non-negative integer");
@@ -282,7 +295,7 @@ export function parseArgs(argv) {
 
   if (!command) return { command: null, options };
 
-  const jsonCommands = ["doctor", "route", "activate", "advance", "prepare-completion", "record-check", "preflight", "complete", "audit", "report", "policy", "bundle", "inspect", "status", "validate-state", "clear-state", "validate-receipt", "validate-protocol"];
+  const jsonCommands = ["doctor", "route", "activate", "advance", "next", "prepare-completion", "record-check", "preflight", "complete", "audit", "report", "policy", "bundle", "inspect", "status", "validate-state", "clear-state", "validate-receipt", "validate-protocol"];
   if (!jsonCommands.includes(command) && options.json) {
     throw new Error(`Option --json is not valid for ${command}`);
   }
@@ -436,6 +449,12 @@ export async function main(argv = process.argv.slice(2)) {
       return 0;
     }
 
+    if (command === "next") {
+      const result = await runNext({ target, packageRoot });
+      console.log(options.json ? JSON.stringify(result, null, 2) : formatNextActionResult(result));
+      return 0;
+    }
+
     if (command === "prepare-completion") {
       const result = await runPrepareCompletion({ target, packageRoot });
       console.log(options.json ? JSON.stringify(result, null, 2) : formatPrepareCompletionResult(result));
@@ -451,8 +470,8 @@ export async function main(argv = process.argv.slice(2)) {
         requirement: options.checkRequirement,
         status: options.checkStatus,
         evidenceKind: options.checkEvidenceKind,
-        command: options.checkCommand,
-        result: options.checkResult,
+        command: options.checkCommand ?? undefined,
+        result: options.checkResult ?? undefined,
         exitCode: options.checkExitCode,
         details: options.checkDetails ?? undefined,
       });

package/src/commands/next.js

@@ -0,0 +1,29 @@
+import { getNextAction } from "../core/next-action.js";
+
+export async function runNext({ target, packageRoot }) {
+  return getNextAction({ target, packageRoot });
+}
+
+export function formatNextActionResult(result) {
+  const lines = [
+    `FORGELOOP NEXT: ${result.nextAction}`,
+    `PHASE: ${result.currentPhase}`,
+  ];
+  if (result.reasons.length > 0) {
+    lines.push("REASONS:");
+    lines.push(...result.reasons.map((reason) => `- ${reason.code}: ${reason.message}`));
+  }
+  if (result.commands.length > 0) {
+    lines.push("COMMANDS (SAFE SYNOPSIS ONLY):");
+    lines.push(...result.commands.map((command) => `- ${command}`));
+  }
+  if (result.commandSpecs.length > 0) {
+    lines.push("STRUCTURED COMMAND SPECS: Available in --json output; direct-process argv data, not shell syntax.");
+  }
+  if (result.missingArtifacts.length > 0) {
+    lines.push("MISSING ARTIFACTS:");
+    lines.push(...result.missingArtifacts.map((artifact) => `- ${artifact}`));
+  }
+  if (result.terminal) lines.push("STATE: TERMINAL");
+  return `${lines.join("\n")}\n`;
+}

package/src/core/completion-artifacts.js

@@ -5,16 +5,18 @@ import {
   writeJsonArtifact,
 } from "./artifacts.js";
 import { readContract } from "./contract.js";
-import { appendProtocolEvent } from "./events.js";
+import { appendProtocolEvent, validateEventLedger } from "./events.js";
 import { completionEvidenceForGuides } from "./guide-metadata.js";
 import { createCheck } from "./checks.js";
 import { createEvidence } from "./evidence.js";
 import { coverageForRequirements } from "./coverage.js";
+import { assertCompletionRelationships } from "./completion-relationships.js";
 import { evaluatePreflight } from "./preflight.js";
 import { currentChangedPaths } from "./repository.js";
 import { readPersistedRoute } from "./route-artifact.js";
 import { createReceipt, validateReceipt } from "./receipt.js";
 import { readWorkState, writeWorkState } from "./work-state.js";
+import { assertExecutionPrerequisites, hasExecutionStarted } from "./execution-prerequisites.js";
 
 function artifactError(code, message, artifacts = []) {
   const error = new Error(message);
@@ -72,6 +74,9 @@ export async function prepareCompletion({ target, packageRoot }) {
   if (!state) {
     throw artifactError("E_STATE_MISSING", "Work state is required before preparing completion", [ARTIFACT_PATHS.state]);
   }
+  if (hasExecutionStarted(state.phase)) {
+    await assertExecutionPrerequisites({ target, state, packageRoot });
+  }
 
   let existing = null;
   try {
@@ -90,18 +95,25 @@ export async function prepareCompletion({ target, packageRoot }) {
     additionalEvidence: preflight.policy?.requiredEvidence ?? [],
   });
   const existingValue = existing?.value ?? {};
+  assertCompletionRelationships({
+    contract,
+    route,
+    state,
+    receipt: existingValue.taskId ? existingValue : null,
+    requiredEvidence,
+    requireRequiredChecks: false,
+  });
   const changedPaths = existing
     ? [...(existingValue.changedPaths ?? [])]
     : (await currentChangedPaths(target) ?? []);
-  const checks = [...(existingValue.checks ?? [])];
+  const checks = existing ? [...existingValue.checks] : [...state.checks];
+  const evidence = existing ? [...(existingValue.evidence ?? [])] : [...state.verificationEvidence];
   const receipt = await createReceipt({
     ...existingValue,
     taskId: contract.value.taskId,
     contractFingerprint: contract.fingerprint,
     routeFingerprint: route.fingerprint,
-    ...(Object.hasOwn(existingValue, "stateFingerprint")
-      ? { stateFingerprint: canonicalFingerprint(state) }
-      : {}),
+    stateFingerprint: canonicalFingerprint(state),
     status: existingValue.status ?? "in-progress",
     taskStatus: existingValue.taskStatus ?? "in-progress",
     verificationStatus: existingValue.verificationStatus ?? "not-verified",
@@ -110,7 +122,7 @@ export async function prepareCompletion({ target, packageRoot }) {
     selectedGuides: [...route.value.guides],
     changedPaths,
     checks,
-    evidence: [...(existingValue.evidence ?? [])],
+    evidence,
     evidenceCoverage: coverageForRequirements(requiredEvidence, checks),
     review: existingValue.review ?? { status: "not-run", independent: false },
     limitations: [...(existingValue.limitations ?? [])],
@@ -196,6 +208,7 @@ export async function recordCheck({
       [ARTIFACT_PATHS.state],
     );
   }
+  await assertExecutionPrerequisites({ target, state, packageRoot });
 
   const existingReceipt = await readCurrentReceipt(target, packageRoot);
   await validateReceipt(existingReceipt.value, packageRoot);
@@ -234,6 +247,26 @@ export async function recordCheck({
     packageRoot,
     additionalEvidence: preflight.policy?.requiredEvidence ?? [],
   });
+  assertCompletionRelationships({
+    contract,
+    route,
+    state,
+    receipt: existingReceipt.value,
+    requiredEvidence,
+    requireRequiredChecks: false,
+  });
+  const ledger = await validateEventLedger(target, packageRoot);
+  if (!ledger.valid) {
+    const first = ledger.errors[0];
+    throw artifactError(first.code, first.message, [ARTIFACT_PATHS.events]);
+  }
+  if (!ledger.events.some((event) => event.taskId === state.taskId && event.event === "VERIFICATION_STARTED")) {
+    throw artifactError(
+      "E_PHASE_CHRONOLOGY_INVALID",
+      "record-check requires VERIFICATION_STARTED in the current task ledger",
+      [ARTIFACT_PATHS.events],
+    );
+  }
   const coverage = coverageForRequirements(requiredEvidence, checks);
   const nextState = {
     ...state,
@@ -247,11 +280,18 @@ export async function recordCheck({
     checks,
     evidence: evidenceList,
     evidenceCoverage: coverage,
-    ...(Object.hasOwn(existingReceipt.value, "stateFingerprint")
-      ? { stateFingerprint: canonicalFingerprint(nextState) }
-      : {}),
+    stateFingerprint: canonicalFingerprint(nextState),
   }, packageRoot);
 
+  assertCompletionRelationships({
+    contract,
+    route,
+    state: nextState,
+    receipt: nextReceipt,
+    requiredEvidence,
+    requireRequiredChecks: false,
+  });
+
   await writeWorkState(target, nextState, { packageRoot });
   const written = await writeJsonArtifact(
     target,