create-agdf 0.14.1 → 0.14.3

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

@@ -0,0 +1,331 @@
+{
+  "schemaVersion": 1,
+  "id": "agdf",
+  "version": "0.14.3",
+  "displayName": "AI Governance & Delivery Framework",
+  "developerName": "Arndt Gold",
+  "description": "Control layer for governed AI-assisted delivery.",
+  "longDescription": "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.",
+  "homepage": "https://agdf.iself.eu",
+  "repository": "https://github.com/arndtgold/ai-native-governance-delivery-framework",
+  "license": "Apache-2.0",
+  "keywords": [
+    "agentic",
+    "governance",
+    "delivery",
+    "ai-native",
+    "brownfield"
+  ],
+  "category": "Productivity",
+  "brandColor": "#14B8A6",
+  "author": {
+    "name": "Arndt Gold",
+    "url": "https://agdf.iself.eu"
+  },
+  "codex": {
+    "skills": "./skills/",
+    "skillPrefix": "",
+    "agentRouter": "meta/agdf-agent-router.md",
+    "composerIcon": "./assets/agdf-icon.svg",
+    "logo": "./assets/agdf-logo.svg",
+    "capabilities": [
+      "Read",
+      "Write"
+    ],
+    "defaultPrompt": [
+      "Assess whether AGDF fits this request and recommend the lightest safe path before proposing implementation.",
+      "Start this request under AGDF governance.",
+      "Close this delivery run with an auditable AGDF report."
+    ],
+    "hooks": "hooks/hooks.json"
+  },
+  "claude": {
+    "skillPrefix": "",
+    "agentRouter": "meta/agdf-agent-router.md",
+    "defaultPrompt": [
+      "Assess whether AGDF fits this request and recommend the lightest safe path before proposing implementation.",
+      "Start this request under AGDF governance.",
+      "Close this delivery run with an auditable AGDF report."
+    ]
+  },
+  "copilot": {
+    "skillPrefix": "agdf-",
+    "runtimeContractFileName": "agdf-runtime-contract.md",
+    "pluginManifest": "plugin.json",
+    "skills": "copilot-skills/",
+    "hooks": "hooks/copilot-hooks.json"
+  },
+  "opencode": {
+    "skillPrefix": "agdf-",
+    "globalSkillPrefix": "agdf-global-",
+    "evaluatorAgentName": "agdf-evaluator",
+    "runtimeContractFileName": "agdf-runtime-contract.md",
+    "instructionsFileName": "AGDF.md",
+    "npmPackage": "create-agdf",
+    "permissions": {
+      "question": "allow",
+      "edit": "ask",
+      "bash": "ask",
+      "skill": {
+        "agdf-*": "allow"
+      }
+    }
+  },
+  "automaticRuntimeChecks": {
+    "schemaVersion": 1,
+    "capabilityId": "automatic-runtime-checks",
+    "adapterContractVersion": 1,
+    "entrypoint": "runtime/agdf-session-check.js",
+    "operations": [
+      "resolve-local-runtime",
+      "inspect-control-state",
+      "render-bounded-orientation"
+    ],
+    "constraints": {
+      "arguments": "forbidden",
+      "filesystemWrites": "forbidden",
+      "network": "forbidden",
+      "gateAuthority": "none"
+    },
+    "surfaces": {
+      "codex": "native-hook-review",
+      "claude": "exact-command-rule",
+      "copilot": "plugin-hook-review",
+      "opencode": "plugin-internal",
+      "portable-skills": "manual-external-required"
+    }
+  },
+  "interactions": {
+    "fallback": "exact_text",
+    "localeRegistry": "meta/agdf-interaction-locales.json",
+    "fallbackLocale": "en",
+    "optionOrder": [
+      "approve",
+      "revise",
+      "decline",
+      "cancel"
+    ],
+    "outcomes": [
+      "approve",
+      "revise",
+      "decline",
+      "cancel",
+      "no_response",
+      "timeout",
+      "empty",
+      "invalid",
+      "stale"
+    ],
+    "surfaces": {
+      "codex": {
+        "questionAdapter": "request_user_input",
+        "availability": "when_callable",
+        "gateSafety": "omit_auto_resolution",
+        "explicitOutcomes": [
+          "approve",
+          "revise",
+          "decline"
+        ],
+        "dismissOutcome": "cancel",
+        "approvalValueTransport": "exact_option_value",
+        "waitSafety": "deliberate_no_auto_resolution",
+        "authorizationPath": "exact_text",
+        "technicalPermissionOwner": "codex_host"
+      },
+      "claude": {
+        "questionAdapter": "AskUserQuestion",
+        "availability": "when_no_auto_continue_timeout",
+        "gateSafety": "no_timeout_or_hook_supplied_answer",
+        "explicitOutcomes": [
+          "approve",
+          "revise",
+          "decline"
+        ],
+        "dismissOutcome": "cancel",
+        "approvalValueTransport": "exact_option_value",
+        "waitSafety": "deliberate_no_auto_resolution",
+        "authorizationPath": "exact_text",
+        "technicalPermissionOwner": "claude_host"
+      },
+      "copilot": {
+        "questionAdapter": "exact_text",
+        "availability": "always",
+        "gateSafety": "wait_for_deliberate_user_input",
+        "explicitOutcomes": [
+          "approve",
+          "revise",
+          "decline",
+          "cancel"
+        ],
+        "approvalValueTransport": "exact_option_value",
+        "waitSafety": "deliberate_no_auto_resolution",
+        "authorizationPath": "exact_text",
+        "technicalPermissionOwner": "copilot_host"
+      },
+      "opencode": {
+        "questionAdapter": "question",
+        "availability": "when_permission_question_allows",
+        "gateSafety": "preserve_explicit_deny",
+        "explicitOutcomes": [
+          "approve",
+          "revise",
+          "decline"
+        ],
+        "dismissOutcome": "cancel",
+        "approvalValueTransport": "exact_option_value",
+        "waitSafety": "deliberate_no_auto_resolution",
+        "authorizationPath": "exact_text",
+        "technicalPermissionOwner": "opencode_host"
+      },
+      "fallback": {
+        "questionAdapter": "exact_text",
+        "availability": "always",
+        "gateSafety": "wait_for_deliberate_user_input",
+        "explicitOutcomes": [
+          "approve",
+          "revise",
+          "decline",
+          "cancel"
+        ],
+        "approvalValueTransport": "exact_option_value",
+        "waitSafety": "deliberate_no_auto_resolution",
+        "authorizationPath": "exact_text",
+        "technicalPermissionOwner": "host_specific"
+      }
+    }
+  },
+  "publicDistribution": {
+    "schemaVersion": 1,
+    "submissionType": "skills",
+    "technicalId": "agdf",
+    "publicDisplayName": "AGDF",
+    "fullDisplayName": "AI Governance & Delivery Framework (AGDF)",
+    "shortDescription": "Governed AI delivery controls",
+    "developerName": "Arndt Gold",
+    "publisher": {
+      "target": "Arndt Gold",
+      "verificationState": "unverified"
+    },
+    "category": "Productivity",
+    "urls": {
+      "website": "https://agdf.iself.eu",
+      "privacy": "https://agdf.iself.eu/privacy",
+      "terms": "https://agdf.iself.eu/terms",
+      "support": "https://agdf.iself.eu/support"
+    },
+    "defaultPrompt": [
+      "Assess whether AGDF fits this work and recommend the lightest safe delivery path.",
+      "Start this request under AGDF governance.",
+      "Review the active AGDF run and explain the next allowed step."
+    ],
+    "availability": {
+      "decisionState": "pending",
+      "countries": [],
+      "regions": [],
+      "workspaceContexts": [],
+      "decisionOwner": "verified publisher"
+    },
+    "submissionSources": {
+      "capabilityMatrix": "submission/openai/capability-matrix.json",
+      "reviewerCases": "submission/openai/reviewer-cases.json",
+      "releaseNotes": "submission/openai/release-notes.md",
+      "availabilityDecision": "submission/openai/availability.md"
+    }
+  },
+  "skillSet": [
+    {
+      "slug": "delivery-path-search",
+      "discovery": "optional",
+      "useFor": "high-impact planning decisions with several plausible next delivery steps before implementation",
+      "boundary": "read-only advisory search; never grants gate permission or replaces gate-check"
+    },
+    {
+      "slug": "brownfield-analysis",
+      "discovery": "automatic",
+      "useFor": "after gate-check permits Brownfield Review or implementation preparation, before non-trivial changes in existing systems",
+      "boundary": "clarifies reuse, owners, risks and Mode/Slice Decision; never bypasses gate-check; Brownfield Review is not implementation permission"
+    },
+    {
+      "slug": "ux-intent-definition",
+      "discovery": "automatic",
+      "useFor": "after approved UR and post-UR routing for medium/high UI/UX impact or ambiguous low-impact product semantics before PRD readiness",
+      "boundary": "non-authorizing analytical PRD input; never creates product intent, gate permission, technical design or a parallel product source of truth"
+    },
+    {
+      "slug": "clean-implementation-review",
+      "discovery": "automatic",
+      "useFor": "evidence dimension: inspect whether the solution is structurally clean",
+      "boundary": "supports Quality Readiness; not a TP or QA substitute"
+    },
+    {
+      "slug": "code-review",
+      "discovery": "automatic",
+      "useFor": "evidence dimension: review the actual diff for defects, regression and security findings",
+      "boundary": "supports Quality Readiness; does not replace QA"
+    },
+    {
+      "slug": "delivery-closeout",
+      "discovery": "automatic",
+      "useFor": "commit/PR-near handoff after QA/OR/UAT",
+      "boundary": "never performs VCS actions automatically"
+    },
+    {
+      "slug": "gate-check",
+      "discovery": "start_here",
+      "useFor": "new build/change intent, unclear approval, Structured Delivery, later-gate artefact requested",
+      "boundary": "does not create later artefacts or skip Mode/Slice Decision after Brownfield Review"
+    },
+    {
+      "slug": "qa-gate",
+      "discovery": "automatic",
+      "useFor": "sole final Quality Readiness decision",
+      "boundary": "only instance for `pass | revise | block`"
+    },
+    {
+      "slug": "release-or",
+      "discovery": "automatic",
+      "useFor": "auditable closeout for every relevant run",
+      "boundary": "not a QA substitute"
+    },
+    {
+      "slug": "task-plan-review",
+      "discovery": "automatic",
+      "useFor": "evidence dimension: verify whether the approved Task Plan was fulfilled",
+      "boundary": "supports Quality Readiness; no final QA decision"
+    }
+  ],
+  "distributionProfiles": {
+    "schemaVersion": 1,
+    "marketplaceIdentities": {
+      "durable": "agdf",
+      "generatedRepository": "agdf-repo"
+    },
+    "profiles": {
+      "source-development": {
+        "runtime": "absent",
+        "installable": false,
+        "machineValidation": "unavailable"
+      },
+      "runtime-plugin": {
+        "runtime": "required",
+        "installable": true,
+        "machineValidation": "local_exact_version_digest"
+      },
+      "copilot-runtime-plugin": {
+        "runtime": "required",
+        "installable": true,
+        "machineValidation": "local_exact_version_digest_inventory"
+      },
+      "opencode-config-local": {
+        "runtime": "config_local_package",
+        "installable": true,
+        "machineValidation": "local_exact_version"
+      },
+      "portable-skills": {
+        "runtime": "absent",
+        "installable": true,
+        "machineValidation": "unavailable_or_external_required"
+      }
+    }
+  }
+}

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

