create-agdf 0.14.2 → 0.14.4

package/generated/plugins/copilot/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/copilot/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/copilot/agdf/runtime/create-agdf/lib/interaction-presentation.js

@@ -1,3 +1,5 @@
+import { RUN_ID_PATTERN } from "./control-state/run-identity.js";
+
 const REQUIRED_GATES = ["UR", "PRD", "SD", "TP", "QA", "UAT"];
 const ARTEFACT_ORDER = ["UR", "PRD", "SD", "TP"];
 const OUTCOMES = new Set(["approve", "revise", "decline", "cancel", "no_response", "timeout", "empty", "invalid", "stale"]);
@@ -313,17 +315,37 @@ function operationalBreadcrumb(value, labels) {
     .join(labels.breadcrumbSeparator);
 }
 
+export function validateOperationalStatusCardPreconditions(statusCard, {
+  registry,
+  humanPresentation,
+} = {}) {
+  const errors = [];
+  if (!plainObject(statusCard)) errors.push("status_card_missing");
+  if (humanPresentation !== undefined && !plainObject(humanPresentation)) errors.push("human_presentation_missing");
+  if (plainObject(statusCard)) {
+    if (!String(statusCard.run_id ?? "").trim()) errors.push("run_id_missing");
+    if (!String(statusCard.current_gate ?? "").trim()) errors.push("current_gate_missing");
+    let locale = "";
+    try {
+      locale = resolvePresentationLocale(registry, statusCard.presentation_language);
+    } catch {
+      locale = "";
+    }
+    if (!locale) errors.push("locale_unresolved");
+  }
+  return Object.freeze({ valid: errors.length === 0, errors: Object.freeze(errors) });
+}
+
 export function renderOperationalStatusCard(statusCard, {
   registry,
   humanPresentation,
   revisionId = "",
 } = {}) {
-  if (!plainObject(statusCard) || !plainObject(humanPresentation)) return null;
+  if (!validateOperationalStatusCardPreconditions(statusCard, { registry, humanPresentation: humanPresentation ?? null }).valid) return null;
   const runId = String(statusCard.run_id ?? "").trim();
   const currentGate = String(statusCard.current_gate ?? "").trim();
   const revision = String(revisionId ?? "").trim() || "unversioned";
   const locale = resolvePresentationLocale(registry, statusCard.presentation_language);
-  if (!runId || !currentGate || !locale) return null;
 
   const pack = localePack(registry, locale);
   const labels = pack.statusCard;
@@ -537,6 +559,37 @@ export function normalizeInteractionOutcome(value, { expectedApproval, stale = f
   return "invalid";
 }
 
+export function validateApprovalOrientationPreconditions({
+  statusCard,
+  humanPresentation,
+  registry,
+  requestedLocale,
+} = {}) {
+  const errors = [];
+  if (!plainObject(statusCard)) return Object.freeze({ valid: false, errors: Object.freeze(["status_card_missing"]) });
+  if (humanPresentation !== undefined && !plainObject(humanPresentation)) errors.push("human_presentation_missing");
+  const gate = String(statusCard.current_gate ?? "").trim();
+  const runId = String(statusCard.run_id ?? "").trim();
+  if (!REQUIRED_GATES.includes(gate)) errors.push("gate_not_user_gate");
+  if (!RUN_ID_PATTERN.test(runId)) errors.push("run_id_invalid");
+  if (statusCard.status !== "open") errors.push("status_not_open");
+  if (statusCard.missing_approval !== `Approval: ${gate}`) errors.push("missing_approval_mismatch");
+  const nextGate = String(statusCard.next_gate_after_approval ?? "none");
+  const nextUserGate = String(statusCard.next_user_gate ?? "").trim();
+  const userActionRequired = String(statusCard.user_action_required ?? "").trim();
+  const userActionSemanticsValid = (userActionRequired === "no" && nextUserGate === "none")
+    || (userActionRequired === "yes" && REQUIRED_GATES.includes(nextUserGate) && nextGate === nextUserGate);
+  if (!userActionSemanticsValid) errors.push("user_action_semantics_invalid");
+  let locale = "";
+  try {
+    locale = resolvePresentationLocale(registry, requestedLocale);
+  } catch {
+    locale = "";
+  }
+  if (!locale) errors.push("locale_unresolved");
+  return Object.freeze({ valid: errors.length === 0, errors: Object.freeze(errors) });
+}
+
 export function buildApprovalOrientationSnapshot({
   ready = false,
   statusCard,
@@ -545,11 +598,11 @@ export function buildApprovalOrientationSnapshot({
   registry,
   requestedLocale,
 } = {}) {
-  if (!ready || !plainObject(statusCard) || !plainObject(humanPresentation)) return null;
+  if (!ready) return null;
+  if (!validateApprovalOrientationPreconditions({ statusCard, humanPresentation: humanPresentation ?? null, registry, requestedLocale }).valid) return null;
   const gate = String(statusCard.current_gate ?? "").trim();
   const runId = String(statusCard.run_id ?? "").trim();
   const expectedApproval = `Approval: ${gate}`;
-  if (!REQUIRED_GATES.includes(gate) || !/^[A-Za-z0-9._-]+$/.test(runId) || statusCard.status !== "open" || statusCard.missing_approval !== expectedApproval) return null;
 
   const locale = resolvePresentationLocale(registry, requestedLocale);
   const pack = localePack(registry, locale);
@@ -560,9 +613,6 @@ export function buildApprovalOrientationSnapshot({
   const nextGate = String(statusCard.next_gate_after_approval ?? "none");
   const nextUserGate = String(statusCard.next_user_gate ?? "").trim();
   const userActionRequired = String(statusCard.user_action_required ?? "").trim();
-  const userActionSemanticsValid = (userActionRequired === "no" && nextUserGate === "none")
-    || (userActionRequired === "yes" && REQUIRED_GATES.includes(nextUserGate) && nextGate === nextUserGate);
-  if (!userActionSemanticsValid) return null;
   const narration = pack.primary.narration.gates[gate] ?? {};
   const nextDecision = userActionRequired === "no"
     ? pack.primary.narration.noAction

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

@@ -137,6 +137,22 @@ export function validateDistributionProfiles(definition) {
   return { status: "matched", contract };
 }
 
+function classifyInstalledHistoricalProfile(catalogue, definition, classifyHistoricalProfile) {
+  if (typeof classifyHistoricalProfile !== "function") {
+    return { status: "invalid", reason: "profile_history_invalid" };
+  }
+  const result = classifyHistoricalProfile({
+    catalogue,
+    version: definition?.version,
+    distributionProfiles: definition?.distributionProfiles,
+  });
+  if (result.status !== "matched") return result;
+  return {
+    ...result,
+    contract: catalogue.contracts[result.contract_id].distribution_profiles,
+  };
+}
+
 export function inspectGeneratedRepositoryMarketplace(targetDir) {
   const marketplacePath = join(targetDir, ".agents", "plugins", "marketplace.json");
   if (!existsSync(marketplacePath)) return { status: "absent", marketplacePath };
@@ -196,11 +212,23 @@ export function inspectInstallationProvenance(pluginRoot, {
   allowLegacy = false,
   profileId = "runtime-plugin",
   inventoryDigest = null,
+  allowHistoricalProfilesForMigration = false,
+  distributionProfileHistory = null,
+  classifyHistoricalProfile = null,
 } = {}) {
   const markerPath = join(pluginRoot, INSTALLATION_PROVENANCE_FILE);
   const legacyPath = join(pluginRoot, LEGACY_LOCAL_INSTALL_FILE);
   if (!existsSync(markerPath)) {
     if (allowLegacy && existsSync(legacyPath)) {
+      const currentProfile = validateDistributionProfiles(definition);
+      if (Object.hasOwn(definition ?? {}, "distributionProfiles")
+          && currentProfile.status !== "matched") {
+        return allowHistoricalProfilesForMigration
+          ? classifyInstalledHistoricalProfile(distributionProfileHistory, definition, classifyHistoricalProfile).status === "matched"
+            ? { status: "invalid", reason: "installation_provenance_invalid" }
+            : classifyInstalledHistoricalProfile(distributionProfileHistory, definition, classifyHistoricalProfile)
+          : currentProfile;
+      }
       const marker = readJson(legacyPath);
       if (!marker
           || marker.schema_version !== 1
@@ -223,8 +251,14 @@ export function inspectInstallationProvenance(pluginRoot, {
     if (profile.status !== "matched") return profile;
     return { status: "missing", reason: "installation_provenance_missing" };
   }
-  const profile = validateDistributionProfiles(definition);
-  if (profile.status !== "matched") return profile;
+  const currentProfile = validateDistributionProfiles(definition);
+  const historicalProfile = currentProfile.status !== "matched" && allowHistoricalProfilesForMigration
+    ? classifyInstalledHistoricalProfile(distributionProfileHistory, definition, classifyHistoricalProfile)
+    : null;
+  if (currentProfile.status !== "matched" && historicalProfile?.status !== "matched") {
+    return historicalProfile ?? currentProfile;
+  }
+  const profile = currentProfile.status === "matched" ? currentProfile : historicalProfile;
   const marker = readJson(markerPath);
   if (!marker
       || marker.schema_version !== 1
@@ -247,7 +281,16 @@ export function inspectInstallationProvenance(pluginRoot, {
   if (observedSourceDigest !== marker.source_digest) {
     return { status: "invalid", reason: "source_digest_mismatch", marker, observedSourceDigest };
   }
-  return { status: "matched", marker, observedSourceDigest };
+  return {
+    status: "matched",
+    marker,
+    observedSourceDigest,
+    profileClassification: historicalProfile ? "supported_historical" : "current",
+    historicalReleaseVersion: historicalProfile?.release_version ?? null,
+    historicalContractId: historicalProfile?.contract_id ?? null,
+    historicalContractDigest: historicalProfile?.contract_digest ?? null,
+    historicalEntryDigest: historicalProfile?.entry_digest ?? null,
+  };
 }
 
 export const distributionProfileContract = Object.freeze({

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

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

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

@@ -2,7 +2,7 @@
   "schema_version": "1",
   "generated": true,
   "source": "create-agdf/cli",
-  "version": "0.14.2",
+  "version": "0.14.4",
   "entrypoint": "create-agdf/bin/agdf-validator.js",
-  "digest": "51035c8735d47aa727980d82709326071b372464ae077a1d269aadc0d30f2624"
+  "digest": "68b83a6721a799c34067cdbcc0ed6664f7fbf89bce186a3d8de284b0959deac7"
 }

package/generated/submissions/openai/agdf/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "agdf",
-  "version": "0.14.2",
+  "version": "0.14.4",
   "description": "Control layer for governed AI-assisted delivery.",
   "author": {
     "name": "Arndt Gold",

package/generated/submissions/openai/agdf/meta/agdf-plugin.definition.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "id": "agdf",
-  "version": "0.14.2",
+  "version": "0.14.4",
   "displayName": "AI Governance & Delivery Framework",
   "developerName": "Arndt Gold",
   "description": "Control layer for governed AI-assisted delivery.",

package/generated/submissions/openai/agdf/meta/contracts/control-scaffold.md

@@ -4,11 +4,24 @@
 
 Delivery Path Search is an optional read-only planning step for high-impact decisions with several materially different next actions.
 
-- It consumes current AGDF state and must reject gate-illegal candidates before model evaluation.
-- It returns one advisory recommendation or `no_safe_recommendation`.
+- It consumes the canonical selected-run `gate-check` evaluation for run, revision, current gate and
+  legal actions. Persisted presentation Markdown such as the Run Status Card is never policy input.
+- It binds the selected `scope_key`, `scope_revision` and objective to one control snapshot. A stale
+  or incomplete snapshot fails before candidate generation or evaluation.
+- It reports the phase that actually ran: `input | candidate | evaluation | search`. A phase that
+  did not run cannot produce a later-phase conclusion.
+- Terminal status is `input_unavailable | no_legal_candidates | evaluator_unavailable |
+  evaluator_error | recommendation | no_safe_recommendation`. Recommendation-facing statuses
+  require at least one contract-valid evaluation. `candidate_queue_exhausted` is a stopping reason,
+  not recommendation evidence.
+- It reports baseline/generated/legal/rejected candidate counts and attempted/valid/invalid
+  evaluation counts. Zero valid evaluations must never be presented or persisted as an evaluated
+  recommendation conclusion.
 - It must report budgets, stopping reason and `full | tool_enforced | instruction_only` enforcement.
 - Model scores are judgements, not measurements.
 - Search output is evidence only. Canonical `gate-check` independently decides what may proceed.
+- Search applies only to the selected run objective. An unrelated decision needs the correct
+  governed scope; Delivery Path Search is not a second task-target resolver.
 - The bounded first-release algorithm must not be labelled MCTS.
 - Surface adapters may translate transport and presentation, but must not fork scoring, search or gate semantics.
 - Optional AI-native candidate generation supplements the deterministic candidate baseline; it never replaces it.
@@ -19,6 +32,8 @@ Delivery Path Search is an optional read-only planning step for high-impact deci
 - Codex and Claude Code may provide tool-enforced generator transports. Copilot, OpenCode and generic surfaces remain instruction-only without conforming evidence.
 - OpenCode may provide a tool-enforced evaluator only for an invocation whose capability preflight proves `opencode run --pure --agent`, the owned evaluator agent and effective executable-tool denies. Preflight or transport failure must return `evaluator_unavailable` with `instruction_only` enforcement and point to the existing instruction-only workflow; it must not continue through a weaker subprocess.
 - OpenCode candidate generation remains unavailable.
+- Persistence accepts only contract-valid `recommendation` or `no_safe_recommendation` results with
+  at least one valid evaluation. Input, candidate and evaluator failure results remain transient.
 
 The field names above are the stable machine-readable contract used by JSON
 reports and automation. Human-facing Markdown must present the same projection

package/generated/submissions/openai/agdf/meta/contracts/interaction.md

@@ -154,8 +154,8 @@ required decision and one neutral instruction to choose approve, request revisio
 or decline. It does not contain the exact approval value or quality outlook. It uses localized human-readable labels
 and must not contain evidence, diagnostic codes, raw control-state keys,
 allowed/forbidden inventories or machine values. The complete Run Status Card remains the operational,
-CLI and audit projection and remains available for complete detail outside the
-approval-time compact view.
+CLI and audit projection. Every ready-gate presentation renders the complete operational Run Status Card exactly once, between the compact approval-time Run Status Card and the Gate Transition Card, consumed verbatim from the code-owned status presentation; when it is undeliverable, the localized status-presentation failure line with its concrete diagnostic codes takes its place and the decision is still requested.
+The exact-approval once-only requirement applies to the compact approval-time Run Status Card and the Gate Transition Card only; the complete Run Status Card may carry the missing approval as audit data.
 
 The first scan across both cards reveals the requested decision, readiness,
 required approval, approval effect, remaining boundary and next transition.