create-agdf 0.11.3 → 0.11.4

package/README.md

@@ -115,7 +115,7 @@ it does not localize the CLI lifecycle card.
 - `claude` installs the AGDF plugin globally for Claude Code
 - `copilot` writes `AGENTS.md`, Copilot custom instructions under `.github/`, visible repository skills under `.github/skills/`, and AGDF control templates under `.agdf/control/`
 - `opencode` installs the AGDF npm plugin and ten native skills as a user-wide OpenCode surface
-- `opencode-status` reports OpenCode global config, package loadability, global native-skill completeness, durable repository activation, legacy compatibility and observable session signals
+- `opencode-status` reports OpenCode global config, package loadability, global native-skill completeness, installed host/plugin-SDK versions, declaration-level support for AGDF's two experimental hooks, durable repository activation, legacy compatibility and observable session signals
 - `status` reports installation, repository activation and delivery separately without mutating state
 - `disable` writes a supported repository-local opt-out while retaining global capability and durable control state
 - `uninstall` previews and, only with `--confirm`, applies a selected global removal through supported native/owned operations
@@ -149,7 +149,7 @@ Then verify the visible installation state:
 npx --yes @agdf/cli@latest opencode-status --json
 ```
 
-The status command reports global configuration, package loadability, global native-skill completeness, durable repository activation, legacy local-surface compatibility and session signals. It does not infer an active OpenCode session from config alone.
+The status command reports global configuration, package loadability, global native-skill completeness, installed host/plugin-SDK version divergence, declaration-level support for both experimental hooks, durable repository activation, legacy local-surface compatibility and session signals. SDK declarations are not proof that a live host invoked a hook, and host/SDK divergence is warning-only rather than auto-aligned. The command does not infer an active OpenCode session from config alone.
 In JSON schema version 1, `repository_surface.gate_check_agent` remains a deprecated compatibility alias for the native `gate_check_skill` path so existing status consumers keep working during the agent-to-skill migration.
 
 Use the `opencode-repo` target when a repository should opt into the globally installed AGDF OpenCode runtime:
@@ -235,7 +235,7 @@ Use `delivery-path-search` only for high-impact planning decisions with several
 agdf delivery-path-search --surface codex --json
 ```
 
-The runtime uses bounded best-first Delivery Path Search, not MCTS. It is read-only and advisory: the result must be checked by canonical `gate-check`. Codex and Claude Code are executable, tool-enforced evaluator adapters and support opt-in `--generate-candidates`; generated proposals supplement the deterministic baseline and are deterministically validated before evaluation. Copilot and OpenCode reuse the same skill and contracts as instruction-only surfaces until conforming executable adapters are available.
+The runtime uses bounded best-first Delivery Path Search, not MCTS. It is read-only and advisory: the result must be checked by canonical `gate-check`. Codex and Claude Code are executable, tool-enforced evaluator adapters and support opt-in `--generate-candidates`; generated proposals supplement the deterministic baseline and are deterministically validated before evaluation. OpenCode has an executable evaluator through `opencode run --pure --agent agdf-evaluator` only after the current invocation's capability preflight proves the command flags, owned agent and effective deny permissions. A failed preflight or evaluator transport returns `evaluator_unavailable`, reports `instruction_only` and directs the user to the existing instruction-only workflow. Copilot remains instruction-only.
 
 Requirements and boundaries:
 
@@ -243,10 +243,11 @@ Requirements and boundaries:
 - the current control state must expose legal next actions
 - Codex CLI must be installed and authenticated for `--surface codex`
 - Claude Code CLI must be installed and authenticated for `--surface claude`
+- OpenCode must pass the per-invocation command, agent and effective-permission preflight for `--surface opencode`
 - `--model <id>` optionally selects the Codex or Claude evaluator model
 - `--persist` writes redacted `DELIVERY_PATH_SEARCH.json` and `.md` evidence under the current scope
 - `--fixture <path>` is for deterministic contract tests, not a production evaluator
