create-agdf 0.11.3 → 0.12.0

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

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "id": "agdf",
-  "version": "0.11.3",
+  "version": "0.12.0",
   "displayName": "AI Governance & Delivery Framework",
   "developerName": "Arndt Gold",
   "description": "Operating system for governed AI-assisted delivery.",
@@ -59,6 +59,7 @@
   "opencode": {
     "skillPrefix": "agdf-",
     "globalSkillPrefix": "agdf-global-",
+    "evaluatorAgentName": "agdf-evaluator",
     "runtimeContractFileName": "agdf-runtime-contract.md",
     "instructionsFileName": "AGDF.md",
     "npmPackage": "create-agdf",

package/generated/plugins/agdf/meta/agdf-runtime-contract.md

@@ -4,6 +4,7 @@ This manifest indexes the thematic runtime-contract modules used by AGDF skills
 
 | Module | Path | Coverage |
 |---|---|---|
+| Task target resolution | `contracts/task-target-resolution.md` | Primary target authority, evidence/mutation separation, governance derivation, continuation and fail-closed target states |
 | Gate transitions | `contracts/gate-transition.md` | Source precedence, scope ambiguity, gate rules, Brownfield routing and transition model |
 | Interaction | `contracts/interaction.md` | Run Status Card, approval orientation, native interaction and locale contracts |
 | Modes | `contracts/modes.md` | Mode selection, Quick Task, Verified Change, trivial and bug boundaries |

package/generated/plugins/agdf/meta/contracts/control-scaffold.md

@@ -17,6 +17,8 @@ Delivery Path Search is an optional read-only planning step for high-impact deci
 - External generation receives only bounded normalized control summaries and references, never secrets, full artefacts, raw prompts, hidden reasoning or source snapshots.
 - Generator status, provenance, accepted/rejected counts, separate budget use and typed failure must remain visible. Failure retains the deterministic baseline; automatic provider fallback is forbidden.
 - 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.
 
 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/contracts/gate-transition.md

@@ -93,9 +93,13 @@ Mode/Slice Decision rules:
 
 - `quick_task`: use only when Brownfield Review shows a narrow local change, no new product semantics beyond the approved UR, no architecture/policy/persistence/contract expansion, and evidence is sufficient to proceed with a small implementation plus relevant checks.
 - `verified_change`: use only when the compact record can prove one canonical owner, bounded clean-at-baseline paths, no prohibited impact, deterministic propagation/validation and a structured escalation target. It skips later approvals only after every condition is evidenced and machine-validated.
-- `structured_slice`: use when some formal artefacts are needed, but they can stay intentionally small and scoped to the approved slice.
-- `structured_delivery`: use when the change has broad product, architecture, runtime, policy, persistence, release or cross-owner impact.
-- `block`: use when ownership, SoT, impact, evidence or product direction is not clear enough to choose a safe path.
+- `structured_slice` and `structured_delivery`: apply the sole normative `Structured Depth Decision`
+  in `modes.md`; this contract owns only the operational transition and does not duplicate its
+  trigger or bounded-slice matrix.
+- `block`: use when ownership, SoT, impact, evidence or product direction is not clear enough to
+  choose a safe path. A `depth_unresolved` product result is persisted through this existing value
+  with `depth_facts_missing | depth_facts_conflicting`, a Brownfield Review evidence link and a
+  precise evidence-owner/re-evaluation next action; it never creates a new mode or advances a gate.
 
 A Mode/Slice Decision without scope reason and evidence is not recorded. Treat it as missing and keep the next step at `Mode/Slice Decision`.
 

package/generated/plugins/agdf/meta/contracts/interaction.md

@@ -338,6 +338,28 @@ repeat the sentence later in the same request. Existing-run status inspection re
 uses the existing status projection; this branch must not create a second status-card or narration
 owner.
 
+### Task Target Orientation
+
+Task-target semantics and ordering live in `task-target-resolution.md`. When target/context
+separation is material, a confirmed target changes, or resolution is unresolved, the agent consumes
+the canonical `task_target_orientation.markdown` verbatim from `renderTaskTargetOrientation` in
+`create-agdf/lib/interaction-presentation.js`.
+
+The projection may show the primary target, governance target, evidence sources and working
+directory for a resolved result. For an unresolved result it shows the localized reason and required
+next action. It carries `authorizes: false`, never renders approval controls and never selects or
+derives a target.
+
+For a fresh request, render the target orientation before read-only orientation, Scope
+Classification or any gate presentation when it is required. An unresolved result suppresses every
+downstream orientation and gate surface. A resolved result with material target separation may be
+followed by the one applicable downstream surface. Avoid a redundant target block for an obvious
+unchanged target.
+
+If the input is incomplete or contradictory, the renderer returns `null`. The agent then fails closed
+to target clarification and must not model-reconstruct Markdown. `gate-check` must not maintain a
+skill-local target-orientation template.
+
 ### Scope Classification Card
 
 When `gate-check` classifies a fresh scope as ungated (Quick Task or Trivial Change Boundary),

package/generated/plugins/agdf/meta/contracts/modes.md

@@ -36,6 +36,87 @@ reason, evidence and required next depth in the same internal operation. `Mode/S
 only a fail-closed recovery step for incomplete or legacy records and is not a normal second user
 decision.
 
+### Structured Depth Decision
+
+This section is the sole normative owner for choosing between `structured_slice` and
+`structured_delivery`. Apply it only after an approved durable UR, a Brownfield Review of the
+existing-system context, and unchanged evaluation of Quick Task/Compact Delivery and Verified
+Change. A compact path must be ineligible or explicitly escalated, and the decisive depth facts must
+be durably evidenced before a positive structured decision is recorded.
+
+Choose `structured_delivery` when any one evidenced full-depth trigger applies:
+
+1. **Authority, policy or security** — a trust or authority boundary, permission, security,
+   compliance or normative policy changes, or independent decision owners require coordinated
+   approval.
+2. **Architecture or runtime** — execution, orchestration, durable execution, concurrency, failure
+   or recovery boundaries change beyond a local slice.
+3. **Persistence, data or migration** — persistent schema or meaning changes, data migration,
+   irreversible state transition, coordinated cutover, an extended compatibility window or
+   non-local rollback is required.
+4. **External or public contract** — an external API, public CLI behavior, protocol, file format or
+   compatibility-sensitive integration contract changes, including independent consumer
+   coordination or versioning.
+5. **Release, deployment or cross-host** — the work needs its own rollout, deployment, rollback,
+   feature-flag or release plan, or coordinated activation across hosts, products or operational
+   boundaries.
+6. **Unbounded consumer or owner coordination** — the outcome cannot be delivered as an
+   independently acceptable and reversible slice, or consumers or owners require a shared cutover
+   or compatibility window.
+
+A single trigger is decisive because of its effect, never because of a numeric count.
+
+Choose `structured_slice` only when `depth_facts_status` is `complete`, no full-depth trigger is
+evidenced, and all seven bounded-slice checks are positively evidenced as `pass`:
+
+| Check ID | Required evidence |
+|---|---|
+| `coherent_outcome` | One coherent user or product outcome has a clear acceptance boundary. |
+| `authority_boundary` | Authority and source of truth are known and no new trust, policy, permission or security boundary is introduced. |
+| `owner_consumer_coordination` | Owners and consumers are identified and coordination stays inside the slice without a shared external cutover. |
+| `full_depth_impacts_absent` | Architecture, runtime, persistence, data, external API, public CLI, release and cross-host effects are evidenced as not full-depth relevant. |
+| `migration_propagation_bounded` | Migration and propagation are bounded, compatible, testable and locally reversible. |
+| `failure_recovery_local` | Failure, recovery and rollback remain controllable inside the slice. |
+| `independently_acceptable` | The slice has independent acceptance signals and hides no unknown later work as a prerequisite. |
+
+Multiple files, owners, consumers or derived paths do not fail these checks by themselves. File,
+owner, consumer, task or derived-path counts are not a decision proxy and must never be used as a
+threshold for either structured mode.
+
+If a decisive fact is missing or conflicting and no evidenced full-depth trigger already supports
+`structured_delivery`, the product-language result is `depth_unresolved`. This is not a persisted
+mode. Persist the existing Mode/Slice value `block`, use `depth_facts_missing` or
+`depth_facts_conflicting`, name the affected facts and evidence owner where known, link the
+Brownfield Review, forbid later artefacts and implementation, and provide a precise next action for
+evidence completion and Brownfield/Mode-Slice re-evaluation. Unknown facts must not default to
+`structured_delivery`.
+
+Positive decisions persist the existing `structured_slice | structured_delivery` value, required
+next gate, a `scope_reason` containing the primary reason code and decisive rationale plus the
+rejected alternative, and evidence linking the complete Structured Depth Evidence. Re-evaluate
+before continuing whenever scope growth reveals a new full-depth trigger.
+
+Normalized reason codes are audit and rationale categories, not new modes or gates:
+
+- `bounded_structured_slice`
+- `authority_policy_security_depth`
+- `architecture_runtime_depth`
+- `persistence_migration_depth`
+- `external_contract_depth`
+- `release_cross_host_depth`
+- `unbounded_consumer_coordination`
+- `depth_facts_missing`
+- `depth_facts_conflicting`
+
+Structured Slice and Structured Delivery use the same existing gate and approval sequence. Their
+difference is artefact depth: Slice artefacts cover only the coherent bounded outcome and its owners,
+contracts, propagation, recovery, tasks and tests; Full Delivery covers every affected authority,
+architecture, runtime, consumer, migration, operational and release boundary.
+
+Historical or deterministic benchmark observations are non-authorizing evidence. They do not define
+this policy, retroactively regrade historical runs or prove live-host behavior. A future benchmark
+may apply this policy only with complete, versioned neutral depth facts.
+
 ### Verified Change
 
 `verified_change` is a compact, fail-closed path for a bounded user-visible change with one canonical owner and deterministic proof. It is neither a prose exception nor a new user approval gate.

package/generated/plugins/agdf/meta/contracts/task-target-resolution.md

@@ -0,0 +1,102 @@
+# AGDF Runtime Contract — Task Target Resolution
+
+## Purpose And Ordering
+
+Resolve the user's primary work target before repository activation, Scope Classification, mode
+selection or gate evaluation. Repository governance is downstream of the task target; the current
+working directory, an inspected repository or a source mentioned as evidence must never become the
+work target by accident.
+
+The canonical order is:
+
+1. resolve or revalidate the task target;
+2. derive the governance target from that resolved target;
+3. activate repository-local AGDF control only for that governance target;
+4. then apply read-only orientation, Scope Classification, mode selection and gate evaluation.
+
+If task-target resolution is unresolved, steps 2–4 and every mutation are forbidden.
+
+## Resolution Result
+
+Use one normalized result:
+
+- `resolution_state`: `resolved | unresolved`
+- `reason_code`: `explicit_target | continued_target | multiple_plausible_targets |
+  target_content_mismatch | target_unavailable | no_reliable_target`
+- `primary_target`: exactly one requested work object when resolved, otherwise empty
+- `evidence_sources`: zero or more mentioned or inspected sources that do not gain mutation authority
+- `working_directory`: execution context only, never target authority by itself
+- `governance_target`: the repository whose control state applies to the primary target, otherwise empty
+- `target_changed`: whether an explicit new target replaced the previously confirmed target
+- `next_action`: required clarification, supply or retry action when unresolved
+
+A resolved result requires a non-empty `primary_target` and a reason code of `explicit_target` or
+`continued_target`. An unresolved result requires an empty `primary_target`, an empty
+`governance_target`, one of the four unresolved reason codes and a non-empty `next_action`.
+Contradictory or incomplete results fail closed.
+
+## Target Authority Precedence
+
+Resolve in this order:
+
+1. an explicit file, artefact or repository named as the work target in the current user turn;
+2. a previously confirmed target only when the current turn unambiguously continues the same action,
+   object and scope;
+3. the current repository or working directory only when the request explicitly or deictically asks
+   for work on "this project", "this repository" or an equivalent current-scope reference;
+4. otherwise `no_reliable_target`.
+
+An explicit current-turn target always replaces an inherited target. Make the change visible when
+the previous target could otherwise remain plausible.
+
+Do not fall back to the working directory, a neighboring file or an evidence source when the
+explicit target is unavailable or its content does not support the requested change.
+
+## Evidence And Mutation Boundary
+
+Reading, inspecting, mentioning or relying on a repository or artefact makes it an evidence source,
+not a mutation target. Evidence access never grants mutation authority and never activates that
+repository's AGDF control state.
+
+Derive `governance_target` only from:
+
+- the repository containing the resolved `primary_target`; or
+- an explicit user statement that a named repository governs the target.
+
+An external standalone artefact may have no repository governance target. In that case the router
+continues with the applicable non-repository path; it must not borrow governance from the current
+working directory.
+
+## Continuation And Target Change
+
+A confirmed target may continue across related turns only when the current request remains
+unambiguous. Revalidate it before every mutation or gate decision. New explicit target evidence wins.
+New ambiguity ends the inherited binding and produces `multiple_plausible_targets`.
+
+When a durable AGDF run exists, its Source And Scope State may record the confirmed target as
+evidence. It does not override a newer explicit user target. Outside a run, continuation remains
+transient conversation state; do not create a global target store or a second run-state owner.
+
+## Fail-Closed States
+
+- `multiple_plausible_targets`: more than one work target remains plausible; list the candidates and
+  request the smallest clarification.
+- `target_content_mismatch`: the requested content change is not supported by the explicit target's
+  observable content; name the mismatch and ask whether the target or requested change should change.
+- `target_unavailable`: the named file, attachment or artefact cannot be inspected; request supply or
+  access and offer a visible retry.
+- `no_reliable_target`: neither an explicit target nor an unambiguous continuation exists; request a
+  target.
+
+These states forbid repository activation, Scope Classification, gate evaluation and mutation.
+Never silently expand scope to make the request fit a different project.
+
+## Presentation Boundary
+
+`contracts/interaction.md` owns the visible, non-authorizing Task Target Orientation.
+`create-agdf/lib/interaction-presentation.js` owns its rendering. The renderer projects a normalized
+result; it must not resolve targets, derive governance or become a state store.
+
+Show orientation when target/context separation is material, when the target changes, or when the
+result is unresolved. Avoid redundant presentation for an obvious unchanged target. Presentation
+never grants mutation or gate authority.

package/generated/plugins/agdf/runtime/create-agdf/generated/plugins/agdf/meta/agdf-interaction-locales.json

@@ -58,6 +58,31 @@
         "escalation": "Escalation triggers",
         "challenge": "Challenge path"
       },
+      "taskTargetResolution": {
+        "title": "AGDF task target",
+        "field": "Field",
+        "value": "Value",
+        "state": "Resolution",
+        "resolved": "Resolved",
+        "unresolved": "Clarification required",
+        "primaryTarget": "Primary target",
+        "governanceTarget": "Governance target",
+        "evidenceSources": "Evidence sources",
+        "workingDirectory": "Working directory",
+        "targetChanged": "Target changed",
+        "yes": "yes",
+        "none": "none",
+        "reason": "Reason",
+        "nextAction": "Next action",
+        "reasonCodes": {
+          "explicit_target": "Explicit current-turn target",
+          "continued_target": "Confirmed target continued",
+          "multiple_plausible_targets": "Multiple plausible work targets",
+          "target_content_mismatch": "Requested change mismatches target",
+          "target_unavailable": "Named target is unavailable",
+          "no_reliable_target": "No reliable work target"
+        }
+      },
       "internalStateLabels": {
         "verifiedChange": "Compact change under review",
         "verifiedChangeEscalated": "Escalated to structured delivery",
@@ -284,6 +309,31 @@
         "escalation": "Eskalationsauslöser",
         "challenge": "Widerspruchspfad"
       },
+      "taskTargetResolution": {
+        "title": "AGDF-Arbeitsziel",
+        "field": "Feld",
+        "value": "Wert",
+        "state": "Auflösung",
+        "resolved": "Aufgelöst",
+        "unresolved": "Klärung erforderlich",
+        "primaryTarget": "Primäres Ziel",
+        "governanceTarget": "Governance-Ziel",
+        "evidenceSources": "Evidenzquellen",
+        "workingDirectory": "Arbeitsordner",
+        "targetChanged": "Ziel gewechselt",
+        "yes": "ja",
+        "none": "keines",
+        "reason": "Grund",
+        "nextAction": "Nächste Aktion",
+        "reasonCodes": {
+          "explicit_target": "Explizites Ziel im aktuellen Turn",
+          "continued_target": "Bestätigtes Ziel wird fortgesetzt",
+          "multiple_plausible_targets": "Mehrere plausible Arbeitsziele",
+          "target_content_mismatch": "Änderung passt nicht zum Zielinhalt",
+          "target_unavailable": "Benanntes Ziel ist nicht verfügbar",
+          "no_reliable_target": "Kein belastbares Arbeitsziel"
+        }
+      },
       "internalStateLabels": {
         "verifiedChange": "Kompakte Änderung wird geprüft",
         "verifiedChangeEscalated": "Eskaliert zu structured delivery",

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.11.3",
+  "version": "0.12.0",
   "displayName": "AI Governance & Delivery Framework",
   "developerName": "Arndt Gold",
   "description": "Operating system for governed AI-assisted delivery.",
@@ -59,6 +59,7 @@
   "opencode": {
     "skillPrefix": "agdf-",
     "globalSkillPrefix": "agdf-global-",
+    "evaluatorAgentName": "agdf-evaluator",
     "runtimeContractFileName": "agdf-runtime-contract.md",
     "instructionsFileName": "AGDF.md",
     "npmPackage": "create-agdf",

package/generated/plugins/agdf/runtime/create-agdf/lib/cli/command-registry.js

@@ -27,8 +27,8 @@ export const commandRegistry = Object.freeze([
   command("gate-check", { local: [" --approval-envelope", " --json"], scaffold: [""], legacy: [" --json"] }),
   command("delivery-map", { local: [" --json"], scaffold: [""] }),
   command("delivery-path-search", {
-    local: [" --surface codex --json", " --surface claude --json"],
-    scaffold: [" --surface codex", " --surface claude"],
+    local: [" --surface codex --json", " --surface claude --json", " --surface opencode --json"],
+    scaffold: [" --surface codex", " --surface claude", " --surface opencode"],
   }),
   command("run-create", { local: [" --run <run_id>"] }),
   command("run-migrate", { local: [" [--run <run_id>]"] }),

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

@@ -3,6 +3,7 @@ import { searchInputFromControl } from '../delivery-path-search/state-adapter.js
 import { runDeliveryPathSearch } from '../delivery-path-search/search-engine.js';
 import { codexEvaluator } from '../delivery-path-search/evaluators/codex.js';
 import { claudeEvaluator } from '../delivery-path-search/evaluators/claude.js';
+import { openCodeEvaluator, preflightOpenCodeEvaluator } from '../delivery-path-search/evaluators/opencode.js';
 import { fixtureEvaluator } from '../delivery-path-search/evaluators/protocol.js';
 import { codexGenerator } from '../delivery-path-search/generators/codex.js';
 import { claudeGenerator } from '../delivery-path-search/generators/claude.js';
@@ -10,12 +11,56 @@ import { fixtureGenerator } from '../delivery-path-search/generators/protocol.js
 import { enforcementForSurface } from '../delivery-path-search/surfaces/capabilities.js';
 import { persistSearchResult } from '../delivery-path-search/persistence.js';
 
-export async function executeDeliveryPathSearch(options, io = console) {
+function unavailableOpenCodeResult({ options, preflight, input = null, error = null }) {
+  const mutation = error?.code === "OPENCODE_EVALUATOR_MUTATION_DETECTED";
+  const attempted = Boolean(input);
+  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",
+    scope_key: input?.scope_key ?? options.runId ?? null,
+    current_gate: input?.current_gate ?? null,
+    status: mutation ? "evaluator_error" : "evaluator_unavailable",
+    recommendation: null,
+    enforcement: enforcementForSurface("opencode"),
+    evaluator: {
+      name: "opencode",
+      preflight: preflight?.code ?? "not_run",
+      failure_code: error?.code ?? preflight?.code,
+      detail: error?.message ?? preflight?.detail,
+      evidence: preflight?.evidence ?? [],
+    },
+    executable_evaluator: {
+      attempted,
+      preflight: preflight?.status ?? "failed",
+      failure_code: error?.code ?? preflight?.code,
+      evidence: preflight?.evidence ?? [],
+    },
+    stopping_reason: mutation ? "opencode_mutation_detected" : attempted ? "opencode_evaluator_failed" : "opencode_preflight_failed",
+    next_action: nextAction,
+    next_gate_action: nextAction,
+  };
+}
+
+export async function executeDeliveryPathSearch(options, io = console, dependencies = {}) {
   const fixture = options.fixture ? JSON.parse(readFileSync(options.fixture, "utf8")) : null;
-  const enforcement = fixture?.input?.enforcement ?? enforcementForSurface(options.surface);
+  const preflight = !fixture && options.surface === "opencode"
+    ? (dependencies.preflightOpenCodeEvaluator ?? preflightOpenCodeEvaluator)({ cwd: options.dir })
+    : null;
+  if (preflight?.status === "failed") {
+    const result = unavailableOpenCodeResult({ options, preflight });
+    printDeliveryPathSearchResult(result, options, io);
+    return result;
+  }
+  const enforcement = fixture?.input?.enforcement
+    ?? (preflight
+      ? enforcementForSurface("opencode", preflight.evidence, { preflight })
+      : enforcementForSurface(options.surface));
   const fixtureGeneration = fixture?.generator_response;
   const generationEnabled = Boolean(fixtureGeneration || options.generateCandidates);
-  const baseInput = fixture?.input ?? searchInputFromControl(options.dir, {
+  const baseInput = fixture?.input ?? (dependencies.searchInputFromControl ?? searchInputFromControl)(options.dir, {
     scopeKey: options.runId,
     enforcement,
     generation: generationEnabled ? {
@@ -41,9 +86,11 @@ export async function executeDeliveryPathSearch(options, io = console) {
       ? codexEvaluator({ cwd: options.dir, model: options.model })
       : options.surface === "claude"
         ? claudeEvaluator({ cwd: options.dir, model: options.model })
-        : null;
+        : options.surface === "opencode"
+          ? (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 and Claude are the reference adapters; --fixture is available for deterministic contract testing.`);
+    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 generator = fixtureGeneration
     ? fixtureGenerator(fixtureGeneration)
