@cassiomc1/forgeloop 0.1.12 → 0.1.13

package/.cursor/rules/project-loop.mdc

@@ -16,7 +16,7 @@ Do not treat ForgeLoop as vendor-specific, optional, or to follow only "in spiri
 4. Respect higher-level and local instructions and the latest request.
 5. Make the minimum change, run specific checks, and run proportional regression checks.
 6. Diagnose failures before fixing them; do not repeat attempts without new evidence.
-7. Request authority for unrelated actions, installations, and publications. For missing Qwen-MM-Plugins, follow `LOOP_ENGINEERING.md`.
+7. Request authority for unrelated actions, installations, and publications. Do not install a missing verification tool merely to satisfy a check. For missing Qwen-MM-Plugins, follow `LOOP_ENGINEERING.md`.
 8. After implementation begins, do not return a final result in `EXECUTING`: advance through `VERIFYING` → structured evidence → `REVIEWING` → execution receipt → validator-backed `COMPLETE`. If closure cannot be reached, report `BLOCKED` or `PARTIALLY VERIFIED`.
 
 After implementation work for the current task is complete, run `forgeloop next` before returning a final result. Follow the returned lifecycle action until ForgeLoop reaches a terminal state or an explicit blocker.

package/.github/copilot-instructions.md

@@ -13,7 +13,7 @@ Use these instructions across the repository while preserving local rules.
 - Respect the latest request, scope, and higher-level instructions.
 - Make the smallest coherent change; validate with specific and regression checks.
 - Diagnose causes before fixing failures; do not make unverified attempts.
-- Do not install software, publish, delete, or alter external state without authority. For missing Qwen-MM-Plugins, follow `LOOP_ENGINEERING.md`.
+- Do not install software, publish, delete, or alter external state without authority. Do not install a missing verification tool merely to satisfy a check. For missing Qwen-MM-Plugins, follow `LOOP_ENGINEERING.md`.
 - After implementation begins, do not return a final result in `EXECUTING`: advance through `VERIFYING` → structured evidence → `REVIEWING` → execution receipt → validator-backed `COMPLETE`. If closure cannot be reached, report `BLOCKED` or `PARTIALLY VERIFIED`.
 
 After implementation work for the current task is complete, run `forgeloop next` before returning a final result. Follow the returned lifecycle action until ForgeLoop reaches a terminal state or an explicit blocker.

package/AGENTS.md

@@ -11,7 +11,7 @@ Do not treat ForgeLoop as vendor-specific, optional, or to follow only "in spiri
 1. Use [`GUIDE_ROUTER.md`](./GUIDE_ROUTER.md) to select relevant guides and report activated guide IDs.
 1. Make the smallest coherent change, run specific checks, and proportional regression checks.
 1. Diagnose failures before fixing; do not repeat attempts without new evidence.
-1. Do not install software, publish, delete, or migrate data without authority. For missing Qwen-MM-Plugins, follow `LOOP_ENGINEERING.md`.
+1. Do not install software, publish, delete, or migrate data without authority. Do not install a missing verification tool merely to satisfy a check. For missing Qwen-MM-Plugins, follow `LOOP_ENGINEERING.md`.
 1. Before implementation, create/validate `.forgeloop/current-contract.json`, persist routing, satisfy gates, and require `forgeloop preflight` to return `READY`.
 1. Before claiming `COMPLETE`, require `forgeloop complete` to return `VALID`; otherwise report completion as not protocol-verified.
 1. After implementation begins, do not return a final result in `EXECUTING`: advance through `VERIFYING` → structured evidence → `REVIEWING` → execution receipt → validator-backed `COMPLETE`. If closure cannot be reached, report `BLOCKED` or `PARTIALLY VERIFIED`.

package/CLAUDE.md

@@ -13,7 +13,7 @@ When working in this repository:
 1. Consult [`GUIDE_ROUTER.md`](./GUIDE_ROUTER.md), select relevant guides, and announce their IDs.
 1. Make small changes, run specific checks, and run proportional regression checks.
 1. Investigate root causes before fixing failures; do not make unverified attempts.