-- Copilot and OpenCode have shared workflow mappings but no executable native evaluator in this release
+- 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.

package/generated/.agdf/control/templates/MASTER_BACKLOG.md

@@ -15,7 +15,7 @@ This file is the living control pointer for active AGDF delivery work. Detailed
 9. Historical artefacts remain linkable but do not override the current pointer.
 10. If an item is superseded, mark the replacement.
 11. If active work grows beyond roughly ten items, triage the backlog.
-12. `Status` must be one of the human-readable labels normalized by `create-agdf/lib/control-evaluation/shared.js`: Needs UR, Awaiting Brownfield Review, Awaiting PRD, Awaiting PRD Approval, Awaiting SD, Awaiting SD Approval, Awaiting TP, Awaiting TP Approval, In Progress, Blocked, Awaiting QA, Awaiting UAT, Completed, Superseded, Abandoned. The parser module is authoritative; this list only mirrors it for readability.
+12. `Status` must be one of the human-readable labels normalized by `create-agdf/lib/control-evaluation/shared.js`: Needs UR, Awaiting Brownfield Review, Awaiting PRD, Awaiting PRD Approval, Awaiting SD, Awaiting SD Approval, Awaiting TP, Awaiting TP Approval, In Progress, Blocked, Awaiting QA, Awaiting UAT, Awaiting OR, Completed, Superseded, Abandoned. The parser module is authoritative; this list only mirrors it for readability.
 13. `Artefacts` link labels must be one of the labels normalized by the same parser module: `ur`, `brownfield`, `prd`, `sd`, `tp`, `qa`, `or` (case-insensitive). Do not invent other labels such as a raw artefact filename.
 14. After writing or updating this file, run `doctor --json` (or the locally available equivalent) and resolve any `AGDF_BACKLOG_STATUS_UNKNOWN` or `AGDF_BACKLOG_ARTEFACT_LABEL_UNKNOWN` finding before treating the edit as done.
 15. A `Work item` cell may optionally start with a bracketed scope tag, one of `[framework-maintenance]` or `[external-delivery]`, so the split between AGDF's own maintenance work and external product delivery stays visible at a glance. The tag is never required retroactively on `Completed / Superseded Pointers` rows. `create-agdf/lib/control-evaluation/shared.js` is authoritative for the accepted values.

