@cassiomc1/forgeloop 0.1.13 → 0.1.14

package/LOOP_ENGINEERING.md

@@ -108,6 +108,39 @@ rules permit it.
 A missing checker must never be converted into environmental mutation merely
 to make verification pass.
 
+### Verification command resolution modes and validator enforcement
+
+Every verification command path is classified by resolution mode:
+
+| Mode | Examples | May install software | Authority required |
+| --- | --- | --- | --- |
+| `LOCAL_EXECUTABLE` | `node scripts/test.js`, `python3 -m unittest`, `./bin/check` | No | No |
+| `LOCAL_PACKAGE_BINARY` | `./node_modules/.bin/tool`, `npm test`, `pnpm test`, `yarn test` | No | No |
+| `NON_INSTALLING_RESOLUTION` | `npx --no-install tool`, `npx --no tool` | No | No |
+| `INSTALL_CAPABLE_RESOLUTION` | `npx tool`, `pnpm dlx tool`, `yarn dlx tool`, `bunx tool`, `uvx tool`, `pipx run tool` | Yes | Yes (`E_INSTALLATION_AUTHORITY_REQUIRED`) |
+| `EXPLICIT_INSTALLATION` | `npm install tool`, `pnpm add tool`, `pip install tool`, `cargo install tool` | Yes | Yes (`E_INSTALLATION_AUTHORITY_REQUIRED`) |
+
+**Validator-enforced rule**: Any verification command executed via an installation-capable or explicit-installation resolution mode without a valid canonical installation authority grant is rejected by `record-check`, `audit`, and `complete` with error code `E_INSTALLATION_AUTHORITY_REQUIRED`, `E_AUTHORITY_INVALID`, `E_AUTHORITY_SCOPE_MISMATCH`, or `E_AUTHORITY_UNTRUSTED_SOURCE` and cannot contribute to `VALID` completion.
+
+Authority cannot be self-issued by the actor consuming it. Boolean fields inside verification evidence (such as `installationAuthorized: true`) are not sufficient proof of installation authority. Installation authority must be established via a canonical authority grant supplied by a host/operator trust boundary and referenced via `installationAuthorityRef`.
+
+The runtime authority context has two modes:
+
+- `NONE` is the default for the actor-facing standalone CLI. `FORGELOOP_AUTHORITY_FILE` and `FORGELOOP_AUTHORITY_DIR` may select candidate source metadata for compatibility and diagnostics, but they do not make a source trusted. An environment-selected source is rejected with `E_AUTHORITY_UNTRUSTED_SOURCE` when it is used for an installation-capable verification.
+- `HOST_ATTESTED` is an internal integration context supplied by a host-owned wrapper, embedded API, or equivalent boundary. It may select a trusted authority file, directory, or in-memory provider only when the actor cannot replace that context at command invocation time. The CLI exposes no flag that promotes a source to `HOST_ATTESTED`.
+
+External path is not equivalent to external authority ownership. The host-attested source must still resolve outside the actor-writable target, and a project-local `.forgeloop/authorities/` artifact remains an untrusted reference, cache, diagnostic, or mirror by default. A local claim such as `source: operator` is not proof of operator authority.
+
+ForgeLoop validates authority semantics, while the host defines the trust boundary. If the host grants the actor write access to the configured attested source, the host boundary is compromised and ForgeLoop cannot distinguish operator authority from actor fabrication without a stronger external trust anchor.
+
+### Stale receipt recovery invariant
+
+Every recovery action returned by `forgeloop next` must be executable from the state that produced it. When work state changes legitimately after preparing a completion receipt, `forgeloop prepare-completion` refreshes the receipt and re-binds it to current state and changed paths without requiring manual deletion of `.forgeloop/execution-receipt.json`.
+
+### Conformance profile escalation policy
+
+A run started in Standard conformance must not be silently escalated to Strict after validator-backed completion. Strict validation is a separate conformance profile. If Strict revalidation is performed after Standard `COMPLETE`, it is treated as a distinct revalidation cycle and does not retroactively invalidate a valid Standard result.
+
 ## Blocking vs Non-Blocking Decisions
 
 Classify every unresolved decision before deciding whether to ask the user.

