create-agdf 0.14.1 → 0.14.3

package/generated/plugins/agdf/runtime/create-agdf/lib/delivery-path-search/search-engine.js

@@ -1,4 +1,4 @@
-import { CONTRACT_VERSION, SCORING_POLICY_VERSION, validateEvaluation, validateSearchInput } from "./contracts.js";
+import { CONTRACT_VERSION, SCORING_POLICY_VERSION, validateEvaluation, validateSearchInput, validateSearchResult } from "./contracts.js";
 import { candidateLegality, candidatesFromInput, generatedCandidatesFromResponse } from "./candidate-policy.js";
 import { scoreEvaluation } from "./scoring.js";
 import { generatorRequestFromInput } from "./state-adapter.js";
@@ -14,6 +14,30 @@ function generatorFailureCode(error) {
   return "generator_schema_invalid";
 }
 
+function evaluatorFailureCode(error) {
+  if (error?.code === "ENOENT") return "evaluator_unavailable";
+  if (/auth/i.test(error?.message ?? "")) return "evaluator_authentication_failed";
+  if (/unavailable|not found|not configured/i.test(error?.message ?? "")) return "evaluator_unavailable";
+  return "evaluator_output_invalid";
+}
+
+export function classifyTerminalOutcome({
+  inputUnavailable = false,
+  legalCandidates = 0,
+  evaluationAttempts = 0,
+  validEvaluations = 0,
+  invalidEvaluations = 0,
+  evaluatorUnavailable = false,
+  leader = null,
+}) {
+  if (inputUnavailable) return { status: "input_unavailable", outcome_phase: "input" };
+  if (legalCandidates === 0) return { status: "no_legal_candidates", outcome_phase: "candidate" };
+  if (validEvaluations === 0 && evaluatorUnavailable) return { status: "evaluator_unavailable", outcome_phase: "evaluation" };
+  if (validEvaluations === 0 && legalCandidates > 0) return { status: "evaluator_error", outcome_phase: "evaluation" };
+  if (leader) return { status: "recommendation", outcome_phase: "search" };
+  return { status: "no_safe_recommendation", outcome_phase: "search" };
+}
+
 export async function runDeliveryPathSearch(inputValue, evaluator, options = {}) {
   const input = validateSearchInput(inputValue);
   const startedAt = Date.now();
@@ -22,12 +46,18 @@ export async function runDeliveryPathSearch(inputValue, evaluator, options = {})
   const rejected = [];
   const evaluated = [];
   let evaluations = 0;
+  let evaluationAttempts = 0;
+  let invalidEvaluations = 0;
+  let legalCandidates = 0;
+  let rejectedCandidates = 0;
+  let evaluatorUnavailable = false;
+  let evaluationFailureCode = null;
   let costUnits = 0;
   let lastLeaderId = null;
   let stableComparisons = 0;
   let stoppingReason = "candidate_queue_exhausted";
   const generation = {
-    status: input.generation?.enabled ? "failed" : "disabled",
+    status: input.generation?.enabled ? "not_run" : "disabled",
     adapter: options.generator?.metadata ?? null,
     budgets: input.generation ?? null,
     returned: 0,
@@ -38,7 +68,66 @@ export async function runDeliveryPathSearch(inputValue, evaluator, options = {})
     failure_code: null,
   };
 
+  const finish = ({ leader = null, outcome, failureCode = null, recoveryAction = null }) => {
+    evaluated.sort((a, b) => b.score - a.score || a.candidate.id.localeCompare(b.candidate.id));
+    const result = {
+      contract_version: CONTRACT_VERSION,
+      scoring_policy_version: SCORING_POLICY_VERSION,
+      scope_key: input.scope_key,
+      scope_revision: input.scope_revision ?? "unversioned",
+      objective: input.objective,
+      current_gate: input.current_gate,
+      outcome_phase: outcome.outcome_phase,
+      status: outcome.status,
+      recommendation: outcome.status === "recommendation" && leader ? {
+        candidate_id: leader.candidate.id,
+        action: leader.candidate.action,
+        score: leader.score,
+        rationale: leader.evaluation.rationale,
+        expected_evidence: leader.candidate.expected_evidence,
+        tests: leader.candidate.tests,
+        risks: leader.evaluation.risks,
+        assumptions: leader.evaluation.assumptions,
+      } : null,
+      alternatives: outcome.outcome_phase === "search" ? evaluated.slice(1).map((item) => ({
+        candidate_id: item.candidate.id,
+        action: item.candidate.action,
+        score: item.score,
+        rejection_reason: `ranked_below_${leader?.candidate.id ?? "search_policy"}`,
+      })) : [],
+      rejected,
+      provenance: {
+        baseline_candidates: baseline.length,
+        generated_candidates: generation.accepted,
+        legal_candidates: legalCandidates,
+        rejected_candidates: rejectedCandidates + generation.rejected.length,
+        evaluation_attempts: evaluationAttempts,
+        valid_evaluations: evaluations,
+        invalid_evaluations: invalidEvaluations,
+      },
+      enforcement: input.enforcement,
+      evaluator: evaluator?.metadata ?? { name: evaluator?.name ?? "unknown" },
+      generation,
+      budgets: { configured: input.budgets, evaluations, cost_units: costUnits, stable_comparisons: stableComparisons, duration_ms: Date.now() - startedAt },
+      stopping_reason: stoppingReason,
+      failure_code: failureCode,
+      next_action: recoveryAction ?? "Run canonical AGDF gate-check; search does not grant permission.",
+      next_gate_action: recoveryAction ?? "Run canonical AGDF gate-check; search does not grant permission.",
+    };
+    return validateSearchResult(result);
+  };
+
+  if (input.input_failure_code || input.allowed_actions.length === 0) {
+    stoppingReason = input.input_failure_code || "canonical_actions_unavailable";
+    return finish({
+      outcome: classifyTerminalOutcome({ inputUnavailable: true }),
+      failureCode: input.input_failure_code || "canonical_actions_unavailable",
+      recoveryAction: input.input_recovery_action || "Run canonical AGDF gate-check and repair the selected control state.",
+    });
+  }
+
   if (input.generation?.enabled) {
+    generation.status = "failed";
     if (!options.generator) {
       generation.failure_code = "generator_unavailable";
     } else {
@@ -75,17 +164,20 @@ export async function runDeliveryPathSearch(inputValue, evaluator, options = {})
   }
 
   while (queue.length > 0) {
-    if (evaluations >= input.budgets.max_evaluations) { stoppingReason = "evaluation_budget_exhausted"; break; }
-    if (costUnits >= input.budgets.max_cost_units) { stoppingReason = "cost_budget_exhausted"; break; }
-    if (Date.now() - startedAt >= input.budgets.max_duration_ms) { stoppingReason = "duration_budget_exhausted"; break; }
     const candidate = queue.shift();
     const legality = candidateLegality(candidate, input);
     if (!legality.legal) {
+      rejectedCandidates += 1;
       rejected.push({ candidate_id: candidate.id, action: candidate.action, reason: legality.reason });
       continue;
     }
+    legalCandidates += 1;
+    if (evaluations >= input.budgets.max_evaluations) { stoppingReason = "evaluation_budget_exhausted"; evaluationFailureCode = stoppingReason; break; }
+    if (costUnits >= input.budgets.max_cost_units) { stoppingReason = "cost_budget_exhausted"; evaluationFailureCode = stoppingReason; break; }
+    if (Date.now() - startedAt >= input.budgets.max_duration_ms) { stoppingReason = "duration_budget_exhausted"; evaluationFailureCode = stoppingReason; break; }
 
     try {
+      evaluationAttempts += 1;
       const evaluation = validateEvaluation(await evaluator.evaluate(input, candidate), candidate.id);
       evaluations += 1;
       costUnits += evaluation.cost;
@@ -115,41 +207,39 @@ export async function runDeliveryPathSearch(inputValue, evaluator, options = {})
       }
     } catch (error) {
       if (error?.fatalEvaluator === true) throw error;
+      invalidEvaluations += 1;
+      evaluationFailureCode = evaluatorFailureCode(error);
+      evaluatorUnavailable ||= evaluationFailureCode === "evaluator_unavailable" || evaluationFailureCode === "evaluator_authentication_failed";
       rejected.push({ candidate_id: candidate.id, action: candidate.action, reason: `invalid_evaluation: ${error.message}` });
+      if (evaluatorUnavailable) break;
     }
   }
 
   evaluated.sort((a, b) => b.score - a.score || a.candidate.id.localeCompare(b.candidate.id));
   const leader = evaluated[0];
-  if (!leader) stoppingReason = rejected.length ? "no_safe_candidate" : stoppingReason;
-  return {
-    contract_version: CONTRACT_VERSION,
-    scoring_policy_version: SCORING_POLICY_VERSION,
-    scope_key: input.scope_key,
-    current_gate: input.current_gate,
-    status: leader ? "recommendation" : "no_safe_recommendation",
-    recommendation: leader ? {
-      candidate_id: leader.candidate.id,
-      action: leader.candidate.action,
-      score: leader.score,
-      rationale: leader.evaluation.rationale,
-      expected_evidence: leader.candidate.expected_evidence,
-      tests: leader.candidate.tests,
-      risks: leader.evaluation.risks,
-      assumptions: leader.evaluation.assumptions,
-    } : null,
-    alternatives: evaluated.slice(1).map((item) => ({
-      candidate_id: item.candidate.id,
-      action: item.candidate.action,
-      score: item.score,
-      rejection_reason: `ranked_below_${leader?.candidate.id ?? "safety_threshold"}`,
-    })),
-    rejected,
-    enforcement: input.enforcement,
-    evaluator: evaluator.metadata ?? { name: evaluator.name ?? "unknown" },
-    generation,
-    budgets: { configured: input.budgets, evaluations, cost_units: costUnits, stable_comparisons: stableComparisons, duration_ms: Date.now() - startedAt },
-    stopping_reason: stoppingReason,
-    next_gate_action: "Run canonical AGDF gate-check; search does not grant permission.",
-  };
+  const outcome = classifyTerminalOutcome({
+    legalCandidates,
+    evaluationAttempts,
+    validEvaluations: evaluations,
+    invalidEvaluations,
+    evaluatorUnavailable,
+    leader,
+  });
+  if (!leader) {
+    stoppingReason = outcome.status === "no_legal_candidates"
+      ? "no_legal_candidates"
+      : outcome.status === "evaluator_unavailable"
+        ? "evaluator_unavailable"
+        : outcome.status === "evaluator_error"
+          ? "evaluator_error"
+          : stoppingReason;
+  }
+  return finish({
+    leader,
+    outcome,
+    failureCode: outcome.outcome_phase === "evaluation" ? evaluationFailureCode : null,
+    recoveryAction: outcome.outcome_phase === "evaluation"
+      ? "Repair the declared evaluator capability and retry from a fresh canonical control snapshot."
+      : null,
+  });
 }

