create-agdf 0.11.4 → 0.12.0

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

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

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

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

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

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

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

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "id": "agdf",
-  "version": "0.11.4",
+  "version": "0.12.0",
   "displayName": "AI Governance & Delivery Framework",
   "developerName": "Arndt Gold",
   "description": "Operating system for governed AI-assisted delivery.",

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

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

package/generated/plugins/agdf/runtime/create-agdf/lib/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.4",
+  "version": "0.12.0",
   "description": "Bootstrap AGDF repository-local plugin files, Copilot/OpenCode instructions, skills, control files and machine-readable checks.",
   "type": "module",
   "files": [
@@ -39,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 && npm run test:opencode-hardening && 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.4",
+  "version": "0.12.0",
   "entrypoint": "create-agdf/bin/agdf-validator.js",
-  "digest": "a3dcdf6d1b66e4789ab10339253e69b967d2d4f2421b52a1d50212e9a8553ec1"
+  "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}`);
   }
 }