create-agdf 0.14.1 → 0.14.3

package/README.md

@@ -147,8 +147,10 @@ it does not localize the CLI lifecycle card.
 - `opencode-repo` writes durable AGDF control configuration and templates under `.agdf/control/`; it does not copy a second OpenCode runtime surface
 - `config` writes or updates only `.agdf/control/config.json` for an already installed plugin or an existing repository
 
-The `codex`, `claude` and `copilot` commands install from the complete plugin built into the released
-`create-agdf` package. They atomically stage it under an AGDF-owned user-data marketplace, register
+The `codex` and `claude` commands install the complete shared plugin built into the released
+`create-agdf` package. The `copilot` command installs a dedicated generated profile containing only
+the Copilot manifest, prefixed skills, hook, required contracts and exact-version runtime. Every profile
+is rendered from the same canonical sources. The installers atomically stage their profile under an AGDF-owned user-data marketplace, register
 that stable local path through the host CLI and verify the exposed version. Source `plugin/` therefore
 contains no generated runtime bytes and the source checkout exposes no installable root marketplace.
 The staged plugin contains one installation-provenance marker and the shared exact-version runtime;
@@ -157,6 +159,10 @@ checkout, npm cache, PATH or registry. Rerunning either command performs the exp
 migrates only the exact known legacy AGDF GitHub marketplace; foreign same-name registrations fail
 closed and failed host operations restore the prior owned stage.
 
+Copilot staging uses the independent path `<AGDF data directory>/marketplaces/agdf-copilot`. This
+prevents Copilot updates and rollbacks from replacing the shared Codex and Claude payload while the
+host-facing Marketplace identity remains `agdf` and the install identity remains `agdf@agdf`.
+
 The Copilot installer does not create, rewrite or remove repository files. Existing `AGENTS.md`, `.github/` and `.agdf/control/` content remains untouched. Use `init` separately when a repository should own surface-neutral durable AGDF control state.
 
 Use the `codex-repo` target when AGDF should be available only inside one repository instead of being installed as a personal/global Codex plugin.
@@ -280,7 +286,11 @@ Requirements and boundaries:
 - OpenCode candidate generation is intentionally unavailable; Copilot has no executable native evaluator
 - cost units are rubric values used for bounded comparison, not measured provider currency
 
-The result is either one recommendation or `no_safe_recommendation`. In both cases run canonical `gate-check` afterwards.
+The result reports the selected run/revision/objective, the phase that actually ran and candidate and
+evaluation provenance. `input_unavailable`, `no_legal_candidates`, `evaluator_unavailable` and
+`evaluator_error` are non-recommendation outcomes. `recommendation` and
+`no_safe_recommendation` require at least one valid evaluation; only those evaluated outcomes may be
+persisted. A result applies only to its selected run objective. Run canonical `gate-check` afterwards.
 
 `gate-check --json` and `delivery-map --json` also expose a `status_card` object. It is a compact projection of the current control state: current gate, allowed and forbidden actions, blocker, next skill, next permissible step and `quality_outlook`. `next_step` is process permission; `quality_outlook` is the next meaningful quality-improvement focus and does not unlock gates.
 

package/generated/.opencode/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 `agdf-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 `agdf-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/.opencode/skills/agdf-delivery-path-search/SKILL.md

@@ -33,7 +33,9 @@ Skip for routine questions, obvious local fixes and approved implementation with
 ## Workflow
 
 1. Run AGDF gate-check and inspect durable control state.
-2. Confirm that search is allowed and implementation is not occurring during exploration.
+2. Confirm that the requested decision matches the selected run objective, and that search is
+   allowed while implementation is not occurring during exploration. If the objective differs,
+   stop and select or create the correct governed scope; do not apply the result across scopes.
 3. Declare the active surface and its enforcement level.
 4. Resolve the exact-version surface-local validator using the same ownership rules as `agdf-gate-check`. Do not search `PATH`, query a registry, install a package or invoke `npx ...@latest` during routine planning. If no owned or explicitly configured exact-version validator is available, report `machine_validation: unavailable` or `machine_validation: external_required` and stop the machine-evaluated search.
 5. Invoke the shared CLI runtime:
@@ -54,7 +56,9 @@ node <surface-local-agdf> delivery-path-search \
 It supplements the deterministic baseline with at most one bounded generator call. Treat proposals as untrusted until the canonical core validates schema, gate action, scope, duplicates and material diversity. Report generation provenance, budgets, rejections and failure. Never hide deterministic fallback or switch providers automatically.
 
 6. Treat facts, repository evidence, assumptions and model judgements separately.