@@ -0,0 +1,144 @@
+function command(name, usages) {
+  return Object.freeze({
+    name,
+    handler: name,
+    groups: Object.freeze(Object.keys(usages)),
+    usages: Object.freeze(Object.fromEntries(
+      Object.entries(usages).map(([group, suffixes]) => [group, Object.freeze(suffixes)]),
+    )),
+  });
+}
+
+export const commandRegistry = Object.freeze([
+  command("codex", { preferred: [""], scaffold: [""] }),
+  command("codex-repo", { preferred: [""], scaffold: [""] }),
+  command("claude", { preferred: [""], scaffold: [""] }),
+  command("copilot", { preferred: [""] }),
+  command("opencode", { preferred: [""], scaffold: [""] }),
+  command("opencode-status", { preferred: [""], scaffold: [""] }),
+  command("status", { preferred: [" [--surface <surface>] [--run <run_id>] [--json]"] }),
+  command("runtime-checks", { preferred: [" <status|enable|manual> --surface <codex|claude|copilot|opencode> [--json]"] }),
+  command("disable", { preferred: [" --surface <surface> [--scope repository] [--dir <path>]"] }),
+  command("uninstall", { preferred: [" --surface <surface> --scope global [--confirm]"] }),
+  command("opencode-repo", { preferred: [""], scaffold: [""] }),
+  command("init", { preferred: [""], scaffold: [""] }),
+  command("config", { scaffold: [" --language de"] }),
+  command("doctor", { local: [""], scaffold: [""], legacy: [" --json"] }),
+  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", " --surface opencode --json"],
+    scaffold: [" --surface codex", " --surface claude", " --surface opencode"],
+  }),
+  command("run-create", { local: [" --run <run_id>"] }),
+  command("run-migrate", { local: [" [--run <run_id>]"] }),
+  command("run-render-legacy", { local: [" --run <run_id>"] }),
+]);
+
+const commandByName = new Map(commandRegistry.map((entry) => [entry.name, entry]));
+
+export function resolveCommand(name) {
+  return commandByName.get(name) ?? null;
+}
+
+export function supportedCommandNames() {
+  return commandRegistry.map((entry) => entry.name);
+}
+
+export function validateCommandOptions(options) {
+  if (options.allActive && !["doctor", "delivery-map"].includes(options.target)) {
+    throw new Error("--all-active is supported only by doctor and delivery-map");
+  }
+  if (options.target === "run-create" && (!options.runId || options.allActive)) {
+    throw new Error("run-create requires --run and rejects --all-active");
+  }
+  if (options.target === "run-render-legacy" && !options.runId) {
+    throw new Error("run-render-legacy requires --run");
+  }
+  if (["disable", "uninstall"].includes(options.target) && ["", "generic", undefined].includes(options.surface)) {
+    throw new Error(`${options.target} requires an explicit --surface`);
+  }
+  if (options.target === "disable" && options.scope && options.scope !== "repository") {
+    throw new Error("disable supports repository scope only");
+  }
+  if (options.target === "uninstall" && options.scope !== "global") {
+    throw new Error("uninstall requires explicit --scope global");
+  }
+  if (options.confirm && options.target !== "uninstall") throw new Error("--confirm is supported only by uninstall");
+  if (options.runtimeChecksDecision && !["codex", "claude", "copilot", "opencode"].includes(options.target)) {
+    throw new Error("--runtime-checks is supported only by codex, claude, copilot and opencode installation commands");
+  }
+  if (options.target === "runtime-checks" && !["codex", "claude", "copilot", "opencode"].includes(options.surface)) {
+    throw new Error("runtime-checks requires --surface codex, claude, copilot or opencode");
+  }
+  if (options.approvalEnvelope && options.target !== "gate-check") throw new Error("--approval-envelope is supported only by gate-check");
+  if (options.approvalEnvelope && (options.json || options.statusCard || options.allActive)) {
+    throw new Error("--approval-envelope cannot be combined with --json, --status-card or --all-active");
+  }
+  return options;
+}
+
+function usageLines(group, prefix) {
+  return commandRegistry
+    .flatMap((entry) => (entry.usages[group] ?? []).map((suffix) => `  ${prefix}${entry.name}${suffix}`))
+    .join("\n");
+}
+
+export function renderUsage() {
+  return `AGDF CLI
+
+Operating model:
+  Chat/skill is the normal interaction surface.
+  .agdf/control is the durable source of truth.
+  The CLI validates, renders deterministic gate output and supports automation.
+
+Repeated local validation (after global installation):
+${usageLines("local", "agdf ")}
+
+Bootstrap, installation and explicit refresh:
+
+Bootstrap and lifecycle commands:
+${usageLines("preferred", "npx --yes @agdf/cli@latest ")}
+
+Advanced / Compatibility
+
+Scaffold-compatible npm create usage:
+${usageLines("scaffold", "npm create agdf@latest -- ")}
+
+Backward-compatible create-agdf usage:
+${usageLines("legacy", "npx --yes create-agdf@latest ")}
+
+Options:
+  --dir <path>   Write files into a specific directory. With opencode, use this as the OpenCode config directory.
+  --force        Overwrite existing generated files
+  --language <tag>
+                 Set AGDF chat and artefact language. Defaults to detected system locale.
+  --lang <tag>   Alias for --language
+  --json         Print machine-readable command output as JSON
+  --verbose       Print captured host command output and generated-file details
+  --status-card  Print compact gate-check status-card output for interactive use
+  --approval-envelope
+                 Print the deterministic ready-gate cards and exact-text request
+  --run <run_id> Select one canonical run
+  --all-active   Evaluate every active run (doctor and delivery-map only)
+  --surface <codex|claude|copilot|opencode|generic>
+                 Declare the active Delivery Path Search surface
+  --scope <repository|global>
+                 Select the lifecycle mutation scope
+  --confirm      Apply a previously previewed global uninstall plan
+  --runtime-checks <enable|manual|cancel>
+                 Make the installation-time automatic-check decision explicitly; no TTY defaults to manual
+  --fixture <path>
+                 Use deterministic evaluator/candidate fixtures instead of a live evaluator
+  --persist      Persist the redacted Delivery Path Search result under the current scope
+  --model <id>   Optional Codex evaluator model
+  --generate-candidates
+                 Add one bounded AI-native candidate-generation call before evaluation
+  --generator-model <id>
+                 Optional candidate-generator model override
+  --max-generated-candidates <1-5>
+  --generation-timeout-ms <1-30000>
+  --generation-cost-units <1-5>
+  --help         Show this help
+`;
+}

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