-1. Request authority for unrelated installations, publications, deletions, or migrations. For missing Qwen-MM-Plugins, follow `LOOP_ENGINEERING.md`.
+1. Request authority for unrelated installations, publications, deletions, or migrations. Do not install a missing verification tool merely to satisfy a check. For missing Qwen-MM-Plugins, follow `LOOP_ENGINEERING.md`.
 1. After implementation begins, do not return a final result in `EXECUTING`: advance through `VERIFYING` → structured evidence → `REVIEWING` → execution receipt → validator-backed `COMPLETE`. If closure cannot be reached, report `BLOCKED` or `PARTIALLY VERIFIED`.
 1. After implementation work for the current task is complete, run `forgeloop next` before returning a final result. Follow the returned lifecycle action until ForgeLoop reaches a terminal state or an explicit blocker.
 1. Report current evidence, limitations, and publication state without claiming checks that were not run.

package/LOOP_ENGINEERING.md

@@ -68,6 +68,46 @@ If the required CLI/API capability cannot be resolved:
 Report the corresponding ForgeLoop dimension as `NOT_VERIFIED` with
 `E_FORGELOOP_CLI_UNAVAILABLE`.
 
+### Missing verification tool policy
+
+A missing verification tool does not grant authority to install it.
+
+When a verification command or checker is unavailable:
+
+1. Try only already-installed or explicitly non-installing resolution paths.
+2. Prefer an already available equivalent when it can verify the same requirement.
+3. If no suitable local capability exists, request explicit installation authority
+   only when the missing verification is genuinely required.
+4. If authority is unavailable or the check is non-critical, record the affected
+   verification dimension as `NOT_VERIFIED` with `E_VERIFICATION_TOOL_UNAVAILABLE`.
+
+Do not retry a failed non-installing lookup with a command that implicitly
+downloads or installs the missing package.
+
+Examples of forbidden escalation without authority:
+
+```text
+npx --no-install TOOL → missing
+npx TOOL              → implicit install
+```
+
+```text
+command -v TOOL → missing
+package-manager install TOOL
+```
+
+```text
+local executable missing
+curl | sh
+```
+
+Automatic installation is allowed only when an explicit ForgeLoop rule grants
+that exact task-scoped installation authority and higher-priority platform/user
+rules permit it.
+
+A missing checker must never be converted into environmental mutation merely
+to make verification pass.
+
 ## Blocking vs Non-Blocking Decisions
 
 Classify every unresolved decision before deciding whether to ask the user.

package/LOOP_SYSTEM_DESIGN.md

@@ -10,11 +10,13 @@ The system should use every guide that materially helps the task without loading
 
 ## Primary decisions
 
-- The package supports Codex, Claude Code, Cursor, GitHub Copilot, Antigravity,
-  OpenCode, Hermes, Pi, Command Code, and Freebuff.
-- Codex, Claude Code, Cursor, and GitHub Copilot use native entry files; the
-  other six agents consume the shared `AGENTS.md` entry point.
-- The portable instruction layer uses Markdown and each agent's native instruction mechanism; the optional local Node CLI validates and installs the kit without an agent runtime or third-party dependency.
+- The protocol is vendor-neutral, project-scoped, and capability-based,
+  supporting any AI agent, coding assistant, IDE runtime, or developer workflow.
+- Common discovery surfaces (e.g. `AGENTS.md`, `CLAUDE.md`, `.cursor/rules/`,
+  `.github/copilot-instructions.md`) use project-local shims delegating to the
+  canonical protocol under `.forgeloop/kit/`, while other environments use the
+  shared `AGENTS.md` entry point or manual bootstrap.
+- The portable instruction layer uses Markdown and each environment's native instruction mechanism; the optional local Node CLI validates and installs the kit without an agent runtime or third-party dependency.
 - English is the only language used by repository content and guide metadata.
 - The agent uses all applicable guides, not every file indiscriminately.
 - Design, planning, test-first, and review process gates live in the canonical loop and scale with task risk instead of becoming unconditional boilerplate in every adapter or architecture note.
@@ -389,8 +391,8 @@ update practice.
 ## Acceptance criteria
 
 - The repository and its maintained content are English-only.