-7. Return exactly one recommendation or `no_safe_recommendation`.
+7. Report the actual terminal phase and status. Return a recommendation-facing conclusion only
+   after at least one valid evaluation. Missing/stale input, zero legal candidates and evaluator
+   unavailability/error remain typed non-recommendation outcomes with one recovery action.
 8. Run canonical AGDF gate-check after search. Never translate a recommendation into permission.
 
 ## Enforcement
@@ -71,15 +75,20 @@ Do not overstate the surface's guarantee.
 
 Keep chat output compact:
 
-- recommendation or `no_safe_recommendation`
+- selected run, revision and objective
+- outcome phase and typed terminal status
+- recommendation only for a recommendation-facing evaluated result
 - current gate
 - enforcement level
 - decisive evidence and assumptions
 - rejected alternatives and reasons
 - budgets and stopping reason
+- candidate and evaluation provenance, including attempted, valid and invalid counts
 - next AGDF gate action
 
-Persist only the redacted decision summary when durable evidence is required. Do not persist raw prompts, hidden reasoning, secrets or source snapshots.
+Persist only a contract-valid evaluated recommendation-facing summary when durable evidence is
+required. Never persist input, candidate or evaluator failure as a decision. Do not persist raw
+prompts, hidden reasoning, secrets or source snapshots.
 
 ## Boundaries
 
@@ -87,6 +96,9 @@ Persist only the redacted decision summary when durable evidence is required. Do
 - Do not modify repository files during search.
 - Do not execute evaluator-returned commands.
 - Do not invent default scores for invalid evaluator output.
+- Do not parse Run Status Card or other presentation Markdown as gate-policy input.
+- Do not describe zero valid evaluations as `no_safe_recommendation`.
+- Do not apply one selected run's result to an unrelated question.
 - Do not implement, approve or release based on search output.
 - Do not create agent-specific scoring, gate logic or skill copies.
 - Do not replace deterministic candidates with generated proposals.