@@ -55,21 +102,38 @@ export async function executeDeliveryPathSearch(options, io = console) {
   if (options.generateCandidates && !generator) {
     throw new Error(`${options.surface} has no executable candidate generator; Codex and Claude are tool-enforced reference transports.`);
   }
-  const result = await runDeliveryPathSearch(input, evaluator, { candidates: fixture?.candidates, generator });
-  if (options.persist) result.persistence = persistSearchResult(options.dir, result);
+  let result;
+  try {
+    result = await (dependencies.runDeliveryPathSearch ?? runDeliveryPathSearch)(input, evaluator, { candidates: fixture?.candidates, generator });
+    if (!fixture && options.surface === "opencode" && result.budgets?.evaluations === 0) {
+      result.enforcement = enforcementForSurface("opencode");
+    }
+  } catch (error) {
+    if (!error?.fatalEvaluator || options.surface !== "opencode") throw error;
+    result = unavailableOpenCodeResult({ options, preflight, input, error });
+  }
+  if (options.persist && ["recommendation", "no_safe_recommendation"].includes(result.status)) {
+    result.persistence = (dependencies.persistSearchResult ?? persistSearchResult)(options.dir, result);
+  }
+  printDeliveryPathSearchResult(result, options, io);
+  return result;
+}
+
+function printDeliveryPathSearchResult(result, options, io) {
   if (options.json) {
     io.log(JSON.stringify(result, null, 2));
-    return result;
+    return;
   }
   io.log(`AGDF Delivery Path Search: ${result.status}`);
-  io.log(`Current gate: ${result.current_gate}`);
+  io.log(`Current gate: ${result.current_gate ?? "unknown"}`);
   io.log(`Enforcement: ${result.enforcement.level}`);
   io.log(`Recommendation: ${result.recommendation?.action ?? "none"}`);
-  io.log(`Evaluations: ${result.budgets.evaluations}`);
-  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}`);
+  if (result.budgets) io.log(`Evaluations: ${result.budgets.evaluations}`);
+  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);
-  return result;
 }

package/generated/plugins/agdf/runtime/create-agdf/lib/control-evaluation/gate-policy.js

@@ -29,8 +29,9 @@ export function isGateSatisfied(runState, gate) {
   return isDurableGateArtefactSatisfied(runState, gate);
 }
 
-function qaRevisionRequired(runState) {
-  return gateArtefactStatus(runState, "QA").status === "revise";
+function qaNonPassDecision(runState) {
+  const status = gateArtefactStatus(runState, "QA").status;
+  return status === "revise" || status === "block" ? status : null;
 }
 
 export function transitionDecisionForRunState(runState, verifiedChange = null) {
@@ -233,15 +234,21 @@ export function transitionDecisionForRunState(runState, verifiedChange = null) {
     };
   }
 
-  if (qaRevisionRequired(runState)) {
+  const qaNonPass = qaNonPassDecision(runState);
+  if (qaNonPass) {
+    const blocked = qaNonPass === "block";
     return {
-      status: "open",
+      status: blocked ? "blocked" : "open",
       current_gate: "QA",
-      blocking_reason: "qa_revise_required",
+      blocking_reason: blocked ? "qa_blocked" : "qa_revise_required",
       missing_approval: "none",
-      allowed: ["revise the implementation against the QA findings", "refresh CD+Tests and mandatory reviews", "rerun QA with refreshed evidence"],
+      allowed: blocked
+        ? ["route the blocking QA findings to their authoritative owner", "record the next permitted remediation or upstream decision", "rerun QA only after the blocker is resolved"]
+        : ["revise the implementation against the QA findings", "refresh CD+Tests and mandatory reviews", "rerun QA with refreshed evidence"],
       forbidden: ["request QA approval", "request UAT approval", "release", "claim delivery readiness"],
-      next_allowed_action: "Resolve the QA revise findings, refresh CD+Tests and reviews, then rerun QA. Do not request Approval: QA from a revise report.",
+      next_allowed_action: blocked
+        ? "Resolve or route the blocking QA findings through their authoritative owner, then rerun the required delivery steps. Do not request Approval: QA from a block report."
+        : "Resolve the QA revise findings, refresh CD+Tests and reviews, then rerun QA. Do not request Approval: QA from a revise report.",
     };
   }
 

package/generated/plugins/agdf/runtime/create-agdf/lib/control-evaluation/shared.js

@@ -56,6 +56,7 @@ const backlogStatusLabels = new Map([
   ["blocked", "blocked"],
   ["awaiting qa", "awaiting_qa"],
   ["awaiting uat", "awaiting_uat"],
+  ["awaiting or", "awaiting_or"],
   ["completed", "completed"],
   ["superseded", "superseded"],
   ["abandoned", "abandoned"],

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

@@ -1,6 +1,7 @@
 import { execFileSync } from "node:child_process";
 import { evaluatorOutputSchema, validateEvaluation } from "../contracts.js";
 import { guardedExecFileSync } from "../transports/read-only-guard.js";
+import { buildEvaluatorPrompt } from "./prompt.js";
 
 export function claudeEvaluator(options = {}) {
   const claudeBin = options.claudeBin ?? "claude";
@@ -13,17 +14,7 @@ export function claudeEvaluator(options = {}) {
     name: "claude",
     metadata: { name: "claude", runtime, model: options.model ?? "configured-default" },
     async evaluate(input, candidate) {
-      const prompt = [
-        "You are an evaluation-only component. Do not use tools, execute commands, or modify files.",
-        `Return JSON matching contract version ${input.contract_version}.`,
-        `Objective: ${input.objective}`,
-        `Current gate: ${input.current_gate}`,
-        `Candidate id: ${candidate.id}`,
-        `Candidate action: ${candidate.action}`,
-        "Score scope_fit, gate_readiness, risk_reduction, evidence_gain, testability, reversibility and cost from 0 to 5.",
-        "Cost 0 is low and 5 is high. uncertainty is 0 low to 5 high.",
-        "Keep rationale concise. child_actions must only contain actions permitted by the current gate.",
-      ].join("\n");
+      const prompt = buildEvaluatorPrompt(input, candidate);
       const args = [
         "-p", "--disallowedTools", "Edit,Write,Bash",
         "--output-format", "json", "--json-schema", JSON.stringify(evaluatorOutputSchema()),

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

@@ -4,6 +4,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { evaluatorOutputSchema, validateEvaluation } from "../contracts.js";
 import { guardedExecFileSync } from "../transports/read-only-guard.js";
+import { buildEvaluatorPrompt } from "./prompt.js";
 
 export function codexEvaluator(options = {}) {
   const codexBin = options.codexBin ?? "codex";
@@ -21,17 +22,7 @@ export function codexEvaluator(options = {}) {
       const outputPath = join(temp, "output.json");
       try {
         writeFileSync(schemaPath, `${JSON.stringify(evaluatorOutputSchema(), null, 2)}\n`, "utf8");
-        const prompt = [
-          "You are an evaluation-only component. Do not use tools, execute commands, or modify files.",
-          `Return JSON matching contract version ${input.contract_version}.`,
-          `Objective: ${input.objective}`,
-          `Current gate: ${input.current_gate}`,
-          `Candidate id: ${candidate.id}`,
-          `Candidate action: ${candidate.action}`,
-          "Score scope_fit, gate_readiness, risk_reduction, evidence_gain, testability, reversibility and cost from 0 to 5.",
-          "Cost 0 is low and 5 is high. uncertainty is 0 low to 5 high.",
-          "Keep rationale concise. child_actions must only contain actions permitted by the current gate.",
-        ].join("\n");
+        const prompt = buildEvaluatorPrompt(input, candidate);
         const args = [
           "exec", "--sandbox", "read-only", "--ephemeral", "--ignore-user-config",
           "--output-schema", schemaPath, "--output-last-message", outputPath, "--color", "never",