-- All ten supported agents have a documented entry into one canonical loop,
-  with native adapters distinguished from shared `AGENTS.md` compatibility.
+- Common project instruction surfaces and generic bootstrap mechanisms have a
+  documented entry into one canonical loop.
 - The router selects every relevant guide and excludes irrelevant guides in the six defined scenarios.
 - The profile contains verifiable facts, sources, and real commands without secrets.
 - The loop requires evidence before completion claims and exits safely when blocked.

package/PROTOCOL_INTEGRATION.md

@@ -140,6 +140,21 @@ If the required CLI or API capability cannot be resolved:
 
 Report the corresponding ForgeLoop dimension as `NOT_VERIFIED` / `E_FORGELOOP_CLI_UNAVAILABLE`.
 
+## Missing tool capability
+
+A missing tool is a capability gap, not installation authority.
+
+If an expected verifier, browser tool, linter, analyzer, or test dependency is
+not already available:
+
+- use a suitable existing local equivalent when possible;
+- otherwise request authority if installation is necessary and allowed;
+- otherwise report the affected verification dimension as not verified with
+  `E_VERIFICATION_TOOL_UNAVAILABLE`.
+
+Never convert `PROTOCOL_LIMITED` into environmental mutation by implicitly
+installing a package.
+
 ## Optional capability extensions
 
 The installed loop directs the active actor to inspect native model and harness
@@ -150,6 +165,19 @@ through native mechanisms or upstream installers, then verify it before use.
 API credentials, system packages, and unrelated environment changes remain
 separately gated.
 
+## Delegation scope
+
+Delegation is optional.
+
+A run that contains no delegation events, no delegated task references, and no
+delegation artifacts is a valid single-actor run.
+
+Missing delegation artifacts must not make such a run incomplete. For a purely
+local single-actor lifecycle, the delegation dimension is `NOT_APPLICABLE`.
+
+Once delegation is observed in canonical state, receipt, or event history, the
+required delegation artifacts become mandatory.
+
 ## Instruction precedence
 
 When multiple instruction layers exist, follow standard precedence:

package/README.md