package/generated/plugins/agdf/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "agdf",
-  "version": "0.14.1",
+  "version": "0.14.3",
   "description": "AI Governance & Delivery Framework (AGDF) is a governance framework for agentic work. Its first implementation provides a control layer for governed AI-assisted software delivery. It combines workflow skills, explicit gates, control templates and machine-readable repository checks to keep work aligned with approved scope and make evidence a prerequisite for consequential gate transitions. Supported workflows include brownfield analysis, task-plan review, QA decisions, durable run state and auditable delivery closeout. AGDF is an independent open-source project, not a security sandbox, compliance certification or autonomous release system.",
   "keywords": [
     "agentic",

package/generated/plugins/agdf/.codex-plugin/plugin.json

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

package/generated/plugins/agdf/meta/agdf-plugin.definition.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "id": "agdf",
-  "version": "0.14.1",
+  "version": "0.14.3",
   "displayName": "AI Governance & Delivery Framework",
   "developerName": "Arndt Gold",
   "description": "Control layer for governed AI-assisted delivery.",
@@ -311,6 +311,11 @@
         "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,

package/generated/plugins/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/plugins/agdf/meta/copilot-payload-baseline.json

@@ -0,0 +1,7 @@
+{
+  "schema_version": 1,
+  "profile_id": "copilot-runtime-plugin",
+  "max_files": 78,
+  "max_bytes": 550979,
+  "rationale": "Reviewed Copilot-only manifest, ten prefixed skills, required contracts, exact-version runtime, Delivery Path Search input-integrity provenance and evidence-plane separation. Any further increase requires review."
+}

package/generated/plugins/agdf/runtime/create-agdf/generated/plugins/agdf/meta/agdf-plugin.definition.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "id": "agdf",
-  "version": "0.14.1",
+  "version": "0.14.3",
   "displayName": "AI Governance & Delivery Framework",
   "developerName": "Arndt Gold",
   "description": "Control layer for governed AI-assisted delivery.",
@@ -311,6 +311,11 @@
         "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,

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

@@ -12,21 +12,25 @@ import { enforcementForSurface } from '../delivery-path-search/surfaces/capabili
 import { persistSearchResult } from '../delivery-path-search/persistence.js';
 
 function unavailableOpenCodeResult({ options, preflight, input = null, error = null }) {
+  const surface = options.surface ?? "opencode";
   const mutation = error?.code === "OPENCODE_EVALUATOR_MUTATION_DETECTED";
-  const attempted = Boolean(input);
+  const attempted = Boolean(input && error);
   const nextAction = mutation
     ? "Investigate and revert the detected repository mutation before any evaluator fallback or retry."
     : "Repair the reported OpenCode capability and retry, or use the existing instruction-only Delivery Path Search workflow.";
   return {
     contract_version: "1",
-    surface: "opencode",
+    surface,
     scope_key: input?.scope_key ?? options.runId ?? null,
+    scope_revision: input?.scope_revision ?? "unversioned",
+    objective: input?.objective ?? "Delivery Path Search evaluator capability",
     current_gate: input?.current_gate ?? null,
+    outcome_phase: "evaluation",
     status: mutation ? "evaluator_error" : "evaluator_unavailable",
     recommendation: null,
-    enforcement: enforcementForSurface("opencode"),
+    enforcement: enforcementForSurface(surface),
     evaluator: {
-      name: "opencode",
+      name: surface,
       preflight: preflight?.code ?? "not_run",
       failure_code: error?.code ?? preflight?.code,
       detail: error?.message ?? preflight?.detail,
@@ -38,6 +42,16 @@ function unavailableOpenCodeResult({ options, preflight, input = null, error = n
       failure_code: error?.code ?? preflight?.code,
       evidence: preflight?.evidence ?? [],
     },
+    provenance: {
+      baseline_candidates: Math.min(input?.allowed_actions?.length ?? 0, input?.budgets?.max_candidates ?? 0),
+      generated_candidates: 0,
+      legal_candidates: attempted ? 1 : 0,
+      rejected_candidates: 0,
+      evaluation_attempts: attempted ? 1 : 0,
+      valid_evaluations: 0,
+      invalid_evaluations: attempted ? 1 : 0,
+    },
+    failure_code: error?.code ?? preflight?.code,
     stopping_reason: mutation ? "opencode_mutation_detected" : attempted ? "opencode_evaluator_failed" : "opencode_preflight_failed",
     next_action: nextAction,
     next_gate_action: nextAction,
@@ -46,11 +60,26 @@ function unavailableOpenCodeResult({ options, preflight, input = null, error = n
 
 export async function executeDeliveryPathSearch(options, io = console, dependencies = {}) {
   const fixture = options.fixture ? JSON.parse(readFileSync(options.fixture, "utf8")) : null;
+  const fixtureGeneration = fixture?.generator_response;
+  const generationEnabled = Boolean(fixtureGeneration || options.generateCandidates);
+  const initialEnforcement = fixture?.input?.enforcement ?? enforcementForSurface(options.surface);
+  const initialInput = fixture?.input ?? (dependencies.searchInputFromControl ?? searchInputFromControl)(options.dir, {
+    scopeKey: options.runId,
+    enforcement: initialEnforcement,
+    generation: generationEnabled ? {
+      enabled: true,
+      maxProposals: options.maxGeneratedCandidates,
+      maxDurationMs: options.generationTimeoutMs,
+      maxCostUnits: options.generationCostUnits,
+    } : undefined,
+  });
   const preflight = !fixture && options.surface === "opencode"
     ? (dependencies.preflightOpenCodeEvaluator ?? preflightOpenCodeEvaluator)({ cwd: options.dir })
     : null;
   if (preflight?.status === "failed") {
-    const result = unavailableOpenCodeResult({ options, preflight });
+    const result = initialInput.input_failure_code
+      ? await runDeliveryPathSearch(initialInput, { name: "not-invoked", async evaluate() { throw new Error("input failure must stop before evaluation"); } })
+      : unavailableOpenCodeResult({ options, preflight, input: initialInput });
     printDeliveryPathSearchResult(result, options, io);
     return result;
   }
@@ -58,18 +87,7 @@ export async function executeDeliveryPathSearch(options, io = console, dependenc
     ?? (preflight
       ? enforcementForSurface("opencode", preflight.evidence, { preflight })
       : enforcementForSurface(options.surface));
-  const fixtureGeneration = fixture?.generator_response;
-  const generationEnabled = Boolean(fixtureGeneration || options.generateCandidates);
-  const baseInput = fixture?.input ?? (dependencies.searchInputFromControl ?? searchInputFromControl)(options.dir, {
-    scopeKey: options.runId,
-    enforcement,
-    generation: generationEnabled ? {
-      enabled: true,
-      maxProposals: options.maxGeneratedCandidates,
-      maxDurationMs: options.generationTimeoutMs,
-      maxCostUnits: options.generationCostUnits,
-    } : undefined,
-  });
+  const baseInput = fixture ? initialInput : { ...initialInput, enforcement };
   const input = generationEnabled && !baseInput.generation ? {
     ...baseInput,
     generation: {
@@ -90,7 +108,13 @@ export async function executeDeliveryPathSearch(options, io = console, dependenc
           ? (dependencies.openCodeEvaluator ?? openCodeEvaluator)({ cwd: options.dir, model: options.model, preflight })
           : null;
   if (!evaluator) {
-    throw new Error(`${options.surface} has no executable evaluator in this release. Codex, Claude and preflight-qualified OpenCode are the executable adapters; --fixture is available for deterministic contract testing.`);
+    const detail = `${options.surface} has no executable evaluator in this release. Codex, Claude and preflight-qualified OpenCode are the executable adapters; --fixture is available for deterministic contract testing.`;
+    const result = {
+      ...unavailableOpenCodeResult({ options, preflight: { code: "surface_evaluator_unavailable", detail, evidence: [] }, input }),
+      surface: options.surface,
+    };
+    printDeliveryPathSearchResult(result, options, io);
+    return result;
   }
   const generator = fixtureGeneration
     ? fixtureGenerator(fixtureGeneration)
@@ -125,15 +149,23 @@ function printDeliveryPathSearchResult(result, options, io) {
     return;
   }
   io.log(`AGDF Delivery Path Search: ${result.status}`);
+  io.log(`Scope: ${result.scope_key ?? "unknown"} @ ${result.scope_revision ?? "unversioned"}`);
+  if (result.objective) io.log(`Objective: ${result.objective}`);
   io.log(`Current gate: ${result.current_gate ?? "unknown"}`);
+  io.log(`Outcome phase: ${result.outcome_phase ?? "unknown"}`);
   io.log(`Enforcement: ${result.enforcement.level}`);
   io.log(`Recommendation: ${result.recommendation?.action ?? "none"}`);
   if (result.budgets) io.log(`Evaluations: ${result.budgets.evaluations}`);
+  if (result.provenance) {
+    io.log(`Candidates: ${result.provenance.legal_candidates} legal, ${result.provenance.rejected_candidates} rejected`);
+    io.log(`Evaluation provenance: ${result.provenance.valid_evaluations}/${result.provenance.evaluation_attempts} valid, ${result.provenance.invalid_evaluations} invalid`);
+  }
   if (result.generation) {
     io.log(`Generation: ${result.generation.status} (${result.generation.accepted}/${result.generation.returned} accepted)`);
     io.log(`Generation budget: ${result.generation.cost_units} cost units, ${result.generation.duration_ms} ms`);
     if (result.generation.failure_code) io.log(`Generation failure: ${result.generation.failure_code}`);
   }
   io.log(`Stopping reason: ${result.stopping_reason}`);
-  io.log(result.next_gate_action);
+  if (result.failure_code) io.log(`Failure: ${result.failure_code}`);
+  io.log(result.next_action ?? result.next_gate_action);
 }

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

@@ -68,6 +68,10 @@ export function validateSearchInput(value) {
   }
   requireString(input.objective, "objective");
   requireString(input.current_gate, "current_gate");
+  optionalBoundedString(input.scope_revision, "scope_revision", 200);
+  optionalBoundedString(input.input_failure_code, "input_failure_code", 200);
+  optionalBoundedString(input.input_failure_detail, "input_failure_detail", 1000);
+  optionalBoundedString(input.input_recovery_action, "input_recovery_action", 1000);
   stringArray(input.allowed_actions, "allowed_actions");
   stringArray(input.forbidden_actions, "forbidden_actions");
   stringArray(input.evidence_refs ?? [], "evidence_refs");
@@ -81,6 +85,39 @@ export function validateSearchInput(value) {
   return structuredClone(input);
 }
 
+const RESULT_PHASE_BY_STATUS = new Map([
+  ["input_unavailable", "input"],
+  ["no_legal_candidates", "candidate"],
+  ["evaluator_unavailable", "evaluation"],
+  ["evaluator_error", "evaluation"],
+  ["recommendation", "search"],
+  ["no_safe_recommendation", "search"],
+]);
+
+export function validateSearchResult(value) {
+  const result = requireObject(value, "search result");
+  if (result.contract_version !== CONTRACT_VERSION) throw new Error(`unsupported search result contract_version: ${result.contract_version}`);
+  const status = requireString(result.status, "result.status");
+  const expectedPhase = RESULT_PHASE_BY_STATUS.get(status);
+  if (!expectedPhase) throw new Error(`unsupported search result status: ${status}`);
+  if (result.outcome_phase !== expectedPhase) throw new Error(`${status} requires outcome_phase ${expectedPhase}`);
+  requireString(result.scope_key, "result.scope_key");
+  optionalBoundedString(result.scope_revision, "result.scope_revision", 200);
+  const provenance = requireObject(result.provenance, "result.provenance");
+  for (const key of ["baseline_candidates", "generated_candidates", "legal_candidates", "rejected_candidates", "evaluation_attempts", "valid_evaluations", "invalid_evaluations"]) {
+    if (!Number.isInteger(provenance[key]) || provenance[key] < 0) throw new Error(`result.provenance.${key} must be a non-negative integer`);
+  }
+  if (provenance.evaluation_attempts !== provenance.valid_evaluations + provenance.invalid_evaluations) throw new Error("result evaluation provenance counts are inconsistent");
+  const recommendationFacing = status === "recommendation" || status === "no_safe_recommendation";
+  if (recommendationFacing && provenance.valid_evaluations < 1) throw new Error(`${status} requires at least one valid evaluation`);
+  if (status === "recommendation" && !result.recommendation) throw new Error("recommendation status requires recommendation content");
+  if (status !== "recommendation" && result.recommendation != null) throw new Error(`${status} must not contain recommendation content`);
+  if (status === "no_legal_candidates" && (provenance.legal_candidates !== 0 || provenance.evaluation_attempts !== 0)) throw new Error("no_legal_candidates requires zero legal candidates and evaluation attempts");
+  if (status === "input_unavailable" && provenance.evaluation_attempts !== 0) throw new Error("input_unavailable requires zero evaluation attempts");
+  if ((status === "evaluator_unavailable" || status === "evaluator_error") && provenance.valid_evaluations !== 0) throw new Error(`${status} requires zero valid evaluations`);
+  return structuredClone(result);
+}
+
 export function validateCandidate(value) {
   const candidate = requireObject(value, "candidate");
   requireString(candidate.id, "candidate.id");

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

@@ -1,5 +1,6 @@
 import { mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { validateSearchResult } from "./contracts.js";
 
 function safeResult(result) {
   return JSON.parse(JSON.stringify(result, (key, value) => {
@@ -9,22 +10,33 @@ function safeResult(result) {
 }
 
 export function persistSearchResult(targetDir, result) {
-  const root = join(targetDir, ".agdf", "control", "artefacts", result.scope_key);
+  const validated = validateSearchResult(result);
+  if (!["recommendation", "no_safe_recommendation"].includes(validated.status)) {
+    throw new Error(`search result status ${validated.status} is not persistable`);
+  }
+  if (validated.provenance.valid_evaluations < 1) {
+    throw new Error("search result requires at least one valid evaluation before persistence");
+  }
+  const root = join(targetDir, ".agdf", "control", "artefacts", validated.scope_key);
   const jsonPath = join(root, "DELIVERY_PATH_SEARCH.json");
   const markdownPath = join(root, "DELIVERY_PATH_SEARCH.md");
   mkdirSync(dirname(jsonPath), { recursive: true });
-  const safe = safeResult(result);
+  const safe = safeResult(validated);
   writeFileSync(jsonPath, `${JSON.stringify(safe, null, 2)}\n`, "utf8");
   const recommendation = safe.recommendation?.action ?? "No safe recommendation";
   writeFileSync(markdownPath, [
     "# Delivery Path Search Decision",
     "",
     `- status: ${safe.status}`,
+    `- outcome_phase: ${safe.outcome_phase}`,
+    `- scope_revision: ${safe.scope_revision}`,
     `- current_gate: ${safe.current_gate}`,
     `- enforcement: ${safe.enforcement.level}`,
     `- recommendation: ${recommendation}`,
     `- stopping_reason: ${safe.stopping_reason}`,
     `- evaluations: ${safe.budgets.evaluations}`,
+    `- evaluation_attempts: ${safe.provenance.evaluation_attempts}`,
+    `- invalid_evaluations: ${safe.provenance.invalid_evaluations}`,
     `- generation_status: ${safe.generation?.status ?? "legacy_deterministic"}`,
     `- generated_candidates: ${safe.generation ? `${safe.generation.accepted}/${safe.generation.returned}` : "0/0"}`,
     `- generation_cost_units: ${safe.generation?.cost_units ?? 0}`,