package/generated/plugins/agdf/runtime/create-agdf/lib/delivery-path-search/state-adapter.js

@@ -1,11 +1,10 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
 import {
   CONTRACT_VERSION,
   GENERATOR_CONTRACT_VERSION,
   validateGeneratorRequest,
 } from "./contracts.js";
-import { resolveRuns, verifyLegacyProjection } from "../control-state/index.js";
+import { evaluateGateCheck } from "../control-evaluation/gate-check.js";
+import { readRunState } from "../control-evaluation/run-state.js";
 
 function section(content, heading) {
   return (
@@ -15,100 +14,44 @@ function section(content, heading) {
   );
 }
 
-function tableAnswers(content) {
-  const answers = {};
-  for (const line of section(content, "Current Control State").split(/\r?\n/)) {
-    const cells = line
-      .split("|")
-      .slice(1, -1)
-      .map((cell) => cell.trim());
-    if (
-      cells.length >= 2 &&
-      cells[0] &&
-      !cells[0].startsWith("---") &&
-      cells[0] !== "Question"
-    )
-      answers[cells[0]] = cells[1];
-  }
-  return answers;
-}
-
-function statusCard(content) {
-  const card = {};
-  for (const line of section(content, "Run Status Card").split(/\r?\n/)) {
-    const cells = line
-      .split("|")
-      .slice(1, -1)
-      .map((cell) => cell.trim().replace(/^`|`$/g, ""));
-    if (
-      cells.length >= 2 &&
-      cells[0] &&
-      !cells[0].startsWith("---") &&
-      cells[0] !== "Run status"
-    )
-      card[cells[0]] = cells[1];
-  }
-  return card;
+function metaField(content, name) {
+  return content.match(new RegExp(`^- ${name}:\\s*(.+)$`, "m"))?.[1]
+    ?.replace(/^`|`$/g, "")
+    .trim() ?? "";
 }
 
-function listCell(value) {
-  return String(value ?? "")
-    .split(/\s*;\s*/)
-    .map((item) => item.trim())
-    .filter(Boolean);
-}
-
-export function searchInputFromControl(targetDir, options = {}) {
-  const canonicalRoot = join(targetDir, ".agdf", "control", "runs");
-  if (existsSync(canonicalRoot)) {
-    const projection = verifyLegacyProjection(targetDir);
-    if (!["absent", "valid"].includes(projection.status)) {
-      throw new Error(`AGDF_LEGACY_PROJECTION_DRIFT:${projection.status}`);
-    }
+export function searchInputFromControl(targetDir, options = {}, dependencies = {}) {
+  const evaluate = dependencies.evaluateGateCheck ?? evaluateGateCheck;
+  const readRun = dependencies.readRunState ?? readRunState;
+  const selection = options.scopeKey ? { runId: options.scopeKey } : {};
+  const gate = evaluate(targetDir, selection);
+  const run = readRun(targetDir, selection);
+  const content = run.content ?? "";
+  const evaluatedRunId = gate.status_card?.run_id ?? "";
+  const evaluatedRevision = gate.status_presentation?.revision_id ?? "";
+  const runId = metaField(content, "run_id");
+  const runRevision = metaField(content, "revision_id");
+  const runGate = metaField(content, "current_gate");
+  let inputFailureCode = "";
+  if (!content || run.resolution_error) inputFailureCode = "canonical_control_unavailable";
+  else if (!evaluatedRunId || !evaluatedRevision) inputFailureCode = "canonical_snapshot_identity_missing";
+  else if (evaluatedRunId !== runId || evaluatedRevision !== runRevision || gate.current_gate !== runGate) {
+    inputFailureCode = "stale_control_snapshot";
+  } else if (!Array.isArray(gate.allowed) || gate.allowed.length === 0) {
+    inputFailureCode = "canonical_actions_unavailable";
   }
-  const resolved = existsSync(canonicalRoot)
-    ? resolveRuns(targetDir, {
-        runIdArg: options.scopeKey,
-        runIdEnv: process.env.AGDF_RUN_ID,
-      })
-    : null;
-  const runPath =
-    resolved?.run.path ?? join(targetDir, ".agdf", "control", "AGDF_RUN.md");
-  if (!existsSync(runPath)) throw new Error("missing AGDF run state");
-  const content = readFileSync(runPath, "utf8");
-  const meta = Object.fromEntries(
-    [...content.matchAll(/^- ([a-z_]+):\s*(.+)$/gm)].map((match) => [
-      match[1],
-      match[2].replace(/^`|`$/g, "").trim(),
-    ]),
-  );
-  const answers = tableAnswers(content);
-  const card = statusCard(content);
   const result = {
     contract_version: CONTRACT_VERSION,
-    scope_key: options.scopeKey ?? meta.run_id ?? "unknown-scope",
-    objective: section(content, "Objective").trim(),
-    current_gate: card["Current gate"] ?? meta.current_gate ?? "unknown",
-    allowed_actions: options.allowedActions ?? listCell(card["Allowed now"]),
-    forbidden_actions:
-      options.forbiddenActions ??
-      listCell(answers["What is explicitly forbidden right now?"]),
-    evidence_refs: [
-      ...content.matchAll(
-        /\|\s*([^|]+)\s*\|\s*([^|]+)\s*\|\s*([^|]+)\s*\|\s*(direct|indirect)\s*\|/g,
-      ),
-    ]
-      .slice(1)
-      .map((match) => `${match[1].trim()}: ${match[2].trim()}`),
-    risks: section(content, "Risks")
-      .split(/\r?\n/)
-      .filter(
-        (line) =>
-          line.startsWith("|") &&
-          !line.includes("---") &&
-          !line.includes("| Risk |"),
-      )
-      .map((line) => line.split("|")[1].trim()),
+    scope_key: evaluatedRunId || runId || options.scopeKey || "unknown-scope",
+    scope_revision: evaluatedRevision || runRevision || "unversioned",
+    objective: section(content, "Objective").trim() || "Canonical Delivery Path Search input unavailable",
+    current_gate: gate.current_gate || runGate || "unknown",
+    allowed_actions: inputFailureCode ? [] : [...gate.allowed],
+    forbidden_actions: Array.isArray(gate.forbidden) ? [...gate.forbidden] : [],
+    evidence_refs: Array.isArray(gate.evidence_refs)
+      ? gate.evidence_refs.map((item) => `${item.evidence}: ${item.source}`)
+      : [],
+    risks: Array.isArray(run.risks) ? run.risks.map((item) => item.risk).filter(Boolean) : [],
     enforcement: options.enforcement ?? {
       level: "instruction_only",
       evidence: ["surface instruction prohibits implementation during search"],
@@ -122,6 +65,11 @@ export function searchInputFromControl(targetDir, options = {}) {
       stability_window: options.stabilityWindow ?? 3,
     },
   };
+  if (inputFailureCode) {
+    result.input_failure_code = inputFailureCode;
+    result.input_failure_detail = run.resolution_error || (gate.blocking_reason !== "none" ? gate.blocking_reason : "") || "canonical input is not ready";
+    result.input_recovery_action = gate.next_allowed_action || "Run canonical AGDF gate-check and repair the selected control state.";
+  }
   if (options.generation?.enabled)
     result.generation = {
       enabled: true,

package/generated/plugins/agdf/runtime/create-agdf/lib/runtime/local-validator.js

@@ -5,6 +5,7 @@ import process from "node:process";
 import {
   INSTALLATION_PROVENANCE_FILE,
   digestDirectory,
+  inspectCopilotPayloadInventory,
   inspectGeneratedRepositoryMarketplace,
   inspectInstallationProvenance,
   validateDistributionProfiles,
@@ -83,41 +84,52 @@ export function resolveLocalValidator(options) {
     }
     const codexManifest = readJson(join(pluginRoot, ".codex-plugin", "plugin.json"));
     const claudeManifest = readJson(join(pluginRoot, ".claude-plugin", "plugin.json"));
-    const pluginVersion = codexManifest?.version ?? null;
-    if (!codexManifest || !claudeManifest || claudeManifest.version !== definition.version) {
-      return { envelope: envelope("version_mismatch", options, { source: "plugin_bundle", pluginRoot, pluginVersion, canonicalVersion: definition.version, distributionProfile: "runtime-plugin", provenanceStatus: "invalid", reason: "manifest_invalid" }) };
+    const copilotManifest = readJson(join(pluginRoot, "plugin.json"));
+    const copilotProfile = Boolean(copilotManifest && !codexManifest && !claudeManifest);
+    const distributionProfile = copilotProfile ? "copilot-runtime-plugin" : "runtime-plugin";
+    const pluginVersion = copilotProfile ? copilotManifest?.version ?? null : codexManifest?.version ?? null;
+    if (copilotProfile
+      ? copilotManifest.version !== definition.version
+      : (!codexManifest || !claudeManifest || claudeManifest.version !== definition.version)) {
+      return { envelope: envelope("version_mismatch", options, { source: "plugin_bundle", pluginRoot, pluginVersion, canonicalVersion: definition.version, distributionProfile, provenanceStatus: "invalid", reason: "manifest_invalid" }) };
+    }
+    const copilotInventory = copilotProfile ? inspectCopilotPayloadInventory(pluginRoot, definition.version) : null;
+    if (copilotProfile && copilotInventory.status !== "matched") {
+      return { envelope: envelope("version_mismatch", options, { source: "plugin_bundle", pluginRoot, pluginVersion, canonicalVersion: definition.version, distributionProfile, provenanceStatus: "invalid", reason: copilotInventory.reason }) };
     }
     const packageRoot = join(options.runtimeRoot, "create-agdf");
     if (!existsSync(packageRoot)) {
-      return { envelope: envelope("unavailable", options, { source: "plugin_bundle", pluginRoot, pluginVersion, distributionProfile: "runtime-plugin", reason: "runtime_missing" }) };
+      return { envelope: envelope("unavailable", options, { source: "plugin_bundle", pluginRoot, pluginVersion, distributionProfile, reason: "runtime_missing" }) };
     }
     const packageManifest = readJson(join(packageRoot, "package.json"));
     const observedVersion = packageManifest?.version ?? manifest.version ?? null;
     if (observedVersion !== options.expectedVersion || manifest.version !== options.expectedVersion) {
-      return { envelope: envelope("version_mismatch", options, { observedVersion, source: "plugin_bundle", pluginRoot, pluginVersion, canonicalVersion: definition.version, distributionProfile: "runtime-plugin" }) };
+      return { envelope: envelope("version_mismatch", options, { observedVersion, source: "plugin_bundle", pluginRoot, pluginVersion, canonicalVersion: definition.version, distributionProfile }) };
     }
     let observedDigest = null;
     try { observedDigest = digestDirectory(packageRoot); } catch {}
     if (!observedDigest || manifest.digest !== observedDigest) {
-      return { envelope: envelope("version_mismatch", options, { observedVersion, source: "plugin_bundle", pluginRoot, pluginVersion, canonicalVersion: definition.version, runtimeDigest: observedDigest, distributionProfile: "runtime-plugin", reason: "runtime_digest_mismatch" }) };
+      return { envelope: envelope("version_mismatch", options, { observedVersion, source: "plugin_bundle", pluginRoot, pluginVersion, canonicalVersion: definition.version, runtimeDigest: observedDigest, distributionProfile, reason: "runtime_digest_mismatch" }) };
     }
     const entrypoint = resolve(options.runtimeRoot, manifest.entrypoint ?? "");
     const entrypointRelative = relative(options.runtimeRoot, entrypoint);
     if (!manifest.entrypoint || entrypointRelative === ".." || entrypointRelative.startsWith(`..${sep}`) || isAbsolute(entrypointRelative)) {
-      return { envelope: envelope("version_mismatch", options, { observedVersion, source: "plugin_bundle", pluginRoot, pluginVersion, canonicalVersion: definition.version, runtimeDigest: observedDigest, distributionProfile: "runtime-plugin", reason: "invalid_entrypoint" }) };
+      return { envelope: envelope("version_mismatch", options, { observedVersion, source: "plugin_bundle", pluginRoot, pluginVersion, canonicalVersion: definition.version, runtimeDigest: observedDigest, distributionProfile, reason: "invalid_entrypoint" }) };
     }
     if (!existsSync(entrypoint)) {
-      return { envelope: envelope("unavailable", options, { observedVersion, source: "plugin_bundle", pluginRoot, pluginVersion, canonicalVersion: definition.version, runtimeDigest: observedDigest, distributionProfile: "runtime-plugin", reason: "entrypoint_missing" }) };
+      return { envelope: envelope("unavailable", options, { observedVersion, source: "plugin_bundle", pluginRoot, pluginVersion, canonicalVersion: definition.version, runtimeDigest: observedDigest, distributionProfile, reason: "entrypoint_missing" }) };
     }
     const installed = existsSync(join(pluginRoot, INSTALLATION_PROVENANCE_FILE));
     let provenanceStatus = "not_applicable";
     let sourceDigest = null;
-    let evidencePlane = "loaded_session";
+    let evidencePlane = options.expectedPluginRoot ? "loaded_session" : "installed_plugin_root";
     if (installed) {
       const provenance = inspectInstallationProvenance(pluginRoot, {
         definition,
         runtimeManifest: manifest,
         pluginVersion,
+        profileId: distributionProfile,
+        inventoryDigest: copilotInventory?.inventoryDigest ?? null,
       });
       provenanceStatus = provenance.status;
       sourceDigest = provenance.marker?.source_digest ?? null;
@@ -130,8 +142,8 @@ export function resolveLocalValidator(options) {
           canonicalVersion: definition.version,
           runtimeDigest: observedDigest,
           sourceDigest,
-          distributionProfile: "runtime-plugin",
-          evidencePlane: "loaded_session",
+          distributionProfile,
+          evidencePlane,
           provenanceStatus,
           reason: provenance.reason,
         }) };
@@ -144,16 +156,16 @@ export function resolveLocalValidator(options) {
         pluginVersion,
         canonicalVersion: definition.version,
         runtimeDigest: observedDigest,
-        distributionProfile: "runtime-plugin",
+        distributionProfile,
         evidencePlane: "loaded_session",
         provenanceStatus: "missing",
         reason: "installation_provenance_missing",
       }) };
     } else {
-      const generatedRepository = inspectGeneratedRepositoryMarketplace(resolve(pluginRoot, "..", ".."));
+      const generatedRepository = copilotProfile ? null : inspectGeneratedRepositoryMarketplace(resolve(pluginRoot, "..", ".."));
       if (pluginVersion !== definition.version
-          || generatedRepository.status !== "matched"
-          || canonicalPath(generatedRepository.pluginRoot) !== pluginRoot) {
+          || (!copilotProfile && (generatedRepository.status !== "matched"
+            || canonicalPath(generatedRepository.pluginRoot) !== pluginRoot))) {
         return { envelope: envelope("unavailable", options, {
           observedVersion,
           source: "plugin_bundle",
@@ -161,7 +173,7 @@ export function resolveLocalValidator(options) {
           pluginVersion,
           canonicalVersion: definition.version,
           runtimeDigest: observedDigest,
-          distributionProfile: "runtime-plugin",
+          distributionProfile,
           evidencePlane: "installed_plugin_root",
           provenanceStatus: "missing",
           reason: "installation_provenance_missing",
@@ -178,7 +190,7 @@ export function resolveLocalValidator(options) {
         canonicalVersion: definition.version,
         runtimeDigest: observedDigest,
         sourceDigest,
-        distributionProfile: "runtime-plugin",
+        distributionProfile,
         evidencePlane,
         provenanceStatus,
       }),

package/generated/plugins/agdf/runtime/create-agdf/lib/runtime/plugin-provenance.js

@@ -4,10 +4,12 @@ import { isAbsolute, join, relative, resolve, sep } from "node:path";
 
 export const INSTALLATION_PROVENANCE_FILE = ".agdf-installation.json";
 export const LEGACY_LOCAL_INSTALL_FILE = ".agdf-local-install.json";
+export const COPILOT_PAYLOAD_INVENTORY_FILE = ".agdf-payload-inventory.json";
 
 const EXPECTED_PROFILES = Object.freeze({
   "source-development": Object.freeze({ runtime: "absent", installable: false, machineValidation: "unavailable" }),
   "runtime-plugin": Object.freeze({ runtime: "required", installable: true, machineValidation: "local_exact_version_digest" }),
+  "copilot-runtime-plugin": Object.freeze({ runtime: "required", installable: true, machineValidation: "local_exact_version_digest_inventory" }),
   "opencode-config-local": Object.freeze({ runtime: "config_local_package", installable: true, machineValidation: "local_exact_version" }),
   "portable-skills": Object.freeze({ runtime: "absent", installable: true, machineValidation: "unavailable_or_external_required" }),
 });
@@ -41,6 +43,50 @@ export function digestDirectory(root) {
   return hash.digest("hex");
 }
 
+export function digestFile(path) {
+  return createHash("sha256").update(readFileSync(path)).digest("hex");
+}
+
+export function inspectCopilotPayloadInventory(pluginRoot, expectedVersion) {
+  const inventoryPath = join(pluginRoot, COPILOT_PAYLOAD_INVENTORY_FILE);
+  const inventory = readJson(inventoryPath);
+  if (!inventory || inventory.schema_version !== 1 || inventory.profile_id !== "copilot-runtime-plugin"
+      || inventory.version !== expectedVersion || !Array.isArray(inventory.entries)) {
+    return { status: "invalid", reason: "copilot_payload_inventory_invalid" };
+  }
+  const destinations = inventory.entries.map((entry) => entry.destination);
+  if (new Set(destinations).size !== destinations.length) {
+    return { status: "invalid", reason: "copilot_payload_inventory_duplicate" };
+  }
+  const actual = [];
+  function visit(directory) {
+    for (const name of readdirSync(directory).sort()) {
+      const path = join(directory, name);
+      const stats = statSync(path);
+      if (stats.isDirectory()) visit(path);
+      else if (stats.isFile()) {
+        const normalized = relative(pluginRoot, path).replaceAll("\\", "/");
+        if (![COPILOT_PAYLOAD_INVENTORY_FILE, INSTALLATION_PROVENANCE_FILE, LEGACY_LOCAL_INSTALL_FILE].includes(normalized)) actual.push(normalized);
+      }
+    }
+  }
+  try { visit(pluginRoot); } catch { return { status: "invalid", reason: "copilot_payload_incomplete" }; }
+  if (JSON.stringify(actual.sort()) !== JSON.stringify([...destinations].sort())) {
+    return { status: "invalid", reason: "copilot_payload_inventory_mismatch" };
+  }
+  for (const entry of inventory.entries) {
+    const path = join(pluginRoot, entry.destination);
+    if (!existsSync(path) || digestFile(path) !== entry.digest || statSync(path).size !== entry.bytes) {
+      return { status: "invalid", reason: "copilot_payload_digest_mismatch", entry: entry.destination };
+    }
+  }
+  const excluded = actual.some((path) => path.startsWith("skills/") || path.startsWith(".codex-plugin/")
+    || path.startsWith(".claude-plugin/") || path.startsWith("submission/")
+    || path === "hooks/hooks.json" || path === "hooks/session-start.sh");
+  if (excluded) return { status: "invalid", reason: "copilot_payload_excluded_surface" };
+  return { status: "matched", inventory, inventoryDigest: digestFile(inventoryPath) };
+}
+
 export function digestNormalizedPluginSource(root, canonicalVersion) {
   const files = [];
   function visit(directory) {
@@ -148,6 +194,8 @@ export function inspectInstallationProvenance(pluginRoot, {
   runtimeManifest,
   pluginVersion,
   allowLegacy = false,
+  profileId = "runtime-plugin",
+  inventoryDigest = null,
 } = {}) {
   const markerPath = join(pluginRoot, INSTALLATION_PROVENANCE_FILE);
   const legacyPath = join(pluginRoot, LEGACY_LOCAL_INSTALL_FILE);
@@ -181,11 +229,12 @@ export function inspectInstallationProvenance(pluginRoot, {
   if (!marker
       || marker.schema_version !== 1
       || marker.owner !== "create-agdf"
-      || marker.profile_id !== "runtime-plugin"
+      || marker.profile_id !== profileId
       || marker.marketplace_id !== profile.contract.marketplaceIdentities.durable
       || marker.canonical_version !== definition.version
       || marker.codex_install_version !== pluginVersion
       || marker.runtime_digest !== runtimeManifest?.digest
+      || (profileId === "copilot-runtime-plugin" && marker.inventory_digest !== inventoryDigest)
       || !/^[a-f0-9]{64}$/.test(marker.source_digest ?? "")) {
     return { status: "invalid", reason: "installation_provenance_invalid", marker };
   }

package/generated/plugins/agdf/runtime/create-agdf/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agdf/local-validator-runtime",
-  "version": "0.14.1",
+  "version": "0.14.3",
   "private": true,
   "type": "module"
 }

package/generated/plugins/agdf/runtime/runtime-manifest.json

@@ -2,7 +2,7 @@
   "schema_version": "1",
   "generated": true,
   "source": "create-agdf/cli",
-  "version": "0.14.1",
+  "version": "0.14.3",
   "entrypoint": "create-agdf/bin/agdf-validator.js",
-  "digest": "724174653ad423b30654aa64a34e1699a18cc67037172c10aa249d1d61087116"
+  "digest": "8f6dbd5e647aff7dfc1405f4e54a5b135a8d820858b5f8f85873964f6eb2f7cf"
 }

package/generated/plugins/agdf/scripts/check-runtime-integrity.mjs

@@ -681,6 +681,7 @@ if (pluginDefinition) {
   const expectedProfiles = {
     "source-development": { runtime: "absent", installable: false, machineValidation: "unavailable" },
     "runtime-plugin": { runtime: "required", installable: true, machineValidation: "local_exact_version_digest" },
+    "copilot-runtime-plugin": { runtime: "required", installable: true, machineValidation: "local_exact_version_digest_inventory" },
     "opencode-config-local": { runtime: "config_local_package", installable: true, machineValidation: "local_exact_version" },
     "portable-skills": { runtime: "absent", installable: true, machineValidation: "unavailable_or_external_required" },
   };
@@ -888,7 +889,7 @@ if (pluginDefinition) {
   }
 }
 
-if (!sourceMode) {
+if (!sourceMode && installationProvenance?.profile_id === "copilot-runtime-plugin") {
   const copilotPlugin = isFile(copilotPluginPath) ? readJson(copilotPluginPath, "Copilot plugin manifest") : null;
   const copilotHooks = isFile(copilotHooksPath) ? readJson(copilotHooksPath, "Copilot plugin hooks") : null;
   if (!copilotPlugin) failures.push("installed runtime plugin must include root plugin.json for GitHub Copilot");