@@ -0,0 +1,171 @@
+import { readFileSync } from 'node:fs';
+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';
+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';
+
+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 && 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,
+    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(surface),
+    evaluator: {
+      name: surface,
+      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 ?? [],
+    },
+    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,
+  };
+}
+
+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 = 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;
+  }
+  const enforcement = fixture?.input?.enforcement
+    ?? (preflight
+      ? enforcementForSurface("opencode", preflight.evidence, { preflight })
+      : enforcementForSurface(options.surface));
+  const baseInput = fixture ? initialInput : { ...initialInput, enforcement };
+  const input = generationEnabled && !baseInput.generation ? {
+    ...baseInput,
+    generation: {
+      enabled: true,
+      max_calls: 1,
+      max_proposals: options.maxGeneratedCandidates,
+      max_duration_ms: options.generationTimeoutMs,
+      max_cost_units: options.generationCostUnits,
+    },
+  } : baseInput;
+  const evaluator = fixture
+    ? fixtureEvaluator(fixture.evaluations ?? {})
+    : options.surface === "codex"
+      ? codexEvaluator({ cwd: options.dir, model: options.model })
+      : options.surface === "claude"
+        ? claudeEvaluator({ cwd: options.dir, model: options.model })
+        : options.surface === "opencode"
+          ? (dependencies.openCodeEvaluator ?? openCodeEvaluator)({ cwd: options.dir, model: options.model, preflight })
+          : null;
+  if (!evaluator) {
+    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)
+    : options.generateCandidates && options.surface === "codex"
+      ? codexGenerator({ cwd: options.dir, model: options.generatorModel, timeoutMs: options.generationTimeoutMs })
+      : options.generateCandidates && options.surface === "claude"
+        ? claudeGenerator({ cwd: options.dir, model: options.generatorModel, timeoutMs: options.generationTimeoutMs })
+        : null;
+  if (options.generateCandidates && !generator) {
+    throw new Error(`${options.surface} has no executable candidate generator; Codex and Claude are tool-enforced reference transports.`);
+  }
+  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;
+  }
+  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}`);
+  if (result.failure_code) io.log(`Failure: ${result.failure_code}`);
+  io.log(result.next_action ?? result.next_gate_action);
+}