create-agdf 0.11.3 → 0.12.0

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}` });
     }
   }

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

@@ -1,6 +1,6 @@
 import { validateEnforcement } from "../contracts.js";
 
-export function enforcementForSurface(surface, evidence = []) {
+export function enforcementForSurface(surface, evidence = [], context = {}) {
   const defaults = {
     codex: { level: "tool_enforced", evidence: ["codex exec --sandbox read-only --ephemeral"] },
     claude: { level: "tool_enforced", evidence: ["claude -p --disallowedTools Edit,Write,Bash"] },
@@ -9,6 +9,19 @@ export function enforcementForSurface(surface, evidence = []) {
     generic: { level: "instruction_only", evidence: [] },
   };
   const selected = structuredClone(defaults[surface] ?? defaults.generic);
-  if (evidence.length) selected.evidence = evidence;
+  if (surface === "opencode") {
+    const preflight = context.preflight;
+    if (preflight?.surface === "opencode"
+      && preflight.status === "passed"
+      && typeof preflight.invocation_id === "string"
+      && preflight.invocation_id
+      && Array.isArray(preflight.evidence)
+      && preflight.evidence === evidence) {
+      selected.level = "tool_enforced";
+      selected.evidence = [...evidence];
+    }
+  } else if (evidence.length) {
+    selected.evidence = evidence;
+  }
   return validateEnforcement(selected);
 }

package/generated/plugins/agdf/runtime/create-agdf/lib/interaction-presentation.js

@@ -349,6 +349,91 @@ export function renderOperationalStatusCard(statusCard, {
   });
 }
 
+export function renderTaskTargetOrientation(resolution, {
+  registry,
+  requestedLocale,
+} = {}) {
+  if (!plainObject(resolution)) return null;
+
+  const resolutionState = String(resolution.resolution_state ?? "").trim();
+  const reasonCode = String(resolution.reason_code ?? "").trim();
+  const primaryTarget = String(resolution.primary_target ?? "").trim();
+  const governanceTarget = String(resolution.governance_target ?? "").trim();
+  const workingDirectory = String(resolution.working_directory ?? "").trim();
+  const nextAction = String(resolution.next_action ?? "").trim();
+  if (typeof resolution.target_changed !== "boolean") return null;
+  const targetChanged = resolution.target_changed === true;
+  const evidenceSources = Array.isArray(resolution.evidence_sources)
+    ? resolution.evidence_sources.map((item) => String(item ?? "").trim()).filter(Boolean)
+    : null;
+
+  const resolvedReasons = new Set(["explicit_target", "continued_target"]);
+  const unresolvedReasons = new Set([
+    "multiple_plausible_targets",
+    "target_content_mismatch",
+    "target_unavailable",
+    "no_reliable_target",
+  ]);
+
+  if (!["resolved", "unresolved"].includes(resolutionState)) return null;
+  if (!workingDirectory || evidenceSources === null) return null;
+  if (resolutionState === "resolved") {
+    if (!resolvedReasons.has(reasonCode) || !primaryTarget || nextAction) return null;
+  } else if (!unresolvedReasons.has(reasonCode) || primaryTarget || governanceTarget || !nextAction || targetChanged) {
+    return null;
+  }
+
+  let locale;
+  try {
+    locale = resolvePresentationLocale(registry, requestedLocale);
+  } catch {
+    return null;
+  }
+  if (!locale) return null;
+
+  const pack = localePack(registry, locale);
+  const labels = pack?.taskTargetResolution;
+  if (!plainObject(labels) || !plainObject(labels.reasonCodes)) return null;
+  const reason = labels.reasonCodes[reasonCode];
+  if (!reason) return null;
+
+  const rows = resolutionState === "resolved"
+    ? [
+        [labels.state, labels.resolved],
+        [labels.primaryTarget, primaryTarget],
+        [labels.governanceTarget, governanceTarget || labels.none],
+        [labels.evidenceSources, evidenceSources.join("; ") || labels.none],
+        [labels.workingDirectory, workingDirectory],
+        [labels.reason, reason],
+        ...(targetChanged ? [[labels.targetChanged, labels.yes]] : []),
+      ]
+    : [
+        [labels.state, labels.unresolved],
+        [labels.reason, reason],
+        [labels.evidenceSources, evidenceSources.join("; ") || labels.none],
+        [labels.workingDirectory, workingDirectory],
+        [labels.nextAction, nextAction],
+      ];
+
+  const markdown = [
+    `## ${labels.title}`,
+    "",
+    `| ${labels.field} | ${labels.value} |`,
+    "|---|---|",
+    ...rows.map(([label, value]) => `| ${markdownCell(label)} | ${markdownCell(value)} |`),
+  ].join("\n");
+
+  return Object.freeze({
+    schema_version: "1",
+    semantic_block: "task_target_orientation",
+    presentation_language: locale,
+    resolution_state: resolutionState,
+    reason_code: reasonCode,
+    markdown,
+    authorizes: false,
+  });
+}
+
 export function renderScopeClassificationCard(classification, {
   registry,
   requestedLocale,

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

@@ -1,6 +1,6 @@
 {
   "name": "create-agdf",
-  "version": "0.11.3",
+  "version": "0.12.0",
   "description": "Bootstrap AGDF repository-local plugin files, Copilot/OpenCode instructions, skills, control files and machine-readable checks.",
   "type": "module",
   "files": [
@@ -24,6 +24,7 @@
     "test:delivery-path-search": "node ./scripts/delivery-path-search-test.js",
     "test:delivery-path-search-unit": "node ./scripts/delivery-path-search-unit-test.js",
     "test:delivery-path-search-generator": "node ./scripts/delivery-path-search-generator-test.js",
+    "test:opencode-hardening": "node ./scripts/opencode-hardening-test.js",
     "test:cli-modularization": "node ./scripts/cli-modularization-test.js",
     "test:local-validator": "node ./scripts/local-validator-test.js",
     "test:local-marketplace": "node ./scripts/local-marketplace-test.js",
@@ -38,9 +39,12 @@
     "test:skill-evals": "node ./scripts/skill-evals-test.js",
     "eval:skills": "node ./scripts/run-skill-evals.js",
     "eval:skills:record": "node ./scripts/record-skill-evals.js",
+    "eval:proportionality:record": "node ./scripts/record-proportionality-benchmark.js",
+    "eval:proportionality": "node ./scripts/run-proportionality-benchmark.js",
+    "test:proportionality": "node ./scripts/proportionality-benchmark-test.js",
     "test:release-bootstrap": "node ./scripts/release-bootstrap-smoke-test.js",
     "test:routing": "npm run sync-package-assets && node ./scripts/test-routing.js",
-    "smoke-test": "npm run sync-package-assets && npm run test:cli-modularization && npm run test:local-validator && npm run test:local-marketplace && npm run test:package-build && npm run test:package-contents && npm run test:lifecycle && npm run test:control-state && npm run test:interaction-presentation && npm run test:verified-change && npm run test:runtime-integrity-layout && npm run test:runtime-integrity-negative && npm run test:skill-evals && npm run eval:skills && npm run test:delivery-path-search && npm run test:delivery-path-search-unit && npm run test:delivery-path-search-generator && node ./scripts/smoke-test.js && node ./scripts/test-routing.js",
+    "smoke-test": "npm run sync-package-assets && npm run test:cli-modularization && npm run test:local-validator && npm run test:local-marketplace && npm run test:package-build && npm run test:package-contents && npm run test:lifecycle && npm run test:control-state && npm run test:interaction-presentation && npm run test:verified-change && npm run test:runtime-integrity-layout && npm run test:runtime-integrity-negative && npm run test:skill-evals && npm run eval:skills && npm run test:proportionality && npm run test:delivery-path-search && npm run test:delivery-path-search-unit && npm run test:delivery-path-search-generator && npm run test:opencode-hardening && node ./scripts/smoke-test.js && node ./scripts/test-routing.js",
     "prepack": "npm run sync-package-assets"
   },
   "keywords": [

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

@@ -2,7 +2,7 @@
   "schema_version": "1",
   "generated": true,
   "source": "create-agdf/cli",
-  "version": "0.11.3",
+  "version": "0.12.0",
   "entrypoint": "create-agdf/bin/agdf-validator.js",
-  "digest": "217946af2b7c5782e9a620c18a0aa3ce351993b4bda8874bbfbf7d8406cc48ff"
+  "digest": "a869279122dd6a2a7de6a5c719e41eedea5e89b7a2ee32012f7d74ce778ff24e"
 }

package/generated/plugins/agdf/scripts/check-runtime-integrity.mjs

@@ -92,6 +92,7 @@ const agentRouterPath = join(pluginRoot, "meta", "agdf-agent-router.md");
 const runtimeContractPath = join(pluginRoot, "meta", "agdf-runtime-contract.md");
 const contractsDir = join(pluginRoot, "meta", "contracts");
 const contractModules = [
+  "task-target-resolution.md",
   "gate-transition.md",
   "interaction.md",
   "modes.md",
@@ -331,12 +332,66 @@ if (!sourceMode && isFile(localRuntimeEntrypointPath)) {
   }
 }
 const runtimeContract = readAllContracts();
+const modesContract = isFile(join(contractsDir, "modes.md")) ? read(join(contractsDir, "modes.md")) : "";
+const gateTransitionContract = isFile(join(contractsDir, "gate-transition.md")) ? read(join(contractsDir, "gate-transition.md")) : "";
+const agentRouterContent = isFile(agentRouterPath) ? read(agentRouterPath) : "";
 const interactionLocales = isFile(interactionLocalesPath) ? readJson(interactionLocalesPath, "interaction locale registry") : null;
 const gateCheckSkill = isFile(gateCheckSkillPath) ? read(gateCheckSkillPath) : "";
 const brownfieldSkill = isFile(brownfieldSkillPath) ? read(brownfieldSkillPath) : "";
 if (!brownfieldSkill.includes("Persist the completed review and its decision, scope reason, evidence and required next gate in the same internal operation")) {
   failures.push("brownfield-analysis must own atomic post-UR review and routing persistence");
 }
+for (const required of [
+  "### Structured Depth Decision",
+  "depth_unresolved",
+  "depth_facts_status",
+  "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",
+  "coherent_outcome",
+  "authority_boundary",
+  "owner_consumer_coordination",
+  "full_depth_impacts_absent",
+  "migration_propagation_bounded",
+  "failure_recovery_local",
+  "independently_acceptable",
+]) {
+  if (!modesContract.includes(required)) failures.push(`modes contract Structured Depth Decision missing: ${required}`);
+}
+if (!modesContract.includes("counts are not a decision proxy")
+    || !modesContract.includes("threshold for either structured mode")) {
+  failures.push("modes contract must reject numeric structured-depth proxies");
+}
+if (!modesContract.includes("Structured Slice and Structured Delivery use the same existing gate and approval sequence")) {
+  failures.push("modes contract must preserve structured-depth gate parity");
+}
+if (!gateTransitionContract.includes("sole normative `Structured Depth Decision`")
+    || !gateTransitionContract.includes("does not duplicate its")
+    || !gateTransitionContract.includes("trigger or bounded-slice matrix")) {
+  failures.push("gate-transition contract must reference the Modes-owned Structured Depth Decision without duplicating it");
+}
+if (!gateTransitionContract.includes("`depth_unresolved` product result is persisted through this existing value")
+    || !gateTransitionContract.includes("`depth_facts_missing | depth_facts_conflicting`")) {
+  failures.push("gate-transition contract must route unresolved structured depth through the existing block value");
+}
+for (const required of [
+  "../../meta/contracts/modes.md",
+  "depth_policy_version: 1",
+  "depth_facts_status: complete",
+  "rejected_alternative",
+  "missing_or_conflicting_facts",
+  "all seven bounded-slice",
+  "the existing `block` decision",
+  "Brownfield/Mode-Slice re-evaluation",
+]) {
+  if (!brownfieldSkill.includes(required)) failures.push(`brownfield-analysis structured-depth guidance missing: ${required}`);
+}
 const codexPlugin = isFile(codexPluginPath) ? readJson(codexPluginPath, "Codex plugin manifest") : null;
 const claudePlugin = isFile(claudePluginPath) ? readJson(claudePluginPath, "Claude plugin manifest") : null;
 const agdfPackage = isFile(agdfPackagePath) ? readJson(agdfPackagePath, "agdf CLI package manifest") : null;
@@ -354,13 +409,18 @@ if (!runtimeContract.includes("### Interaction Locale Contract") || !runtimeCont
 }
 
 const gateCheckOperationalBoundaries = [
+  "Resolve or revalidate the primary task target before selecting repository control state.",
+  "Derive repository activation only from the resolved governance target",
   "Select exactly one run and evaluate its current gate.",
   "Confirm that the required durable artefact is present and ready.",
   "Consume the canonical `approval_presentation` verbatim",
   "obtain deliberate input through the contract-selected native or exact-text path",
-  "Revalidate the same run, gate and revision immediately after the response and before persistence.",
+  "Revalidate the same target, run, gate and revision immediately after the response and before persistence.",
   "Persist only a currently valid exact approval through the existing control-state workflow.",
 ];
+if (!gateCheckSkill.includes("../../meta/contracts/task-target-resolution.md")) {
+  failures.push("gate-check must load the focused task-target-resolution contract");
+}
 if (!gateCheckSkill.includes("../../meta/contracts/interaction.md")) {
   failures.push("gate-check must load the focused interaction contract");
 }
@@ -403,6 +463,26 @@ if (!runtimeContract.includes("### Repository Activation Diagnosis Boundary")) {
 if (!runtimeContract.includes("### Scope Classification Card")) {
   failures.push("interaction contract must own the scope classification card section");
 }
+if (!runtimeContract.includes("## Purpose And Ordering")
+  || !runtimeContract.includes("## Target Authority Precedence")
+  || !runtimeContract.includes("## Evidence And Mutation Boundary")
+  || !runtimeContract.includes("## Fail-Closed States")) {
+  failures.push("task-target-resolution contract must own target precedence, evidence boundaries and fail-closed states");
+}
+if (!runtimeContract.includes("### Task Target Orientation")) {
+  failures.push("interaction contract must own the task target orientation section");
+}
+if (!agentRouterContent.includes("## Task Target Resolution")
+  || agentRouterContent.indexOf("## Task Target Resolution") > agentRouterContent.indexOf("## Mode Selection")) {
+  failures.push("agent router must resolve the task target before Mode Selection");
+}
+if (!gateCheckSkill.includes("task_target_orientation.markdown` verbatim")) {
+  failures.push("gate-check must consume the canonical task target orientation verbatim");
+}
+if (gateCheckSkill.includes("## Task Target Orientation Template")
+  || gateCheckSkill.includes("| Primary target | Governance target | Evidence sources |")) {
+  failures.push("gate-check must not maintain a skill-local task target orientation template");
+}
 if (!gateCheckSkill.includes("scope_classification.markdown` verbatim")) {
   failures.push("gate-check must consume the canonical scope classification projection verbatim");
 }
@@ -415,12 +495,21 @@ if (sourceMode && isFile(interactionPresentationPath)) {
   if (!interactionPresentation.includes("export function renderScopeClassificationCard")) {
     failures.push("interaction-presentation.js must export renderScopeClassificationCard");
   }
+  if (!interactionPresentation.includes("export function renderTaskTargetOrientation")) {
+    failures.push("interaction-presentation.js must export renderTaskTargetOrientation");
+  }
 }
 for (const locale of ["en", "de"]) {
   const pack = interactionLocales?.locales?.[locale];
   if (!pack?.scopeClassification?.title || !pack?.scopeClassification?.mode?.quick_task || !pack?.scopeClassification?.challenge) {
     failures.push(`Interaction locale ${locale} missing scopeClassification section keys`);
   }
+  if (!pack?.taskTargetResolution?.title
+    || !pack?.taskTargetResolution?.primaryTarget
+    || !pack?.taskTargetResolution?.reasonCodes?.target_content_mismatch
+    || !pack?.taskTargetResolution?.nextAction) {
+    failures.push(`Interaction locale ${locale} missing taskTargetResolution section keys`);
+  }
 }
 if (!runtimeContract.includes("not an agent-facing diagnosis proof")) {
   failures.push("control-scaffold contract must classify AGDF_* env vars as non-agent-facing diagnosis");
@@ -902,9 +991,10 @@ for (const skill of expectedSkills) {
     for (const required of [
       "## Native Interaction Path",
       "complete normative owner for interaction kinds, locale",
+      "Resolve or revalidate the primary task target before selecting repository control state",
       "Select exactly one run and evaluate its current gate",
       "Confirm that the required durable artefact is present and ready",
-      "Revalidate the same run, gate and revision immediately after the response and before persistence",
+      "Revalidate the same target, run, gate and revision immediately after the response and before persistence",
       "Persist only a currently valid exact approval",
     ]) {
       if (!skillMd.includes(required)) failures.push(`gate-check native interaction guidance missing: ${required}`);
@@ -1066,7 +1156,33 @@ if (isFile(sotRegistryTemplatePath)) {
 
 if (isFile(brownfieldReviewTemplatePath)) {
   const brownfieldReviewTemplate = read(brownfieldReviewTemplatePath);
-  for (const required of ["Existing-System View", "Reuse And Parallel-Structure Risk", "Mode / Slice Decision", "transparency_note", "Next Permissible Step", "delivery_context", "ui_ux_impact", "ui_ux_impact_reason", "ux_intent_definition_required", "ux_intent_definition_result"]) {
+  for (const required of [
+    "Existing-System View",
+    "Reuse And Parallel-Structure Risk",
+    "Mode / Slice Decision",
+    "transparency_note",
+    "Next Permissible Step",
+    "delivery_context",
+    "ui_ux_impact",
+    "ui_ux_impact_reason",
+    "ux_intent_definition_required",
+    "ux_intent_definition_result",
+    "Structured Depth Evidence",
+    "depth_policy_version",
+    "depth_facts_status",
+    "primary_reason_code",
+    "decisive_full_depth_triggers",
+    "rejected_alternative",
+    "missing_or_conflicting_facts",
+    "depth_evidence_refs",
+    "coherent_outcome",
+    "authority_boundary",
+    "owner_consumer_coordination",
+    "full_depth_impacts_absent",
+    "migration_propagation_bounded",
+    "failure_recovery_local",
+    "independently_acceptable",
+  ]) {
     if (!brownfieldReviewTemplate.includes(required)) failures.push(`BROWNFIELD_REVIEW.md missing control field: ${required}`);
   }
 }

package/generated/plugins/agdf/skills/brownfield-analysis/SKILL.md

@@ -22,6 +22,7 @@ The skill answers:
 Use these focused runtime-contract modules:
 
 - `../../meta/contracts/gate-transition.md`
+- `../../meta/contracts/modes.md`
 - `../../meta/contracts/context-graph.md`
 - `../../meta/contracts/quality.md`
 
@@ -54,6 +55,19 @@ not applicable; Brownfield records cite repository evidence. Do not create a sec
 11. Large UI surfaces and state hooks must be checked for mixed render, view-model, derived state, orchestration, persistence, and recovery ownership.
 12. Context Graph impact must be curated; it is not a review log or version index.
 13. Specification archive migrations must follow the archive index if present.
+14. In `post_ur_review`, evaluate unchanged compact paths first. For a structured candidate, apply
+    only the `Structured Depth Decision` in `modes.md`; do not recreate its trigger/check matrix in
+    this skill.
+15. A positive structured decision requires `depth_policy_version: 1`,
+    `depth_facts_status: complete`, complete evidence for all seven bounded-slice checks, a primary
+    reason code, rejected alternative and evidence references. A decisive full-depth trigger may
+    support `structured_delivery`; `structured_slice` requires every bounded-slice check to pass.
+16. Missing or conflicting decisive facts without an already-evidenced full-depth trigger persist
+    the existing `block` decision with `depth_facts_missing | depth_facts_conflicting`, named facts,
+    their evidence owner where known, a Brownfield Review link and a precise next action for evidence
+    completion and Brownfield/Mode-Slice re-evaluation.
+17. Owner, file, consumer, task or derived-path counts must never select a structured depth by
+    themselves.
 
 ## When To Use
 - after `gate-check` permits `Brownfield Review` or the selected canonical run record names Brownfield Review as the next allowed action
@@ -107,6 +121,11 @@ When used as Brownfield Review after `Approval: UR`, do not recommend PRD, SD, T
 9. Check UI monolith risk for large surfaces or central hooks.
 10. Check Context Graph impact according to `../../meta/contracts/context-graph.md`.
 11. Recommend the minimal clean implementation path.
+12. In `post_ur_review`, record `depth_policy_version`, `depth_facts_status`,
+    `primary_reason_code`, `decisive_full_depth_triggers`, `rejected_alternative`,
+    `missing_or_conflicting_facts`, `depth_evidence_refs` and evidence for all seven bounded-slice
+    check IDs in the Brownfield Review. Then persist the completed review and the existing
+    Mode/Slice Decision atomically.
 
 ## Output
 Use a concise structure:
@@ -133,6 +152,13 @@ For `post_ur_review`, include the four UI/UX routing fields immediately after `s
 definition is required, its `ready | blocked | not_applicable` result must be visible before PRD
 readiness. A required `blocked` result is at least `revise` for this routing step.
 
+For a structured `post_ur_review` candidate, also include the complete `Structured Depth Evidence`
+section from `BROWNFIELD_REVIEW.md`. The decision projection must show the primary reason, decisive
+dimensions, bounded-slice result, rejected alternative, evidence and required next gate. For
+missing/conflicting facts, show product-language `depth_unresolved` while persisting `block`; name
+the gap and exact recovery action. Structural instruction checks can detect missing contract
+elements but do not prove semantic model compliance or live-host behavior.
+
 ## Pass / Revise / Block Guidance
 - `pass`: existing owners are understood, reuse path is clear, and no blocking drift or parallel structure risk remains.
 - `revise`: relevant evidence, tests, ownership, or reuse path is incomplete.