package/PROTOCOL_INTEGRATION.md

@@ -152,6 +152,77 @@ not already available:
 - otherwise report the affected verification dimension as not verified with
   `E_VERIFICATION_TOOL_UNAVAILABLE`.
 
+Every verification command is classified by resolution mode (`LOCAL_EXECUTABLE`,
+`LOCAL_PACKAGE_BINARY`, `NON_INSTALLING_RESOLUTION`, `INSTALL_CAPABLE_RESOLUTION`,
+`EXPLICIT_INSTALLATION`). Any command that uses an install-capable or installation
+path without a valid canonical authority reference is rejected by `record-check`,
+`audit`, and `complete` with `E_INSTALLATION_AUTHORITY_REQUIRED`, `E_AUTHORITY_INVALID`,
+`E_AUTHORITY_SCOPE_MISMATCH`, or `E_AUTHORITY_UNTRUSTED_SOURCE`.
+
+```text
+capability ≠ authority
+evidence ≠ authority grant
+actor claim ≠ operator grant
+```
+
+Authority cannot be self-issued by the actor consuming it. Boolean fields inside
+verification evidence are not sufficient proof of installation authority.
+
+### Authority provenance
+
+Authority provenance is external to actor-authored project state. An external
+path is not equivalent to external authority ownership:
+
+```text
+outside target
+≠
+outside actor control
+```
+
+The standalone CLI uses `trustMode: NONE`. `FORGELOOP_AUTHORITY_FILE` and
+`FORGELOOP_AUTHORITY_DIR` select candidate authority sources, but they do not
+make a source trusted in actor-facing execution. Environment-selected sources
+are rejected with `E_AUTHORITY_UNTRUSTED_SOURCE` for install-capable checks.
+
+Trusted authority requires an explicit `HOST_ATTESTED` runtime context supplied
+through an integration boundary the active actor cannot replace at command
+invocation time. Configuration is not trust:
+
+```text
+environment-selected source
+≠
+host-attested source
+
+configuration
+≠
+trust
+```
+
+The host-attested source must still resolve outside the actor-writable target. A
+project-local authority reference may identify a grant, but it does not create
+the root of trust.
+
+```text
+actor-authored evidence
+≠
+trusted authority
+
+project-local file
+≠
+host grant
+
+declared provenance
+≠
+verified provenance
+```
+
+A local artifact claiming `source: operator` is not sufficient proof of operator
+authority. The actor-facing CLI must not expose an equivalent of
+`--authority-source-attested-by-host` or `--trusted-authority-file` that
+self-promotes a source. If the host exposes the attested source as writable to
+the actor, the host boundary has been compromised and ForgeLoop cannot provide
+cryptographic attestation by itself.
+
 Never convert `PROTOCOL_LIMITED` into environmental mutation by implicitly
 installing a package.
 

package/README.md

@@ -109,11 +109,12 @@ The regression suite injects failures at these boundaries and verifies that
 owned cleanup. The frozen published installation under
 [`tests/fixtures/legacy-0.1.6/`](./tests/fixtures/legacy-0.1.6/) is derived
 from the real npm tarball, includes provenance and digests, and is copied into
-The current published release is `@cassiomc1/forgeloop@0.1.13`.
-Earlier `0.1.8`, `0.1.9`, `0.1.10`, `0.1.11`, and `0.1.12` references are historical; never move
-their tags or `v0.1.10`. Version `0.1.13` enforces the missing verification tool
-policy, conditional single-actor delegation validation, and a universal
-vendor-neutral engineering protocol positioning.
+The latest verified published npm release is `@cassiomc1/forgeloop@0.1.14`.
+The repository release is `0.1.14`.
+Earlier `0.1.8`, `0.1.9`, `0.1.10`, `0.1.11`, `0.1.12`, and `0.1.13` references are historical; never move
+their tags or `v0.1.10`. Release `0.1.14` enforces verification installation
+authority, provides recoverable stale receipt lifecycle in `prepare-completion`,
+and validates single-actor protocol runs.
 
 ## How to prompt ForgeLoop
 