@@ -1,26 +1,18 @@
-# ForgeLoop — Instruction Guides for AI Agents
+# ForgeLoop — Verifiable Engineering Protocol
 
 [![Docs quality](https://github.com/cassiomc1/forgeloop/actions/workflows/docs-quality.yml/badge.svg?branch=main)](https://github.com/cassiomc1/forgeloop/actions/workflows/docs-quality.yml)
 
-An English-only collection of operational guides for AI agents and developers.
-It covers product strategy, code, testing, security, performance,
-accessibility, design, and web games across web, mobile, and desktop projects.
+ForgeLoop is a portable, verifiable engineering protocol for AI-assisted development and developer workflows.
 
-The files are Markdown and can be used as references, as a foundation for
-`AGENTS.md`, `CLAUDE.md`, `.cursor/rules`, and
-`.github/copilot-instructions.md`. The integration contract and capability levels are documented
-in [`PROTOCOL_INTEGRATION.md`](./PROTOCOL_INTEGRATION.md). Adopt only the guides
-relevant to the target project.
+It is project-scoped, capability-based, and vendor-neutral. It turns intent into contract-driven execution with deterministic routing, resumable state, evidence-backed verification, recovery, and validator-backed completion.
 
-ForgeLoop is a portable, verifiable engineering protocol for AI coding environments
-and developer workflows. It turns intent into contract-driven execution with
-deterministic routing, resumable state, evidence-backed verification, recovery, and
-validator-backed completion.
+ForgeLoop does not depend on a specific model, provider, agent product, IDE, or orchestration runtime.
 
-The npm package also ships the local `forgeloop` CLI. In a target project it
-installs canonical documents under `.forgeloop/kit/`, keeps only small native
-discovery shims at the root, and stores mutable protocol artifacts under
-`.forgeloop/`.
+The repository also provides an English-only collection of operational engineering guides covering product strategy, clean code, testing, security, performance, accessibility, visual design, and web games across web, mobile, and desktop projects.
+
+Project-local discovery surfaces (`AGENTS.md`, `CLAUDE.md`, `.cursor/rules/project-loop.mdc`, `.github/copilot-instructions.md`) and manual bootstrap paths delegate to the same canonical protocol in `.forgeloop/kit/`. The capability levels and integration contract are documented in [`PROTOCOL_INTEGRATION.md`](./PROTOCOL_INTEGRATION.md). Adopt only the guides relevant to the target project.
+
+The npm package also ships the local `forgeloop` CLI. In a target project it installs canonical documents under `.forgeloop/kit/`, keeps only small native discovery shims at the root, and stores mutable protocol artifacts under `.forgeloop/`.
 
 ## Catalog
 
@@ -88,13 +80,13 @@ Request → discovery → profile → routing → plan → execution
               └ evidence-only rejection / next cycle
 ```
 
-ForgeLoop is project-scoped, capability-based, and vendor-neutral. Thin
-native adapters support common discovery surfaces including Codex, Claude Code,
-Cursor, and GitHub Copilot, while Antigravity, OpenCode, Hermes, Pi, Command Code,
-Freebuff, custom agents, and developer workflows discover the shared `AGENTS.md`
-entry point or manual bootstrap. All environments delegate to the same canonical
-protocol; see [`PROTOCOL_INTEGRATION.md`](./PROTOCOL_INTEGRATION.md) for
-capability levels, degradation rules, and precedence notes.
+ForgeLoop is project-scoped, capability-based, and vendor-neutral.
+
+Project-local discovery surfaces delegate to the same canonical ForgeLoop protocol. Execution environments that automatically discover one of those instruction surfaces can use it directly, while custom runtimes, automation systems, and developer workflows can use the manual bootstrap path.
+
+Capabilities determine execution. Runtime names do not determine protocol applicability.
+
+See [`PROTOCOL_INTEGRATION.md`](./PROTOCOL_INTEGRATION.md) for discovery, capability levels, degradation rules, and precedence.
 
 ### Migration recovery and release freeze
 
@@ -117,12 +109,11 @@ 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.11`.
-Earlier `0.1.8`, `0.1.9`, and `0.1.10` references are historical; never move
-their tags or `v0.1.10`. Version `0.1.11` adds canonical evidence readiness,
-requirement-specific terminal result recording, legal repeated verification
-cycles, future-result and compound-evidence safeguards, and lifecycle-ledger
-divergence detection.
+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.
 
 ## How to prompt ForgeLoop
 
@@ -212,12 +203,12 @@ 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.11`.
+The current published release is `@cassiomc1/forgeloop@0.1.13`.
 Pin this version when a reproducible blind run or release-identity check is
 required:
 
 ```bash
-npx @cassiomc1/forgeloop@0.1.11 --version
+npx @cassiomc1/forgeloop@0.1.13 --version
 npx @cassiomc1/forgeloop init
 npx @cassiomc1/forgeloop doctor
 npx @cassiomc1/forgeloop update
@@ -314,11 +305,13 @@ cross-artifact relationships plus the same derived freshness classification
 used by `inspect` and `status`. Supply `--contract-file` to compare the saved
 contract fingerprint with the current contract; omitting it leaves contract
 freshness as `NOT_VERIFIED` and a complete artifact set requires revalidation.
-When delegation is in scope, also supply the matching repeated
-`--task-brief <path>` and `--delegated-result <path>` inputs. Without those
-inputs it reports `INCOMPLETE` with
-`task briefs and delegated results were not supplied`; that classification is
-separate from a local `complete --json` result of `VALID`.
+Delegation artifacts are required only when delegation is present in the
+canonical execution history or explicitly supplied as part of a delegated run.
+For a purely local single-actor lifecycle, the delegation dimension is
+`NOT_APPLICABLE` and does not require task briefs or delegated results. When
+delegation is in scope, also supply the matching repeated
+`--task-brief <path>` and `--delegated-result <path>` inputs; omitting them in a
+delegated run reports `INCOMPLETE`.
 It returns `VALID`, `INCOMPLETE`, `STALE`, `INCONSISTENT`, or `INVALID` with
 exact invariant codes and derived stale reasons. The persisted
 `.forgeloop/work-state.json` schema is unchanged: `status`, `stale`, and `fresh`
@@ -575,8 +568,8 @@ installed automatically.
 
 ## Optional multimodal capabilities
 
-[Qwen-MM-Plugins](https://github.com/QwenLM/Qwen-MM-Plugins) can extend a
-supported agent harness with skills and optional MCP servers. Before using a
+[Qwen-MM-Plugins](https://github.com/QwenLM/Qwen-MM-Plugins) can extend an
+execution environment with skills and optional MCP servers. Before using a
 multimodal or media operation, the agent checks the model and harness for a
 callable native capability. If the task requires a missing keyless capability,
 the agent installs only the smallest matching `qwen-mm-plugins-<cap>` capability

package/THREAT_MODEL.md

@@ -33,6 +33,8 @@ remaining trust boundaries and their executable evidence.
 | Runtime self-exemption | An execution environment discovers ForgeLoop but decides that the protocol does not apply because the environment is not named in documentation | Project adapter discovery and runtime interpretation | Universal applicability marker, capability-based integration, explicit unknown-runtime rule, no finite eligibility allowlist | A non-compliant runtime can ignore project instructions entirely | `tests/discovery-surfaces.test.js`, `tests/test_workflow_policy.py` |
 | Blind oracle exposure | The system under test reads expected route/gate/evidence answers from the installed package and contaminates a blind conformance run | Published npm package and agent-readable target workspace | Exclude conformance oracles from npm package, tarball leak scan in `pack:check`, external harness-owned oracle | A misconfigured external harness may still copy oracle material into target | `tests/package.test.js`, `conformance/README.md` |
 | 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` |
 
 ## Boundary rules
 

package/package.json

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

package/src/commands/validate-protocol.js

@@ -97,14 +97,6 @@ export async function runValidateProtocol({
   const stateClassification = state && readErrors.length === 0 && !stateValidationError
     ? await classifyLoadedWorkState({ target, state, contractFile })
     : null;
-  const result = validateTaskArtifactSet({
-    route,
-    state,
-    stateClassification,
-    receipt,
-    taskBriefs,
-    delegatedResults,
-  });
   let readyConsistencyErrors = [];
   try {
     const persistedPreflight = await readJsonArtifact(target, ARTIFACT_PATHS.preflight, "preflight", packageRoot);
@@ -119,9 +111,11 @@ export async function runValidateProtocol({
   } catch {
     // A missing or invalid preflight is already outside the optional protocol set.
   }
+  let ledgerEvents = [];
   let ledgerErrors = [];
   if (state && !stateValidationError) {
     const ledger = await validateEventLedger(target, packageRoot);
+    ledgerEvents = ledger.events ?? [];
     ledgerErrors = [
       ...ledger.errors.map((error) => ({ ...error, artifacts: [ARTIFACT_PATHS.events] })),
       ...validateStateLedgerCoherence(state, ledger.events).map((error) => ({
@@ -130,6 +124,15 @@ export async function runValidateProtocol({
       })),
     ];
   }
+  const result = validateTaskArtifactSet({
+    route,
+    state,
+    stateClassification,
+    receipt,
+    taskBriefs,
+    delegatedResults,
+    events: ledgerEvents,
+  });
   if (readErrors.length > 0 || schemaErrors.length > 0 || readyConsistencyErrors.length > 0 || ledgerErrors.length > 0) {
     return {
       ...result,

package/src/core/conformance.js

@@ -23,6 +23,24 @@ function sortErrors(errors) {
     || left.message.localeCompare(right.message));
 }
 
+export function delegationIsInScope({
+  state = null,
+  receipt = null,
+  events = [],
+  taskBriefs = [],
+  delegatedResults = [],
+} = {}) {
+  if (taskBriefs && taskBriefs.length > 0) return true;
+  if (delegatedResults && delegatedResults.length > 0) return true;
+  if (state?.delegatedTasks && state.delegatedTasks.length > 0) return true;
+  if (state?.delegatedTaskIds && state.delegatedTaskIds.length > 0) return true;
+  if (receipt?.delegatedTasks && receipt.delegatedTasks.length > 0) return true;
+  if (Array.isArray(events) && events.some((event) => typeof event?.type === "string" && event.type.toLowerCase().includes("delegat"))) {
+    return true;
+  }
+  return false;
+}
+
 export function validateTaskArtifactSet({
   route = null,
   state = null,
@@ -30,6 +48,7 @@ export function validateTaskArtifactSet({
   receipt = null,
   taskBriefs = [],
   delegatedResults = [],
+  events = [],
 } = {}) {
   const errors = [];
   const incomplete = [];
@@ -62,6 +81,7 @@ export function validateTaskArtifactSet({
     errors.push(error("STATE_RECEIPT_GUIDES_MISMATCH", "execution-receipt.selectedGuides must equal work-state.selectedGuides", ["state", "receipt"]));
   }
 
+  const delegationActive = delegationIsInScope({ state, receipt, events, taskBriefs, delegatedResults });
   const briefIds = new Set();
   for (const brief of taskBriefs) {
     if (!brief?.taskId) continue;
@@ -86,13 +106,18 @@ export function validateTaskArtifactSet({
     }
   }
 
-  if (taskBriefs.length > 0) {
-    for (const taskId of [...briefIds].sort()) {
-      if (!delegatedIds.has(taskId)) incomplete.push(`missing delegated result: ${taskId}`);
+  if (delegationActive) {
+    if (taskBriefs.length > 0) {
+      for (const taskId of [...briefIds].sort()) {
+        if (!delegatedIds.has(taskId)) incomplete.push(`missing delegated result: ${taskId}`);
+      }
+    } else if (delegatedResults.length > 0) {
+      incomplete.push("task briefs are required when delegated results are supplied");
+    } else {
+      incomplete.push("task briefs and delegated results were not supplied for delegated task");
     }
-  } else if (delegatedResults.length === 0) {
-    incomplete.push("task briefs and delegated results were not supplied");
   }
+
   if (!route || !state || !receipt) incomplete.push("route, state, and receipt are all required for a complete artifact set");
 
   const sortedErrors = sortErrors(errors);
@@ -117,6 +142,22 @@ export function validateTaskArtifactSet({
     }
     : null;
 
+  const delegation = delegationActive
+    ? {
+      status: sortedErrors.some((e) => e.code.includes("DELEGAT") || e.code.includes("TASK"))
+        ? "INCONSISTENT"
+        : incomplete.some((i) => i.includes("delegat") || i.includes("brief"))
+          ? "INCOMPLETE"
+          : "VALID",
+      required: true,
+      errors: sortedErrors.filter((e) => e.code.includes("DELEGAT") || e.code.includes("TASK")),
+    }
+    : {
+      status: "NOT_APPLICABLE",
+      required: false,
+      errors: [],
+    };
+
   const evidenceKind = status === "VALID"
     ? "OBSERVED"
     : status === "INCOMPLETE"
@@ -131,6 +172,7 @@ export function validateTaskArtifactSet({
     errors: sortedErrors,
     incomplete: [...new Set(incomplete)].sort(),
     stale,
+    delegation,
     evidence: [createEvidence({
       kind: evidenceKind,
       source: "ForgeLoop protocol conformance",

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/verification-capability.js

@@ -0,0 +1,47 @@
+export const E_VERIFICATION_TOOL_UNAVAILABLE = "E_VERIFICATION_TOOL_UNAVAILABLE";
+export const E_INSTALLATION_AUTHORITY_REQUIRED = "E_INSTALLATION_AUTHORITY_REQUIRED";
+
+export function classifyVerificationCapability({
+  available = false,
+  equivalentAvailable = false,
+  installationAuthorized = false,
+  installationRequired = false,
+} = {}) {
+  if (available) {
+    return {
+      action: "USE_AVAILABLE",
+      reasonCode: null,
+      message: "Verification tool is locally available.",
+    };
+  }
+
+  if (equivalentAvailable) {
+    return {
+      action: "USE_EQUIVALENT",
+      reasonCode: null,
+      message: "An existing local equivalent verifier is available.",
+    };
+  }
+
+  if (installationAuthorized) {
+    return {
+      action: "INSTALL_AUTHORIZED",
+      reasonCode: null,
+      message: "Installation is explicitly authorized for this verification requirement.",
+    };
+  }
+
+  if (installationRequired) {
+    return {
+      action: "REQUEST_AUTHORITY",
+      reasonCode: E_INSTALLATION_AUTHORITY_REQUIRED,
+      message: "Verification tool is required but installation authority has not been granted.",
+    };
+  }
+
+  return {
+    action: "RECORD_NOT_VERIFIED",
+    reasonCode: E_VERIFICATION_TOOL_UNAVAILABLE,
+    message: "Verification tool is absent and installation was not authorized.",
+  };
+}