package/generated/.github/skills/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/.opencode/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/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "agdf",
-  "version": "0.11.3",
+  "version": "0.11.4",
   "description": "AI Governance & Delivery Framework (AGDF) brings an operating system for governed AI-assisted delivery to Claude Code, combining workflow skills, control templates and machine-readable repository checks for gate decisions, Brownfield analysis, task-plan review, QA decisions, durable run state and auditable closeout.",
   "keywords": [
     "agentic",

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

@@ -1,6 +1,6 @@
 {
   "name": "agdf",
-  "version": "0.11.3",
+  "version": "0.11.4",
   "description": "Operating system for governed AI-assisted delivery.",
   "author": {
     "name": "Arndt Gold",

package/generated/plugins/agdf/control/templates/MASTER_BACKLOG.md

@@ -15,7 +15,7 @@ This file is the living control pointer for active AGDF delivery work. Detailed
 9. Historical artefacts remain linkable but do not override the current pointer.
 10. If an item is superseded, mark the replacement.
 11. If active work grows beyond roughly ten items, triage the backlog.
-12. `Status` must be one of the human-readable labels normalized by `create-agdf/lib/control-evaluation/shared.js`: Needs UR, Awaiting Brownfield Review, Awaiting PRD, Awaiting PRD Approval, Awaiting SD, Awaiting SD Approval, Awaiting TP, Awaiting TP Approval, In Progress, Blocked, Awaiting QA, Awaiting UAT, Completed, Superseded, Abandoned. The parser module is authoritative; this list only mirrors it for readability.
+12. `Status` must be one of the human-readable labels normalized by `create-agdf/lib/control-evaluation/shared.js`: Needs UR, Awaiting Brownfield Review, Awaiting PRD, Awaiting PRD Approval, Awaiting SD, Awaiting SD Approval, Awaiting TP, Awaiting TP Approval, In Progress, Blocked, Awaiting QA, Awaiting UAT, Awaiting OR, Completed, Superseded, Abandoned. The parser module is authoritative; this list only mirrors it for readability.
 13. `Artefacts` link labels must be one of the labels normalized by the same parser module: `ur`, `brownfield`, `prd`, `sd`, `tp`, `qa`, `or` (case-insensitive). Do not invent other labels such as a raw artefact filename.
 14. After writing or updating this file, run `doctor --json` (or the locally available equivalent) and resolve any `AGDF_BACKLOG_STATUS_UNKNOWN` or `AGDF_BACKLOG_ARTEFACT_LABEL_UNKNOWN` finding before treating the edit as done.
 15. A `Work item` cell may optionally start with a bracketed scope tag, one of `[framework-maintenance]` or `[external-delivery]`, so the split between AGDF's own maintenance work and external product delivery stays visible at a glance. The tag is never required retroactively on `Completed / Superseded Pointers` rows. `create-agdf/lib/control-evaluation/shared.js` is authoritative for the accepted values.

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

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "id": "agdf",
-  "version": "0.11.3",
+  "version": "0.11.4",
   "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/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/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.11.4",
   "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/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",

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

@@ -0,0 +1,234 @@
+import { execFileSync, spawnSync } from "node:child_process";
+import process from "node:process";
+import { validateEvaluation } from "../contracts.js";
+import { guardedExecFileSync } from "../transports/read-only-guard.js";
+import { buildEvaluatorPrompt } from "./prompt.js";
+
+export const OPENCODE_EVALUATOR_AGENT = "agdf-evaluator";
+
+export const OPENCODE_DENY_PERMISSIONS = Object.freeze({
+  "*": "deny",
+  read: "deny",
+  edit: "deny",
+  bash: "deny",
+  task: "deny",
+  webfetch: "deny",
+  websearch: "deny",
+  skill: "deny",
+  lsp: "deny",
+  todowrite: "deny",
+  question: "deny",
+  external_directory: "deny",
+});
+
+const executablePermissions = Object.freeze([
+  "edit", "bash", "task", "webfetch", "websearch", "skill", "lsp", "todowrite", "question",
+]);
+
+export function openCodePermissionEnvironment(env = process.env) {
+  return {
+    ...env,
+    OPENCODE_PERMISSION: JSON.stringify(OPENCODE_DENY_PERMISSIONS),
+  };
+}
+
+function preflightFailure(code, detail, evidence = []) {
+  return {
+    surface: "opencode",
+    status: "failed",
+    code,
+    detail,
+    evidence,
+  };
+}
+
+function extractAgentPermissions(output, agentName) {
+  const marker = `${agentName} (`;
+  const lines = output.split(/\r?\n/);
+  const start = lines.findIndex((line) => line.startsWith(marker));
+  if (start < 0) return null;
+  const mode = lines[start].slice(marker.length).split(")")[0];
+  let jsonStart = -1;
+  let depth = 0;
+  for (let index = start + 1; index < lines.length; index += 1) {
+    const line = lines[index].trim();
+    if (jsonStart < 0 && line === "[") {
+      jsonStart = index;
+      depth = 1;
+      continue;
+    }
+    if (jsonStart >= 0) {
+      for (const character of line) {
+        if (character === "[") depth += 1;
+        if (character === "]") depth -= 1;
+      }
+      if (depth === 0) return { mode, permissions: JSON.parse(lines.slice(jsonStart, index + 1).join("\n")) };
+    }
+  }
+  return null;
+}
+
+function terminalPermissionDecision(permissions, permissionName) {
+  let decision = null;
+  for (const entry of permissions) {
+    if (entry?.pattern === "*" && (entry.permission === "*" || entry.permission === permissionName)) {
+      decision = entry.action;
+    }
+  }
+  return decision;
+}
+
+export function preflightOpenCodeEvaluator(options = {}) {
+  const executable = options.openCodeBin ?? process.env.AGDF_OPENCODE_BIN ?? "opencode";
+  const run = options.execFileSync ?? execFileSync;
+  const cwd = options.cwd ?? process.cwd();
+  const agentName = options.agentName ?? OPENCODE_EVALUATOR_AGENT;
+  const env = openCodePermissionEnvironment(options.env ?? process.env);
+  let runtime;
+  let help;
+  let agents;
+  try {
+    runtime = run(executable, ["--version"], {
+      cwd, env, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 5000,
+    }).trim();
+  } catch (error) {
+    return preflightFailure("opencode_host_unavailable", (error.stderr || error.message).toString().trim());
+  }
+  try {
+    if (options.execFileSync) {
+      help = run(executable, ["run", "--help"], {
+        cwd, env, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 5000,
+      });
+    } else {
+      const helpProbe = (options.spawnSync ?? spawnSync)(executable, ["run", "--help"], {
+        cwd, env, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 5000,
+      });
+      if (helpProbe.error || helpProbe.status !== 0) throw helpProbe.error ?? new Error(helpProbe.stderr || "OpenCode run help failed.");
+      help = `${helpProbe.stdout ?? ""}\n${helpProbe.stderr ?? ""}`;
+    }
+  } catch (error) {
+    return preflightFailure("opencode_run_unavailable", (error.stderr || error.message).toString().trim(), [`opencode ${runtime}`]);
+  }
+  const requiredFlags = ["--pure", "--agent", "--format", "--dir"];
+  const missingFlags = requiredFlags.filter((flag) => !help.includes(flag));
+  if (missingFlags.length) {
+    return preflightFailure("opencode_run_capability_missing", `Missing required flags: ${missingFlags.join(", ")}`, [`opencode ${runtime}`]);
+  }
+  try {
+    agents = run(executable, ["agent", "list", "--pure"], {
+      cwd, env, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 10000,
+    });
+  } catch (error) {
+    return preflightFailure("opencode_agent_probe_failed", (error.stderr || error.message).toString().trim(), [`opencode ${runtime}`]);
+  }
+  let projection;
+  try {
+    projection = extractAgentPermissions(agents, agentName);
+  } catch (error) {
+    return preflightFailure("opencode_agent_permissions_unparseable", error.message, [`opencode ${runtime}`]);
+  }
+  if (!projection) {
+    return preflightFailure("opencode_evaluator_agent_missing", `OpenCode agent ${agentName} is not available.`, [`opencode ${runtime}`]);
+  }
+  if (projection.mode !== "primary") {
+    return preflightFailure("opencode_evaluator_agent_incompatible", `OpenCode agent ${agentName} must be primary for opencode run --agent; observed ${projection.mode || "unknown"}.`, [
+      `opencode ${runtime}`,
+      `agent:${agentName}`,
+    ]);
+  }
+  const unsafe = executablePermissions.filter((permission) => terminalPermissionDecision(projection.permissions, permission) !== "deny");
+  if (unsafe.length) {
+    return preflightFailure("opencode_evaluator_permissions_unsafe", `Terminal deny is not effective for: ${unsafe.join(", ")}`, [
+      `opencode ${runtime}`,
+      `agent:${agentName}`,
+    ]);
+  }
+  return {
+    surface: "opencode",
+    status: "passed",
+    code: "opencode_evaluator_ready",
+    invocation_id: `${process.pid}-${Date.now()}`,
+    runtime,
+    agent: agentName,
+    evidence: [
+      `opencode ${runtime}`,
+      "opencode run --pure --agent agdf-evaluator --format json",
+      "effective executable permissions terminal-deny",
+    ],
+    env,
+  };
+}
+
+export function parseOpenCodeEvaluatorOutput(raw) {
+  const text = [];
+  for (const line of raw.split(/\r?\n/).filter(Boolean)) {
+    const event = JSON.parse(line);
+    if (event?.type === "error") {
+      const status = event.error?.data?.statusCode;
+      const detail = event.error?.data?.message || event.error?.message || "unknown OpenCode evaluator error";
+      const error = new Error(`OpenCode evaluator error${status ? ` (${status})` : ""}: ${detail}`);
+      error.code = status === 401 || /auth|credential|provider available/i.test(detail)
+        ? "OPENCODE_EVALUATOR_AUTHENTICATION_FAILED"
+        : "OPENCODE_EVALUATOR_UNAVAILABLE";
+      throw error;
+    }
+    if (event?.part?.type === "text" && typeof event.part.text === "string") text.push(event.part.text);
+    else if (event?.type === "text" && typeof event.text === "string") text.push(event.text);
+  }
+  if (!text.length) throw new Error("OpenCode evaluator returned no text event.");
+  if (text.length !== 1) throw new Error(`OpenCode evaluator returned ${text.length} text events; exactly one final payload is required.`);
+  return JSON.parse(text[0]);
+}
+
+function fatalEvaluatorError(error) {
+  const wrapped = new Error(error.message);
+  wrapped.code = typeof error.code === "string" && error.code.startsWith("OPENCODE_EVALUATOR_")
+    ? error.code
+    : error.code === "GENERATOR_MUTATION_DETECTED"
+    ? "OPENCODE_EVALUATOR_MUTATION_DETECTED"
+    : error.code === "GENERATOR_TIMEOUT"
+      ? "OPENCODE_EVALUATOR_TIMEOUT"
+      : error.code === "ENOENT"
+        ? "OPENCODE_EVALUATOR_UNAVAILABLE"
+        : /auth|unauthorized|credential/i.test(`${error.message}\n${error.stderr ?? ""}`)
+          ? "OPENCODE_EVALUATOR_AUTHENTICATION_FAILED"
+          : "OPENCODE_EVALUATOR_OUTPUT_INVALID";
+  wrapped.fatalEvaluator = true;
+  return wrapped;
+}
+
+export function openCodeEvaluator(options = {}) {
+  if (options.preflight?.status !== "passed" || options.preflight.surface !== "opencode") {
+    throw new Error("OpenCode evaluator requires a successful current-invocation preflight.");
+  }
+  const executable = options.openCodeBin ?? process.env.AGDF_OPENCODE_BIN ?? "opencode";
+  const agentName = options.preflight.agent ?? OPENCODE_EVALUATOR_AGENT;
+  return {
+    name: "opencode",
+    metadata: {
+      name: "opencode",
+      runtime: options.preflight.runtime,
+      agent: agentName,
+      preflight: options.preflight.code,
+    },
+    async evaluate(input, candidate) {
+      const args = [
+        "run", "--pure", "--agent", agentName, "--format", "json", "--dir", options.cwd,
+      ];
+      if (options.model) args.push("--model", options.model);
+      args.push(buildEvaluatorPrompt(input, candidate));
+      try {
+        const raw = guardedExecFileSync(executable, args, {
+          cwd: options.cwd,
+          env: options.preflight.env,
+          encoding: "utf8",
+          stdio: ["ignore", "pipe", "pipe"],
+          timeout: options.timeoutMs ?? 120000,
+        });
+        return validateEvaluation(parseOpenCodeEvaluatorOutput(raw), candidate.id);
+      } catch (error) {
+        throw fatalEvaluatorError(error);
+      }
+    },
+  };
+}

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

@@ -0,0 +1,13 @@
+export function buildEvaluatorPrompt(input, candidate) {
+  return [
+    "You are an evaluation-only component. Do not use tools, execute commands, inspect files, delegate work or modify state.",
+    `Return only one JSON object 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");
+}

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

@@ -114,6 +114,7 @@ export async function runDeliveryPathSearch(inputValue, evaluator, options = {})
         }
       }
     } catch (error) {
+      if (error?.fatalEvaluator === true) throw error;
       rejected.push({ candidate_id: candidate.id, action: candidate.action, reason: `invalid_evaluation: ${error.message}` });
     }
   }