@@ -203,12 +204,13 @@ project without overwriting local instructions. When the package is available
 in the npm registry, use the commands below; otherwise use the repository
 checkout fallback.
 
-The current published release is `@cassiomc1/forgeloop@0.1.13`.
-Pin this version when a reproducible blind run or release-identity check is
-required:
+The current repository package is `@cassiomc1/forgeloop@0.1.14`.
+The latest verified published npm release is `@cassiomc1/forgeloop@0.1.14`.
+For reproducible published-package runs or release-identity checks,
+pin the published version:
 
 ```bash
-npx @cassiomc1/forgeloop@0.1.13 --version
+npx @cassiomc1/forgeloop@0.1.14 --version
 npx @cassiomc1/forgeloop init
 npx @cassiomc1/forgeloop doctor
 npx @cassiomc1/forgeloop update
@@ -372,12 +374,17 @@ target project. Its main threat boundaries are:
 | Data exposure | Receipts and checkpoints reject secret-like keys and values; examples use placeholders, and the repository secret scanner runs in CI. |
 | Unsafe update overwrite | `update` preserves locally modified files and the target's `.forgeloop/kit/PROJECT_PROFILE.md`; adoption and writes remain bounded to the selected target. |
 | Dependency supply chain | Runtime code uses Node built-ins only; the package does not install agents, providers, plugins, or remote services. |
+| Installation authority provenance | Standalone CLI uses `trustMode: NONE`: environment-selected `FORGELOOP_AUTHORITY_FILE`/`FORGELOOP_AUTHORITY_DIR` sources are untrusted candidates; only an internal `HOST_ATTESTED` context may select a trusted source outside the actor-writable target. Project-local authority claims remain untrusted. |
 | Stale replay | Work state records contract and repository fingerprints; drift requires revalidation and never reruns destructive or publication actions automatically. |
 | Unverified publication | Receipts carry explicit publication booleans; local success never implies a push, pull request, merge, release, or deployment. |
 
 The full boundary inventory, residual limitations, and executable evidence are
 in [`THREAT_MODEL.md`](./THREAT_MODEL.md).
 
+An external path is not equivalent to external authority ownership. Actor-controlled
+environment configuration is not sufficient proof of host/operator authority;
+trusted authority requires a host-attested integration boundary.
+
 The CLI cannot protect a target from a separately privileged or hostile process
 that changes the filesystem after validation. Consumers must still review
 permissions, package provenance, and external actions before granting authority.

package/THREAT_MODEL.md

@@ -35,6 +35,10 @@ remaining trust boundaries and their executable evidence.
 | Lifecycle simulation after CLI resolution failure | A runtime manually writes protocol-owned JSON and falsely claims conformance when the CLI is unresolved | Lifecycle-owned protocol state and CLI availability | CLI-owned artifact policy, universal adapter prohibition, validator-backed completion, append-only ledger hash chain | A privileged local process can tamper with local files; ForgeLoop detects consistency, not remote attestation | `tests/discovery-surfaces.test.js`, `tests/lifecycle.test.js`, `LOOP_ENGINEERING.md` |
 | Unauthorized verification dependency installation | The active actor mutates the environment by downloading or installing a missing checker merely to satisfy verification | Verification capability discovery and installation authority | Missing verification tool policy, non-installing resolution first, explicit installation authority, equivalent-check fallback, NOT_VERIFIED degradation | A privileged external process may still install tools outside ForgeLoop's control | `tests/verification-capability.test.js`, `tests/discovery-surfaces.test.js`, `LOOP_ENGINEERING.md` |
 | False delegation requirement | A valid single-actor run is incorrectly reported as incomplete because a validator demands artifacts for delegation that never occurred | Validator delegation scope resolution | Canonical delegationIsInScope predicate, conditional delegation validation in validateTaskArtifactSet and validate-protocol | Malformed or externally injected artifacts may require INCONSISTENT classification | `tests/conformance.test.js`, `tests/validate-protocol-cli.test.js` |
+| Self-asserted authority bypass | The active actor supplies `installationAuthorized=true` inside its own verification evidence and thereby grants itself authority | Authority provenance and verification evidence | Boolean claims are ignored; scoped authority references, task/type/tool validation, and validator revalidation in `record-check`/`audit`/`complete` require a trusted source | A host-controlled source is still a semantic trust boundary and is not cryptographic attestation | `tests/verification-capability.test.js`, `tests/authority.test.js`, `tests/stale-receipt-recovery.test.js` |
+| Forged local authority artifact | The active actor creates `.forgeloop/authorities/auth-modlens.json`, claims `source=operator`, and uses the reference to authorize its own installation-capable check | Host/operator authority source versus actor-writable project state | Resolve grants only from an explicit `HOST_ATTESTED` runtime context with an external source outside the target; reject project-local grants with `E_AUTHORITY_UNTRUSTED_SOURCE`; revalidate in `record-check`/`audit`/`complete` | If the host exposes the attested source as writable to the actor, ForgeLoop cannot distinguish genuine grants from actor fabrication without a stronger trust anchor | Local fake rejection, host-attested external acceptance, inside-target rejection, post-record removal and revocation tests |
+| Environment-injected trust root | The active actor creates an authority file outside the project target and sets `FORGELOOP_AUTHORITY_FILE` or `FORGELOOP_AUTHORITY_DIR` when invoking ForgeLoop | Actor-controlled process environment versus host-attested runtime authority | Standalone CLI uses `trustMode: NONE`; environment-selected sources are metadata/candidates only and fail with `E_AUTHORITY_UNTRUSTED_SOURCE`; trusted authority requires an internal `HOST_ATTESTED` context not exposed as a self-assertable CLI option | If the host integration allows the actor to mutate or replace the attested source/context, the host trust boundary is compromised | Environment-injection rejection, standalone audit/complete rejection, host-attested positive path |
+| Stale receipt recovery dead-end | Work state changes after preparing a receipt, leaving a mismatch that cannot be refreshed because the old receipt is rejected during re-preparation | Preparation lifecycle and recovery action resolution | Recoverable stale receipt binding in `prepareCompletion`, executable `PREPARE_COMPLETION` return from `next`, atomic refresh of stateFingerprint and changedPaths | Manual file corruption outside CLI commands requires manual diagnostic recovery | `tests/stale-receipt-recovery.test.js`, `tests/next-executability.test.js` |
 
 ## Boundary rules
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cassiomc1/forgeloop",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "description": "Portable, verifiable engineering protocol for AI coding environments and developer workflows",
   "repository": {
     "type": "git",

package/schemas/authority.schema.json

@@ -0,0 +1,34 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "forgeloop://schemas/authority.schema.json",
+  "title": "ForgeLoop installation authority grant",
+  "type": "object",
+  "required": [
+    "schemaVersion",
+    "protocolVersion",
+    "authorityId",
+    "taskId",
+    "type",
+    "status",
+    "scope",
+    "source"
+  ],
+  "properties": {
+    "schemaVersion": { "const": 1 },
+    "protocolVersion": { "const": 1 },
+    "authorityId": { "type": "string", "minLength": 1 },
+    "taskId": { "type": "string", "minLength": 1 },
+    "type": { "enum": ["SOFTWARE_INSTALLATION"] },
+    "status": { "enum": ["AUTHORIZED", "REVOKED", "EXPIRED"] },
+    "scope": {
+      "type": "object",
+      "required": ["tool"],
+      "properties": {
+        "tool": { "type": "string", "minLength": 1 }
+      },
+      "additionalProperties": false
+    },
+    "source": { "enum": ["operator", "host", "project-policy"] }
+  },
+  "additionalProperties": false
+}

package/src/commands/inspect.js

@@ -8,6 +8,8 @@ export function formatInspectResult(report) {
     `Manifest: ${report.manifest.status}`,
     `Profile: ${report.profile.mode ?? "unknown"}/${report.profile.status ?? "unknown"}`,
     `Protocol: v${report.protocol.version}`,
+    `Authority source: ${report.authority.sourceType ?? "none configured"} / ${report.authority.trusted ? "TRUSTED" : report.authority.trustMode === "NONE" ? "UNATTESTED" : "UNTRUSTED"}`,
+    `Authority trust: ${report.authority.trustMode}`,
     `State: ${report.state.status}`,
     `Adapters: ${report.adapters.detected.length} detected`,
     `Findings: ${report.findings.length}`,

package/src/commands/prepare-completion.js

@@ -2,8 +2,8 @@ import { prepareCompletion as prepareCompletionArtifacts } from "../core/complet
 
 export { prepareCompletionArtifacts as prepareCompletion };
 
-export async function runPrepareCompletion({ target, packageRoot }) {
-  return prepareCompletionArtifacts({ target, packageRoot });
+export async function runPrepareCompletion({ target, packageRoot, authorityContext, runtimeContext }) {
+  return prepareCompletionArtifacts({ target, packageRoot, authorityContext, runtimeContext });
 }
 
 export function formatPrepareCompletionResult(result) {

package/src/core/audit.js

@@ -34,8 +34,8 @@ async function compareChangedPaths(target, packageRoot) {
   };
 }
 
-export async function evaluateAudit({ target, packageRoot, strict = false } = {}) {
-  const completion = await evaluateCompletion({ target, packageRoot, strict });
+export async function evaluateAudit({ target, packageRoot, strict = false, authorityContext, runtimeContext } = {}) {
+  const completion = await evaluateCompletion({ target, packageRoot, strict, authorityContext, runtimeContext });
   let manifest = null;
   let manifestError = null;
   try {

package/src/core/checks.js

@@ -1,4 +1,5 @@
 import { PROTOCOL_VERSION } from "./protocol.js";
+import { validateVerificationAuthority } from "./verification-capability.js";
 
 export const CHECK_SCHEMA_VERSION = 1;
 export const CHECK_STATUSES = Object.freeze(["passed", "failed", "blocked", "not-run"]);
@@ -45,7 +46,7 @@ function assertCompoundStatus(value, label) {
   }
 }
 
-export function createCheck(input = {}) {
+export function createCheck(input = {}, options = {}) {
   const check = {
     schemaVersion: CHECK_SCHEMA_VERSION,
     protocolVersion: PROTOCOL_VERSION,
@@ -61,10 +62,10 @@ export function createCheck(input = {}) {
     ...(input.viewport !== undefined ? { viewport: structuredClone(input.viewport) } : {}),
     ...(input.details !== undefined ? { details: structuredClone(input.details) } : {}),
   };
-  return assertCheck(check);
+  return assertCheck(check, "check", options);
 }
 
-export function assertCheck(value, label = "check") {
+export function assertCheck(value, label = "check", options = {}) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     throw checkError("E_CHECK_INVALID", `${label} must be an object`);
   }
@@ -97,15 +98,21 @@ export function assertCheck(value, label = "check") {
   if (value.status === "not-run" && value.evidenceKind !== "NOT_VERIFIED") {
     throw contradiction(`${label} not-run must use NOT_VERIFIED evidence`);
   }
+  if (value.status === "passed") {
+    const auth = validateVerificationAuthority(value, options);
+    if (!auth.valid) {
+      throw checkError(auth.error.code, auth.error.message);
+    }
+  }
   assertCompoundStatus(value, label);
   return value;
 }
 
-export function assertCheckList(value, label = "checks") {
+export function assertCheckList(value, label = "checks", options = {}) {
   if (!Array.isArray(value)) throw checkError("E_CHECK_INVALID", `${label} must be an array`);
   const ids = new Set();
   value.forEach((item, index) => {
-    assertCheck(item, `${label}[${index}]`);
+    assertCheck(item, `${label}[${index}]`, options);
     if (ids.has(item.id)) throw checkError("E_CHECK_INVALID", `${label} contains duplicate id ${item.id}`);
     ids.add(item.id);
   });

package/src/core/completion-artifacts.js

@@ -11,7 +11,7 @@ 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 { assertCompletionRelationships, assertStateIdentity } from "./completion-relationships.js";
 import { evaluatePreflight } from "./preflight.js";
 import { currentChangedPaths } from "./repository.js";
 import { readPersistedRoute } from "./route-artifact.js";
@@ -19,6 +19,7 @@ import { createReceipt, validateReceipt } from "./receipt.js";
 import { readWorkState, writeWorkState } from "./work-state.js";
 import { assertExecutionPrerequisites, hasExecutionStarted } from "./execution-prerequisites.js";
 import { normalizeRequirements, classifyRequirement } from "./evidence-readiness.js";
+import { classifyCommandResolution, validateVerificationAuthority } from "./verification-capability.js";
 
 function artifactError(code, message, artifacts = []) {
   const error = new Error(message);
@@ -69,7 +70,7 @@ export async function requiredEvidenceForTarget({ target, contract, route, packa
   ])].sort();
 }
 
-export async function prepareCompletion({ target, packageRoot }) {
+export async function prepareCompletion({ target, packageRoot, authorityContext, runtimeContext }) {
   const contract = await readContract(target, packageRoot);
   const route = await readPersistedRoute(target, packageRoot);
   const state = await readWorkState(target, packageRoot);
@@ -83,7 +84,12 @@ export async function prepareCompletion({ target, packageRoot }) {
   let existing = null;
   try {
     existing = await readJsonArtifact(target, ARTIFACT_PATHS.receipt, "execution-receipt", packageRoot);
-    await validateReceipt(existing.value, packageRoot);
+    await validateReceipt(existing.value, packageRoot, {
+      target,
+      taskId: contract?.value?.taskId,
+      authorityContext,
+      runtimeContext,
+    });
   } catch (error) {
     if (error.code !== "ARTIFACT_MISSING") throw error;
   }
@@ -97,17 +103,19 @@ 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) ?? []);
+  if (existingValue.taskId && existingValue.taskId !== contract.value.taskId) {
+    throw artifactError("E_RECEIPT_TASK_MISMATCH", "Execution receipt does not belong to the current contract task", [ARTIFACT_PATHS.receipt]);
+  }
+  if (existing && existingValue.stateFingerprint === undefined) {
+    throw artifactError("E_RECEIPT_STATE_MISMATCH", "Execution receipt requires the current work-state fingerprint", [ARTIFACT_PATHS.receipt]);
+  }
+  assertStateIdentity({ contract, route, state });
+  const observedPaths = await currentChangedPaths(target);
+  const changedPaths = observedPaths !== null
+    ? [...observedPaths]
+    : existing
+      ? [...(existingValue.changedPaths ?? [])]
+      : [];
   const checks = existing ? [...existingValue.checks] : [...state.checks];
   const evidence = existing ? [...(existingValue.evidence ?? [])] : [...state.verificationEvidence];
   const receipt = await createReceipt({
@@ -126,7 +134,11 @@ export async function prepareCompletion({ target, packageRoot }) {
     changedPaths,
     checks,
     evidence,
-    evidenceCoverage: coverageForRequirements(requiredEvidence, checks),
+    evidenceCoverage: coverageForRequirements(requiredEvidence, checks, {
+      target,
+      taskId: contract.value.taskId,
+      options: { authorityContext, runtimeContext },
+    }),
     review: existingValue.review ?? { status: "not-run", independent: false },
     limitations: [...(existingValue.limitations ?? [])],
     publication: existingValue.publication ?? {
@@ -135,7 +147,24 @@ export async function prepareCompletion({ target, packageRoot }) {
       pullRequest: null,
       deployed: false,
     },
-  }, packageRoot);
+  }, packageRoot, {
+    target,
+    taskId: contract.value.taskId,
+    authorityContext,
+    runtimeContext,
+  });
+  assertCompletionRelationships({
+    contract,
+    route,
+    state,
+    receipt,
+    requiredEvidence,
+    requireRequiredChecks: false,
+    target,
+    taskId: contract.value.taskId,
+    authorityContext,
+    runtimeContext,
+  });
   const written = await writeJsonArtifact(
     target,
     ARTIFACT_PATHS.receipt,
@@ -179,6 +208,8 @@ export async function recordCheck({
   result,
   exitCode,
   details,
+  authorityContext,
+  runtimeContext,
 }) {
   requiredString(id, "check id");
   requiredString(kind, "check kind");
@@ -199,6 +230,8 @@ export async function recordCheck({
     throw artifactError("E_CHECK_INVALID", "record-check requires --command or --result");
   }
 
+  const commandSpec = typeof command === "string" && command.trim() !== "" ? command.trim() : undefined;
+
   const state = await readWorkState(target, packageRoot);
   if (!state) throw artifactError("E_STATE_MISSING", "Work state is required before recording a check", [ARTIFACT_PATHS.state]);
   if (["COMPLETE", "BLOCKED"].includes(state.phase)) {
@@ -235,9 +268,20 @@ export async function recordCheck({
   }
 
   const existingReceipt = await readCurrentReceipt(target, packageRoot);
-  await validateReceipt(existingReceipt.value, packageRoot);
-  const source = command?.trim() || `check:${id}`;
-  const recordedResult = result?.trim() || `recorded command: ${command.trim()}`;
+  await validateReceipt(existingReceipt.value, packageRoot, {
+    target,
+    taskId: contract.value.taskId,
+    authorityContext,
+    runtimeContext,
+  });
+  const source = commandSpec || `check:${id}`;
+  const recordedResult = result?.trim() || `recorded command: ${commandSpec || source}`;
+  const classification = commandSpec !== undefined ? classifyCommandResolution(commandSpec) : null;
+  const installationAuthorized = Boolean(
+    details?.installationAuthorized
+    || details?.authority?.softwareInstallation === "AUTHORIZED"
+    || details?.execution?.installationAuthorized
+  );
   const check = createCheck({
     id,
     kind,
@@ -252,7 +296,20 @@ export async function recordCheck({
       ...(result === undefined ? {} : { result }),
       ...(details === undefined ? {} : details),
       verificationCycle: state.verificationCycle ?? 1,
+      ...(classification ? {
+        execution: {
+          resolutionMode: classification.resolutionMode,
+          mayInstall: classification.mayInstall,
+          installationAuthorized,
+        },
+      } : {}),
     },
+  }, {
+    target,
+    taskId: contract.value.taskId,
+    packageRoot,
+    authorityContext,
+    runtimeContext,
   });
   const evidence = createEvidence({
     kind: evidenceKind,
@@ -265,6 +322,19 @@ export async function recordCheck({
     },
   });
 
+  if (status === "passed") {
+    const auth = validateVerificationAuthority(check, {
+      target,
+      taskId: contract.value.taskId,
+      packageRoot,
+      authorityContext,
+      runtimeContext,
+    });
+    if (!auth.valid) {
+      throw artifactError(auth.error.code, auth.error.message, [ARTIFACT_PATHS.receipt]);
+    }
+  }
+
   const checks = mergeByCheckId(existingReceipt.value.checks ?? [], check);
   const evidenceList = appendUniqueEvidence(existingReceipt.value.evidence ?? [], evidence);
   assertCompletionRelationships({
@@ -274,6 +344,10 @@ export async function recordCheck({
     receipt: existingReceipt.value,
     requiredEvidence,
     requireRequiredChecks: false,
+    target,
+    taskId: contract.value.taskId,
+    authorityContext,
+    runtimeContext,
   });
   const ledger = await validateEventLedger(target, packageRoot);
   if (!ledger.valid) {
@@ -287,7 +361,11 @@ export async function recordCheck({
       [ARTIFACT_PATHS.events],
     );
   }
-  const coverage = coverageForRequirements(requiredEvidence, checks);
+  const coverage = coverageForRequirements(requiredEvidence, checks, {
+    target,
+    taskId: contract.value.taskId,
+    options: { authorityContext, runtimeContext },
+  });
   const nextState = {
     ...state,
     checks,
@@ -302,7 +380,12 @@ export async function recordCheck({
     evidenceCoverage: coverage,
     stateFingerprint: canonicalFingerprint(nextState),
     verificationCycle: state.verificationCycle ?? 1,
-  }, packageRoot);
+  }, packageRoot, {
+    target,
+    taskId: contract.value.taskId,
+    authorityContext,
+    runtimeContext,
+  });
 
   assertCompletionRelationships({
     contract,
@@ -311,6 +394,10 @@ export async function recordCheck({
     receipt: nextReceipt,
     requiredEvidence,
     requireRequiredChecks: false,
+    target,
+    taskId: contract.value.taskId,
+    authorityContext,
+    runtimeContext,
   });
 
   await writeWorkState(target, nextState, { packageRoot });
@@ -351,6 +438,8 @@ export async function recordTerminalResult({
   source,
   result,
   details = {},
+  authorityContext,
+  runtimeContext,
 } = {}) {
   if (!target || !requirement || !type || !status || !source || !result) {
     throw artifactError("E_CHECK_INVALID", "record-terminal-result requires target, requirement, type, status, source, and result", [ARTIFACT_PATHS.state]);
@@ -413,7 +502,12 @@ export async function recordTerminalResult({
   }
 
   const existingReceipt = await readCurrentReceipt(target, packageRoot);
-  await validateReceipt(existingReceipt.value, packageRoot);
+  await validateReceipt(existingReceipt.value, packageRoot, {
+    target,
+    taskId: contract?.value?.taskId,
+    authorityContext,
+    runtimeContext,
+  });
 
   if (type === "PUBLICATION") {
     const rank = {
@@ -540,7 +634,12 @@ export async function recordTerminalResult({
   const nextReceipt = await createReceipt({
     ...receiptUpdates,
     stateFingerprint: canonicalFingerprint(nextState),
-  }, packageRoot);
+  }, packageRoot, {
+    target,
+    taskId: contract.value.taskId,
+    authorityContext,
+    runtimeContext,
+  });
 
   await writeWorkState(target, nextState, { packageRoot });
   await writeJsonArtifact(

package/src/core/completion-recovery.js

@@ -8,6 +8,10 @@ export const RECOVERABLE_COMPLETION_EVIDENCE_CODES = Object.freeze([
   "E_VERIFICATION_CHECK_REQUIRED",
   "E_CHECK_REQUIRED",
   "E_CHECK_INVALID",
+  "E_INSTALLATION_AUTHORITY_REQUIRED",
+  "E_AUTHORITY_INVALID",
+  "E_AUTHORITY_SCOPE_MISMATCH",
+  "E_AUTHORITY_UNTRUSTED_SOURCE",
 ]);
 
 export function isRecoverableCompletionEvidenceCode(code) {