create-agdf 0.11.4 → 0.13.0

package/generated/plugins/agdf/meta/contracts/gate-transition.md

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

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

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

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

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

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

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

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

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

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

@@ -1,13 +1,11 @@
 {
   "schemaVersion": 1,
   "id": "agdf",
-  "version": "0.11.4",
+  "version": "0.13.0",
   "displayName": "AI Governance & Delivery Framework",
   "developerName": "Arndt Gold",
-  "description": "Operating system for governed AI-assisted delivery.",
-  "claudeDescription": "AI Governance & Delivery Framework (AGDF) brings an operating system for governed AI-assisted delivery to Claude Code, combining workflow skills, control templates and machine-readable repository checks for gate decisions, Brownfield analysis, task-plan review, QA decisions, durable run state and auditable closeout.",
-  "shortDescription": "Operating system for governed AI-assisted delivery.",
-  "longDescription": "AI Governance & Delivery Framework (AGDF) brings an operating system for governed AI-assisted delivery, combining workflow skills, control templates and machine-readable repository checks for gate decisions, Brownfield analysis, task-plan review, QA decisions, durable run state and auditable delivery closeout.",
+  "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",
@@ -156,6 +154,44 @@
       }
     }
   },
+  "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",

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,67 +1,6 @@
 {
-  "name": "create-agdf",
-  "version": "0.11.4",
-  "description": "Bootstrap AGDF repository-local plugin files, Copilot/OpenCode instructions, skills, control files and machine-readable checks.",
-  "type": "module",
-  "files": [
-    "bin",
-    "lib",
-    "generated",
-    "opencode-plugin.js",
-    "README.md",
-    "NOTICE"
-  ],
-  "exports": {
-    ".": "./opencode-plugin.js",
-    "./cli": "./bin/create-agdf.js",
-    "./opencode-plugin": "./opencode-plugin.js"
-  },
-  "bin": {
-    "create-agdf": "./bin/create-agdf.js"
-  },
-  "scripts": {
-    "sync-package-assets": "node ./scripts/sync-package-assets.js",
-    "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",
-    "test:package-contents": "node ./scripts/package-contents-test.js",
-    "test:package-build": "node ./scripts/package-build-test.js",
-    "test:lifecycle": "node ./scripts/lifecycle-test.js",
-    "test:control-state": "node ./scripts/control-state-test.js",
-    "test:interaction-presentation": "node ./scripts/interaction-presentation-test.js",
-    "test:verified-change": "node ./scripts/verified-change-test.js",
-    "test:runtime-integrity-layout": "node ./scripts/runtime-integrity-layout-test.js",
-    "test:runtime-integrity-negative": "node ./scripts/runtime-integrity-negative-test.js",
-    "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",
-    "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",
-    "prepack": "npm run sync-package-assets"
-  },
-  "keywords": [
-    "agdf",
-    "copilot",
-    "claude-code",
-    "codex",
-    "opencode",
-    "control",
-    "scaffold",
-    "bootstrap"
-  ],
-  "license": "Apache-2.0",
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/ArndtGold/ai-native-governance-delivery-framework.git",
-    "directory": "create-agdf"
-  },
-  "homepage": "https://github.com/ArndtGold/ai-native-governance-delivery-framework/tree/main/create-agdf"
+  "name": "@agdf/local-validator-runtime",
+  "version": "0.13.0",
+  "private": true,
+  "type": "module"
 }

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.13.0",
   "entrypoint": "create-agdf/bin/agdf-validator.js",
-  "digest": "a3dcdf6d1b66e4789ab10339253e69b967d2d4f2421b52a1d50212e9a8553ec1"
+  "digest": "54f70b2bea2ebe917ba234c860c7924b5e50a807950f3a3c74edaef1ff54c03c"
 }