@cassiomc1/forgeloop 0.1.12 → 0.1.14

package/src/core/native-adapters.js

@@ -43,6 +43,10 @@ route, required gates, and READY preflight.
 Use the project-local ForgeLoop CLI for lifecycle-owned protocol state.
 Never manually synthesize lifecycle chronology or assign ForgeLoop COMPLETE.
 
+Do not install a missing verification tool merely to satisfy a check.
+Use an existing equivalent, obtain explicit authority, or report the
+verification dimension as NOT_VERIFIED.
+
 Before claiming ForgeLoop-verified completion, require
 \`forgeloop complete\` to return \`VALID\`.
 

package/src/core/next-action.js

@@ -236,7 +236,16 @@ async function loadArtifact(loader, fallback) {
   }
 }
 
-async function requirementsAndCoverage({ target, packageRoot, contract, route, checks, additionalEvidence = [] }) {
+async function requirementsAndCoverage({
+  target,
+  packageRoot,
+  contract,
+  route,
+  checks,
+  additionalEvidence = [],
+  authorityContext,
+  runtimeContext,
+}) {
   const requirements = await requiredEvidenceForTarget({
     target,
     contract,
@@ -244,14 +253,21 @@ async function requirementsAndCoverage({ target, packageRoot, contract, route, c
     packageRoot,
     additionalEvidence,
   });
-  return { requirements, coverage: coverageForRequirements(requirements, checks) };
+  return {
+    requirements,
+    coverage: coverageForRequirements(requirements, checks, {
+      target,
+      taskId: contract?.value?.taskId,
+      options: { authorityContext, runtimeContext },
+    }),
+  };
 }
 
 export async function getNextAction(targetOrOptions = {}, packageRootOption) {
   const normalized = typeof targetOrOptions === "string"
     ? { target: targetOrOptions, packageRoot: packageRootOption }
     : targetOrOptions;
-  const { target, packageRoot } = normalized ?? {};
+  const { target, packageRoot, authorityContext, runtimeContext } = normalized ?? {};
   const workState = await loadArtifact(
     () => readWorkState(target, packageRoot),
     ARTIFACT_PATHS.state,
@@ -544,6 +560,8 @@ export async function getNextAction(targetOrOptions = {}, packageRootOption) {
       route,
       checks: state.checks,
       additionalEvidence: preflight.policy?.requiredEvidence ?? [],
+      authorityContext,
+      runtimeContext,
     });
     const authoritative = authoritativeChecksForRequirements({
       requirements: ordinaryLeafRequirements(evidence.requirements),
@@ -587,7 +605,12 @@ export async function getNextAction(targetOrOptions = {}, packageRootOption) {
       );
     }
     try {
-      await validateReceipt(receipt.value.value, packageRoot);
+      await validateReceipt(receipt.value.value, packageRoot, {
+        target,
+        taskId: contract?.value?.taskId,
+        authorityContext,
+        runtimeContext,
+      });
     } catch (error) {
       return decision(
         context,
@@ -596,7 +619,13 @@ export async function getNextAction(targetOrOptions = {}, packageRootOption) {
         [...requiredArtifacts, ARTIFACT_PATHS.receipt],
       );
     }
-    const readiness = evaluateRequiredEvidence({ requirements: evidence.requirements, checks: state.checks });
+    const readiness = evaluateRequiredEvidence({
+      requirements: evidence.requirements,
+      checks: state.checks,
+      target,
+      taskId: contract?.value?.taskId,
+      options: { authorityContext, runtimeContext },
+    });
     const receiptRelationships = completionRelationshipErrors({
       contract,
       route,
@@ -604,8 +633,26 @@ export async function getNextAction(targetOrOptions = {}, packageRootOption) {
       receipt: receipt.value.value,
       requiredEvidence: evidence.requirements,
       requireRequiredChecks: false,
+      target,
+      taskId: contract?.value?.taskId,
+      authorityContext,
+      runtimeContext,
     });
     if (receiptRelationships.length > 0) {
+      if (receiptRelationships.some((err) => (
+        err.code === "E_RECEIPT_STATE_MISMATCH"
+        || err.code === "E_RECEIPT_CYCLE_MISMATCH"
+        || err.code === "E_RECEIPT_CONTRACT_MISMATCH"
+        || err.code === "E_ROUTE_GUIDE_MISMATCH"
+        || err.code === "E_EVIDENCE_COVERAGE_INVALID"
+      ))) {
+        return decision(
+          context,
+          NEXT_ACTIONS.PREPARE_COMPLETION,
+          artifactError("E_RECEIPT_STATE_MISMATCH", "Run forgeloop prepare-completion to refresh the execution receipt with current state", [ARTIFACT_PATHS.receipt]),
+          [...requiredArtifacts, ARTIFACT_PATHS.receipt],
+        );
+      }
       return result({
         ...context,
         nextAction: NEXT_ACTIONS.RESOLVE_BLOCKER,
@@ -670,8 +717,16 @@ export async function getNextAction(targetOrOptions = {}, packageRootOption) {
       route,
       checks: state.checks,
       additionalEvidence: preflight.policy?.requiredEvidence ?? [],
+      authorityContext,
+      runtimeContext,
+    });
+    const readiness = evaluateRequiredEvidence({
+      requirements: evidence.requirements,
+      checks: state.checks,
+      target,
+      taskId: contract?.value?.taskId,
+      options: { authorityContext, runtimeContext },
     });
-    const readiness = evaluateRequiredEvidence({ requirements: evidence.requirements, checks: state.checks });
     if (!readiness.ready) {
       let recoveryAuthorized = false;
       if (state.lastCompletionAttempt?.status === "REJECTED") {
@@ -737,7 +792,12 @@ export async function getNextAction(targetOrOptions = {}, packageRootOption) {
       );
     }
     try {
-      await validateReceipt(receipt.value.value, packageRoot);
+      await validateReceipt(receipt.value.value, packageRoot, {
+        target,
+        taskId: contract?.value?.taskId,
+        authorityContext,
+        runtimeContext,
+      });
     } catch (error) {
       return decision(
         context,
@@ -752,8 +812,26 @@ export async function getNextAction(targetOrOptions = {}, packageRootOption) {
       state,
       receipt: receipt.value.value,
       requiredEvidence: evidence.requirements,
+      target,
+      taskId: contract?.value?.taskId,
+      authorityContext,
+      runtimeContext,
     });
     if (receiptRelationships.length > 0) {
+      if (receiptRelationships.some((err) => (
+        err.code === "E_RECEIPT_STATE_MISMATCH"
+        || err.code === "E_RECEIPT_CYCLE_MISMATCH"
+        || err.code === "E_RECEIPT_CONTRACT_MISMATCH"
+        || err.code === "E_ROUTE_GUIDE_MISMATCH"
+        || err.code === "E_EVIDENCE_COVERAGE_INVALID"
+      ))) {
+        return decision(
+          context,
+          NEXT_ACTIONS.PREPARE_COMPLETION,
+          artifactError("E_RECEIPT_STATE_MISMATCH", "Run forgeloop prepare-completion to refresh the execution receipt with current state", [ARTIFACT_PATHS.receipt]),
+          [...requiredArtifacts, ARTIFACT_PATHS.receipt],
+        );
+      }
       return result({
         ...context,
         nextAction: NEXT_ACTIONS.RESOLVE_BLOCKER,
@@ -761,7 +839,7 @@ export async function getNextAction(targetOrOptions = {}, packageRootOption) {
         requiredArtifacts: [...requiredArtifacts, ARTIFACT_PATHS.receipt],
       });
     }
-    const completion = await evaluateCompletion({ target, packageRoot });
+    const completion = await evaluateCompletion({ target, packageRoot, authorityContext, runtimeContext });
     if (completion.status !== "VALID") {
       const terminalPendingErrors = completion.errors.filter((err) => (
         err.code === "E_PUBLICATION_REQUIREMENT_PENDING" || err.code === "E_PRODUCTION_REQUIREMENT_PENDING"
@@ -793,7 +871,7 @@ export async function getNextAction(targetOrOptions = {}, packageRootOption) {
     return decision(context, NEXT_ACTIONS.RUN_COMPLETE, artifactError("COMPLETION_READY", "Completion artifacts and cross-artifact validation are valid"));
   }
   if (state.phase === "COMPLETE") {
-    const completion = await evaluateCompletion({ target, packageRoot });
+    const completion = await evaluateCompletion({ target, packageRoot, authorityContext, runtimeContext });
     if (completion.status === "VALID") {
       return decision(context, NEXT_ACTIONS.NONE, artifactError("PHASE_COMPLETE", "Completion is validator-backed and terminal"));
     }

package/src/core/phase.js

@@ -101,7 +101,7 @@ function reconcileImplementationStep(state, toPhase) {
   };
 }
 
-async function assertPhasePrerequisites(target, state, toPhase, packageRoot) {
+async function assertPhasePrerequisites(target, state, toPhase, packageRoot, authorityContext, runtimeContext) {
   if (toPhase === "CONTRACT_READY" || toPhase === "ROUTED" || toPhase === "EXECUTING") {
     try {
       await readContract(target, packageRoot);
@@ -127,7 +127,7 @@ async function assertPhasePrerequisites(target, state, toPhase, packageRoot) {
     throw phaseError("E_PHASE_EVIDENCE_MISSING", "COMPLETE requires verification evidence");
   }
   if (toPhase === "COMPLETE") {
-    const completion = await evaluateCompletion({ target, packageRoot, persist: false });
+    const completion = await evaluateCompletion({ target, packageRoot, persist: false, authorityContext, runtimeContext });
     if (completion.status !== "VALID") {
       throw phaseError("E_COMPLETION_REJECTED", "COMPLETE requires a valid completion audit", completion.errors.flatMap((error) => error.artifacts ?? []));
     }
@@ -136,11 +136,16 @@ async function assertPhasePrerequisites(target, state, toPhase, packageRoot) {
 
 export async function advanceWorkState(target, toPhase, options = {}) {
   const normalizedOptions = typeof options === "string" ? { packageRoot: options } : options;
-  const { packageRoot, now = new Date().toISOString() } = normalizedOptions;
+  const {
+    packageRoot,
+    now = new Date().toISOString(),
+    authorityContext,
+    runtimeContext,
+  } = normalizedOptions;
   assertWorkPhase(toPhase);
   const state = await readWorkState(target, packageRoot);
   if (!state) throw phaseError("E_PHASE_PREREQUISITE_MISSING", "Cannot advance without work state", [ARTIFACT_PATHS.state]);
-  await assertPhasePrerequisites(target, state, toPhase, packageRoot);
+  await assertPhasePrerequisites(target, state, toPhase, packageRoot, authorityContext, runtimeContext);
   await assertPersistedStateIdentity(target, state, toPhase, packageRoot);
   if (!isValidTransition(state.phase, toPhase)) {
     throw phaseError("E_PHASE_TRANSITION_INVALID", `Invalid work-state transition: ${state.phase} -> ${toPhase}`);
@@ -231,7 +236,12 @@ export async function advanceWorkState(target, toPhase, options = {}) {
       packageRoot,
       additionalEvidence: preflight.policy?.requiredEvidence ?? [],
     });
-    await validateReceipt(receipt.value, packageRoot);
+    await validateReceipt(receipt.value, packageRoot, {
+      target,
+      taskId: contract?.value?.taskId,
+      authorityContext,
+      runtimeContext,
+    });
     assertCompletionRelationships({
       contract,
       route,
@@ -240,12 +250,21 @@ export async function advanceWorkState(target, toPhase, options = {}) {
       requiredEvidence,
       requireRequiredChecks: false,
       requireReceiptStateFingerprint: false,
+      target,
+      taskId: contract?.value?.taskId,
+      authorityContext,
+      runtimeContext,
     });
     nextReceipt = await createReceipt({
       ...receipt.value,
       stateFingerprint: canonicalFingerprint(next),
       verificationCycle: next.verificationCycle ?? receipt.value.verificationCycle ?? 1,
-    }, packageRoot);
+    }, packageRoot, {
+      target,
+      taskId: contract?.value?.taskId,
+      authorityContext,
+      runtimeContext,
+    });
     assertCompletionRelationships({
       contract,
       route,
@@ -253,6 +272,10 @@ export async function advanceWorkState(target, toPhase, options = {}) {
       receipt: nextReceipt,
       requiredEvidence,
       requireRequiredChecks: false,
+      target,
+      taskId: contract?.value?.taskId,
+      authorityContext,
+      runtimeContext,
     });
   } catch (error) {
     if (error.code !== "ARTIFACT_MISSING") throw error;

package/src/core/protocol.js

@@ -81,6 +81,11 @@ export const FAILURE_CODES = Object.freeze([
   "E_TERMINAL_REQUIREMENT_NOT_TERMINAL",
   "E_TERMINAL_REQUIREMENT_TYPE_MISMATCH",
   "E_TERMINAL_STATUS_REGRESSION",
+  "E_INSTALLATION_AUTHORITY_REQUIRED",
+  "E_AUTHORITY_INVALID",
+  "E_AUTHORITY_SCOPE_MISMATCH",
+  "E_AUTHORITY_UNTRUSTED_SOURCE",
+  "E_VERIFICATION_TOOL_UNAVAILABLE",
 ]);
 
 export const WORK_PHASES = Object.freeze([

package/src/core/receipt.js

@@ -56,7 +56,7 @@ function assertKnownGuides(guides) {
   if (new Set(guides).size !== guides.length) throw new Error("Receipt selectedGuides must not contain duplicates");
 }
 
-export function assertReceiptSemantics(receipt) {
+export function assertReceiptSemantics(receipt, options = {}) {
   const evidence = receipt.evidence ?? [];
   if (receipt.verificationCycle !== undefined
     && (!Number.isInteger(receipt.verificationCycle) || receipt.verificationCycle < 1)) {
@@ -66,7 +66,7 @@ export function assertReceiptSemantics(receipt) {
 
   for (const [index, check] of receipt.checks.entries()) {
     if (check?.schemaVersion !== undefined || check?.id !== undefined || check?.evidenceKind !== undefined) {
-      assertCheck(check, `receipt.checks[${index}]`);
+      assertCheck(check, `receipt.checks[${index}]`, options);
       continue;
     }
     if (check?.status === "passed") {
@@ -132,15 +132,15 @@ export function assertReceiptSemantics(receipt) {
   return receipt;
 }
 
-export async function validateReceipt(receipt, packageRoot) {
+export async function validateReceipt(receipt, packageRoot, options = {}) {
   assertSecretFree(receipt);
   const schema = await readSchema("execution-receipt", packageRoot);
   assertSchema(receipt, schema, "execution receipt");
   assertKnownGuides(receipt.selectedGuides);
-  return assertReceiptSemantics(receipt);
+  return assertReceiptSemantics(receipt, options);
 }
 
-export async function createReceipt(input, packageRoot) {
+export async function createReceipt(input, packageRoot, options = {}) {
   assertSecretFree(input);
   const receipt = {
     schemaVersion: RECEIPT_SCHEMA_VERSION,
@@ -169,5 +169,5 @@ export async function createReceipt(input, packageRoot) {
       deployed: false,
     },
   };
-  return validateReceipt(receipt, packageRoot);
+  return validateReceipt(receipt, packageRoot, options);
 }

package/src/core/runtime-context.js

@@ -0,0 +1,80 @@
+export const AUTHORITY_TRUST_MODES = Object.freeze(["NONE", "HOST_ATTESTED"]);
+
+const AUTHORITY_CONTEXT_FIELDS = Object.freeze([
+  "trustedAuthorityFile",
+  "trustedAuthorityDir",
+  "authorities",
+  "authority",
+]);
+
+function configuredValue(value) {
+  return typeof value === "string" && value.trim() !== "" ? value.trim() : undefined;
+}
+
+function providerValue(provider) {
+  if (typeof provider === "function") return provider();
+  return provider && typeof provider === "object" && !Array.isArray(provider) ? provider : {};
+}
+
+function contextInput(input = {}) {
+  const source = input && typeof input === "object" && !Array.isArray(input) ? input : {};
+  const provider = providerValue(source.trustedAuthorityProvider);
+  const explicit = source.authorityContext && typeof source.authorityContext === "object"
+    ? source.authorityContext
+    : {};
+  const { authorityContext: _authorityContext, trustedAuthorityProvider: _trustedAuthorityProvider, ...direct } = source;
+  return { ...direct, ...provider, ...explicit };
+}
+
+export function hasAuthorityContext(options = {}) {
+  if (!options || typeof options !== "object") return false;
+  return Boolean(
+    options.authorityContext
+    || options.runtimeContext?.authorityContext
+    || (options.runtimeContext && typeof options.runtimeContext === "object" && options.runtimeContext.trustMode),
+  );
+}
+
+export function createAuthorityContext(input = {}) {
+  const values = contextInput(input);
+  const trustMode = values.trustMode ?? values.authorityTrustMode ?? "NONE";
+  if (!AUTHORITY_TRUST_MODES.includes(trustMode)) {
+    const error = new Error(`Unsupported authority trust mode: ${trustMode}`);
+    error.code = "E_AUTHORITY_INVALID";
+    throw error;
+  }
+
+  const context = { trustMode };
+  for (const field of AUTHORITY_CONTEXT_FIELDS) {
+    if (field === "trustedAuthorityFile" || field === "trustedAuthorityDir") {
+      const value = configuredValue(values[field]);
+      if (value !== undefined) context[field] = value;
+    } else if (values[field] !== undefined) {
+      context[field] = values[field];
+    }
+  }
+  return Object.freeze(context);
+}
+
+export function resolveAuthorityContext(options = {}) {
+  const source = options && typeof options === "object" && !Array.isArray(options) ? options : {};
+  if (source.authorityContext !== undefined) {
+    return createAuthorityContext(source.authorityContext);
+  }
+  if (source.runtimeContext?.authorityContext !== undefined) {
+    return createAuthorityContext(source.runtimeContext.authorityContext);
+  }
+  if (source.runtimeContext && typeof source.runtimeContext === "object" && source.runtimeContext.trustMode) {
+    return createAuthorityContext(source.runtimeContext);
+  }
+
+  const hasDirectAuthority = AUTHORITY_CONTEXT_FIELDS.some((field) => source[field] !== undefined);
+  // Direct resolver options are legacy source selectors, not a host attestation
+  // channel. They remain NONE unless wrapped in an explicit runtime context.
+  return hasDirectAuthority ? createAuthorityContext({ ...source, trustMode: "NONE" }) : createAuthorityContext();
+}
+
+export function createForgeLoopContext(options = {}) {
+  const authorityContext = createAuthorityContext(options);
+  return Object.freeze({ authorityContext });
+}