diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index dac407f..6a6259f 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -17,8 +17,6 @@ jobs:
       - uses: actions/checkout@v4
 
       - uses: pnpm/action-setup@v4
-        with:
-          version: 9
 
       - uses: actions/setup-node@v4
         with:
diff --git a/apps/studio/src/components/studio/studio-app.tsx b/apps/studio/src/components/studio/studio-app.tsx
index 0e8cd12..236b416 100644
--- a/apps/studio/src/components/studio/studio-app.tsx
+++ b/apps/studio/src/components/studio/studio-app.tsx
@@ -194,6 +194,9 @@ function StudioEditorBlock({
 				<div
 					className="flex cursor-pointer items-center gap-2 px-3 py-2"
 					onClick={() => onFocus(focused ? "" : block.uiId)}
+					onKeyDown={(e) => {
+						if (e.key === "Enter" || e.key === " ") onFocus(focused ? "" : block.uiId);
+					}}
 				>
 					<button
 						{...attributes}
@@ -1056,7 +1059,12 @@ export function StudioApp(): React.JSX.Element {
 					{/* Split content */}
 					<div className="flex min-h-0 min-w-0 flex-1">
 						{/* Block editor */}
-						<div className={cn("flex min-h-0 min-w-0 flex-1 flex-col overflow-hidden", sourceOpen && "border-r")}>
+						<div
+							className={cn(
+								"flex min-h-0 min-w-0 flex-1 flex-col overflow-hidden",
+								sourceOpen && "border-r",
+							)}
+						>
 							<div className="flex items-center gap-2 border-b px-4 py-1.5">
 								<DropdownMenu>
 									<DropdownMenuTrigger asChild>
diff --git a/biome.json b/biome.json
index f150301..d23f11a 100644
--- a/biome.json
+++ b/biome.json
@@ -21,6 +21,6 @@
 		}
 	},
 	"files": {
-		"ignore": ["node_modules", "dist", ".turbo", "coverage"]
+		"ignore": ["node_modules", "dist", ".turbo", "coverage", "**/.next/**"]
 	}
 }
diff --git a/models/examples/checkout.product.mdx b/models/examples/checkout.product.mdx
index 087f429..3b4d51b 100644
--- a/models/examples/checkout.product.mdx
+++ b/models/examples/checkout.product.mdx
@@ -5,14 +5,50 @@
 <Feature id="checkout" name="Checkout Flow">
   Comprehensive checkout flow from cart preparation to order confirmation.
 
+
+  <Actor id="guest-shopper" name="Guest Shopper"
+    description="Unauthenticated visitor. No saved payment methods or address book."
+  />
+  <Actor id="member-shopper" name="Member Shopper"
+    description="Authenticated user with a verified account, saved addresses, and payment methods on file."
+  />
+  <Actor id="fraud-system" name="Fraud System"
+    description="Internal automated system that performs risk scoring and velocity checks."
+  />
+
+
+  <Outcome id="checkout-conversion" name="Checkout Conversion Rate"
+    metric="checkout_conversion_rate"
+    baseline="68%"
+    target="75%"
+    timeframe="30d"
+    owner="checkout-pm"
+    description="Percentage of users who reach cart and complete a paid order."
+  />
+  <Outcome id="payment-decline-rate" name="Payment Decline Rate"
+    metric="payment_decline_rate"
+    baseline="7%"
+    target="4%"
+    timeframe="30d"
+    owner="payments-pm"
+    description="Percentage of payment attempts that are declined, including soft declines."
+  />
+
+
   <Section id="cart" name="Shopping Cart">
     Captures line items and shopping constraints.
-    <Definition id="cart-item" name="Cart Item" version="1.0.0"
-      fields='[{"name":"productId","type":"string","required":true},{"name":"quantity","type":"number","required":true},{"name":"unitPrice","type":"number","required":true},{"name":"currency","type":"enum","required":true,"enumValues":["USD","EUR","GBP","KRW"]}]'
-    >
+
+    <Definition id="cart-item" name="Cart Item" version="1.0.0">
       Canonical structure for one line item in checkout.
+      <Field name="productId" type="string" required />
+      <Field name="quantity" type="number" required min={1} max={99} />
+      <Field name="unitPrice" type="number" required />
+      <Field name="currency" type="enum" values="USD,EUR,GBP,KRW" required />
     </Definition>
+
     <Policy id="max-cart-items" name="Maximum Cart Items"
+      trigger="cart.item.add"
+      actor="guest-shopper member-shopper"
       rule="A cart may contain at most 50 distinct line items"
       enforcement="must"
     >
@@ -21,7 +57,10 @@
         On add-item request, count distinct items; reject with error code CART_LIMIT_EXCEEDED when count exceeds 50.
       </Logic>
     </Policy>
+
     <Policy id="positive-quantity" name="Positive Quantity"
+      trigger="cart.item.update"
+      actor="guest-shopper member-shopper"
       rule="Quantity must be at least 1 and at most 99 per line item"
       enforcement="must"
     >
@@ -30,7 +69,10 @@
         Accept quantity only when it is between 1 and 99 inclusive. Return INVALID_QUANTITY if out of range; clamp silently only when triggered by inventory sync.
       </Logic>
     </Policy>
+
     <Policy id="inventory-hold" name="Inventory Hold on Cart Add"
+      trigger="cart.item.add"
+      actor="guest-shopper member-shopper"
       rule="Adding an item to cart must create a soft inventory hold that expires after 15 minutes of inactivity"
       enforcement="should"
     >
@@ -45,16 +87,10 @@
         On TTL expiry, release the hold and mark the cart item as unconfirmed. On next cart view, re-check availability and notify the user if stock is no longer available.
       </Logic>
     </Policy>
-    <Policy id="cart-expiration" name="Cart Expiration"
-      rule="Carts with no user activity for 7 days should be marked expired and items released"
-      enforcement="should"
-    >
-      Prevents stale cart data from accumulating and ensures inventory holds do not persist indefinitely through background processes.
-      <Logic id="cart-expiration-logic" name="Cart Cleanup Logic">
-        A daily batch job scans for carts with lastActivityAt older than 7 days. Expired carts are soft-deleted and a cart_expired event is emitted for analytics. If the user returns, show a "your cart has expired" message with option to restore items if still in stock.
-      </Logic>
-    </Policy>
+
     <Policy id="promo-code-validation" name="Promo Code Validation"
+      trigger="cart.promo.apply"
+      actor="guest-shopper member-shopper"
       rule="Only one promo code may be applied per cart; the code must be valid, unexpired, and satisfy minimum order requirements"
       enforcement="must"
     >
@@ -63,19 +99,46 @@
         On code submission, validate against promo service: check code exists, is within valid date range, and cart subtotal meets minimumOrderValue. Apply discount as either percentage or fixed amount based on promo type. Return INVALID_PROMO_CODE, PROMO_EXPIRED, or MINIMUM_NOT_MET as appropriate.
       </Logic>
       <Logic id="promo-code-recalculate" name="Promo Code Recalculation Logic">
-        When cart contents change after promo application, re-evaluate eligibility. If cart no longer meets minimum, remove promo and notify user. If item removal causes promo to become more favorable (e.g., category-specific discount now applies to higher percentage of cart), recalculate automatically.
+        When cart contents change after promo application, re-evaluate eligibility. If cart no longer meets minimum, remove promo and notify user.
       </Logic>
     </Policy>
+
+    <Constraint id="cart-currency-consistency" name="Cart Currency Consistency"
+      condition="All line items in a cart must share the same currency"
+      actor="guest-shopper member-shopper"
+    >
+      Prevents mixed-currency carts that break tax and payment calculations.
+    </Constraint>
+
+    <Scenario id="sc-cart-at-limit" name="Cart at 50-item capacity"
+      given="A cart containing exactly 50 distinct line items"
+      when="The user attempts to add a 51st distinct item"
+      then="The system rejects the request and returns error code CART_LIMIT_EXCEEDED without modifying the cart"
+      policy="max-cart-items"
+      actor="guest-shopper"
+    />
+    <Scenario id="sc-quantity-out-of-range" name="Quantity exceeds maximum"
+      given="A cart with one item at quantity 99"
+      when="The user attempts to set the quantity to 100"
+      then="The system rejects the update and returns INVALID_QUANTITY"
+      policy="positive-quantity"
+      actor="member-shopper"
+    />
   </Section>
 
+
   <Section id="payment" name="Payment Processing">
     Manages payment method capture and gateway constraints.
-    <Definition id="payment-method" name="Payment Method" version="1.0.0"
-      fields='[{"name":"type","type":"enum","required":true,"enumValues":["credit_card","debit_card","paypal","apple_pay","google_pay"]},{"name":"token","type":"string","required":true},{"name":"last4","type":"string","required":false}]'
-    >
+
+    <Definition id="payment-method" name="Payment Method" version="1.0.0">
       Normalized payment representation for authorization and capture.
+      <Field name="type" type="enum" values="credit_card,debit_card,paypal,apple_pay,google_pay" required />
+      <Field name="token" type="string" required />
+      <Field name="last4" type="string" required={false} pattern="^\d{4}$" />
     </Definition>
+
     <Policy id="pci-compliance" name="PCI Compliance"
+      trigger="payment.token.store"
       rule="Raw card numbers must never be stored; only tokenized references are permitted"
       enforcement="must"
     >
@@ -84,7 +147,10 @@
         Drop PAN fields and persist only provider-issued tokens. Log a security event if raw card data is detected in any request payload.
       </Logic>
     </Policy>
+
     <Policy id="payment-retry" name="Payment Retry Policy"
+      trigger="payment.authorize.fail"
+      actor="guest-shopper member-shopper"
       rule="Failed payment attempts should be retried up to 2 times with progressive gateway fallback before surfacing an error to the user"
       enforcement="should"
     >
@@ -93,138 +159,184 @@
         On soft decline (network timeout, 5xx from gateway), wait 2 seconds and retry on the same gateway. If the second attempt also fails with a soft decline, proceed to fallback.
       </Logic>
       <Logic id="payment-retry-fallback" name="Gateway Fallback Logic">
-        If primary gateway fails twice, route the third attempt through the secondary gateway. If all three attempts fail, present a user-friendly error with the option to try a different payment method. Never retry on hard declines (insufficient funds, stolen card, do-not-honor).
+        If primary gateway fails twice, route the third attempt through the secondary gateway. If all three attempts fail, present a user-friendly error. Never retry on hard declines.
       </Logic>
     </Policy>
+
     <Policy id="payment-idempotency" name="Payment Idempotency"
+      trigger="payment.authorize"
       rule="Each payment attempt must carry a unique idempotency key to prevent duplicate charges"
       enforcement="must"
     >
-      Prevents double-charging caused by network retries, user double-clicks, or frontend re-submissions.
+      Prevents double-charging caused by network retries or frontend re-submissions.
       <Logic id="payment-idempotency-logic" name="Idempotency Key Logic">
-        Generate a UUID-based idempotency key on checkout initiation. Attach the key to every authorization request. The gateway must reject duplicate keys within a 24-hour window. On frontend, disable the pay button immediately after first click and re-enable only on confirmed failure.
+        Generate a UUID-based idempotency key on checkout initiation. Attach the key to every authorization request. The gateway must reject duplicate keys within a 24-hour window.
       </Logic>
     </Policy>
+
     <Policy id="fraud-screening" name="Fraud Screening"
+      trigger="payment.authorize"
+      actor="fraud-system"
       rule="All transactions above $500 or flagged by risk scoring must undergo additional verification before capture"
       enforcement="must"
     >
       Reduces chargeback rate and protects against fraudulent high-value orders.
       <Logic id="fraud-risk-scoring" name="Risk Score Evaluation">
-        Before authorization, pass order details (amount, shipping address, device fingerprint, email age) to fraud scoring service. Orders with risk score above 80 are auto-declined. Scores between 60-80 trigger step-up verification (3DS or email OTP).
+        Before authorization, pass order details to fraud scoring service. Orders with risk score above 80 are auto-declined. Scores between 60-80 trigger step-up verification (3DS or email OTP).
       </Logic>
       <Logic id="fraud-velocity-check" name="Velocity Check Logic">
-        Flag accounts that attempt more than 3 failed payments in 10 minutes or more than 5 orders in 24 hours. Temporarily lock checkout for the account and require customer support intervention or a 30-minute cooldown.
+        Flag accounts that attempt more than 3 failed payments in 10 minutes or more than 5 orders in 24 hours. Temporarily lock checkout for the account.
       </Logic>
     </Policy>
+
     <Constraint id="payment-timeout" name="Payment Timeout"
       condition="Payment gateway response must arrive within 30 seconds"
+      actor="guest-shopper member-shopper"
     >
       Protect user flow from long-running authorization calls.
     </Constraint>
+
     <Constraint id="currency-consistency" name="Currency Consistency"
       condition="The currency used in payment authorization must match the currency displayed to the user at cart time"
     >
       Prevents exchange rate discrepancies between displayed price and charged amount.
     </Constraint>
+
+    <Scenario id="sc-payment-soft-decline" name="Soft decline triggers retry"
+      given="A valid cart and payment method are submitted for authorization"
+      when="The primary payment gateway returns a 503 timeout"
+      then="The system waits 2 seconds and retries on the same gateway before falling back"
+      policy="payment-retry"
+      actor="member-shopper"
+    />
+    <Scenario id="sc-fraud-high-risk" name="High-risk transaction blocked"
+      given="An order totalling $800 from a new account with a high-entropy device fingerprint"
+      when="The fraud scoring service returns a risk score of 85"
+      then="The order is auto-declined with reason FRAUD_RISK_TOO_HIGH and no charge is made"
+      policy="fraud-screening"
+      actor="fraud-system"
+    />
   </Section>
 
+
   <Section id="shipping" name="Shipping">
     Shipping destination and fulfillment option data.
-    <Definition id="shipping-address" name="Shipping Address" version="1.0.0"
-      fields='[{"name":"street","type":"string","required":true},{"name":"city","type":"string","required":true},{"name":"state","type":"string","required":false},{"name":"postalCode","type":"string","required":true},{"name":"country","type":"string","required":true}]'
-    >
+
+    <Definition id="shipping-address" name="Shipping Address" version="1.0.0">
       Address schema for delivery and tax calculation.
+      <Field name="street" type="string" required />
+      <Field name="city" type="string" required />
+      <Field name="state" type="string" required={false} />
+      <Field name="postalCode" type="string" required />
+      <Field name="country" type="string" required />
     </Definition>
-    <Definition id="shipping-option" name="Shipping Option" version="1.0.0"
-      fields='[{"name":"carrier","type":"string","required":true},{"name":"speed","type":"enum","required":true,"enumValues":["standard","express","overnight"]},{"name":"price","type":"number","required":true},{"name":"estimatedDays","type":"number","required":true}]'
-    >
+
+    <Definition id="shipping-option" name="Shipping Option" version="1.0.0">
       Available shipping methods offered at checkout.
+      <Field name="carrier" type="string" required />
+      <Field name="speed" type="enum" values="standard,express,overnight" required />
+      <Field name="price" type="number" required min={0} />
+      <Field name="estimatedDays" type="number" required min={1} />
     </Definition>
+
     <Policy id="address-validation" name="Address Validation"
+      trigger="shipping.address.submit"
+      actor="guest-shopper member-shopper"
       rule="Shipping addresses must be validated against a postal service API before order placement"
       enforcement="must"
     >
       Reduces failed deliveries and return costs from invalid or incomplete addresses.
       <Logic id="address-validation-logic" name="Address Verification Logic">
-        On address submission, call postal validation API. If the address is undeliverable, show an error. If the API suggests corrections (e.g., missing apartment number, ZIP+4 completion), present suggestions to the user and require explicit confirmation. Bypass validation only for military (APO/FPO) and PO Box addresses where API coverage is limited.
+        On address submission, call postal validation API. If undeliverable, show an error. If the API suggests corrections, present suggestions and require explicit user confirmation.
       </Logic>
     </Policy>
+
     <Policy id="restricted-regions" name="Restricted Region Handling"
-      rule="Orders shipping to sanctioned countries or regions with import restrictions must be blocked at checkout with a clear explanation"
+      trigger="shipping.address.submit"
+      actor="guest-shopper member-shopper"
+      rule="Orders shipping to sanctioned countries or regions with import restrictions must be blocked at checkout"
       enforcement="must"
     >
       Ensures trade compliance and prevents orders that cannot be legally fulfilled.
       <Logic id="restricted-regions-logic" name="Region Restriction Logic">
-        Maintain a configurable blocklist of country and region codes. On shipping address entry, check against the blocklist. If restricted, display a message explaining the restriction without disclosing specific compliance details. Log blocked attempts for compliance audit.
-      </Logic>
-    </Policy>
-    <Policy id="shipping-tax-calculation" name="Tax Calculation"
-      rule="Sales tax and VAT must be calculated based on the shipping destination before order confirmation"
-      enforcement="must"
-    >
-      Ensures the total displayed at checkout includes all applicable taxes per jurisdiction.
-      <Logic id="tax-calculation-logic" name="Tax Calculation Logic">
-        On shipping address confirmation, call tax service with line items and destination. Apply tax rates per item category (some categories may be tax-exempt). Display tax as a separate line item in the order summary. Recalculate if shipping address or cart contents change.
+        Maintain a configurable blocklist of country and region codes. On address entry, check against the blocklist. If restricted, display a message without disclosing specific compliance details. Log blocked attempts for compliance audit.
       </Logic>
     </Policy>
+
+    <Scenario id="sc-invalid-address" name="Undeliverable address rejected"
+      given="A guest shopper has entered a non-existent postal code"
+      when="The user clicks 'Continue to Payment'"
+      then="The system calls the postal API, receives UNDELIVERABLE, and displays an address correction prompt"
+      policy="address-validation"
+      actor="guest-shopper"
+    />
   </Section>
 
+
   <Section id="order-confirmation" name="Order Confirmation">
     Final order record and confirmation policies.
-    <Definition id="order" name="Order" version="1.0.0"
-      fields='[{"name":"orderId","type":"string","required":true},{"name":"status","type":"enum","required":true,"enumValues":["pending","confirmed","shipped","delivered","cancelled"]},{"name":"total","type":"number","required":true},{"name":"createdAt","type":"datetime","required":true}]'
-    >
+
+    <Definition id="order" name="Order" version="1.0.0">
       Immutable order snapshot created after successful payment.
+      <Field name="orderId" type="string" required pattern="^ORD-[A-Z0-9]{8}$" />
+      <Field name="status" type="enum" values="pending,confirmed,shipped,delivered,cancelled" required />
+      <Field name="total" type="number" required min={0} />
+      <Field name="createdAt" type="datetime" required />
     </Definition>
+
     <Policy id="confirmation-email" name="Order Confirmation Email"
+      trigger="order.created"
       rule="A confirmation email must be sent within 60 seconds of order placement"
       enforcement="must"
     >
       Ensure users get immediate post-purchase confirmation.
       <Logic id="confirmation-email-logic" name="Confirmation Delivery Logic">
-        Enqueue confirmation event at order creation. Email service must deliver within 60 seconds. If delivery fails, retry up to 3 times with exponential backoff (5s, 15s, 45s). After 3 failures, alert the operations team and queue for manual follow-up.
+        Enqueue confirmation event at order creation. Email service must deliver within 60 seconds. If delivery fails, retry up to 3 times with exponential backoff (5s, 15s, 45s).
       </Logic>
     </Policy>
+
     <Policy id="cancellation-window" name="Order Cancellation Window"
+      trigger="order.cancel.request"
+      actor="member-shopper"
       rule="Users may cancel an order within 30 minutes of placement if the order has not entered fulfillment"
       enforcement="must"
     >
-      Provides a grace period for accidental or impulsive purchases while respecting fulfillment workflow constraints.
+      Provides a grace period for accidental purchases while respecting fulfillment workflow constraints.
       <Logic id="cancellation-eligibility" name="Cancellation Eligibility Logic">
-        On cancel request, check that createdAt is within 30 minutes of current time AND order status is still pending or confirmed (not shipped). If eligible, transition status to cancelled, initiate payment refund, and release inventory holds.
+        On cancel request, check that createdAt is within 30 minutes of current time AND order status is still pending or confirmed. If eligible, transition status to cancelled, initiate refund, and release inventory holds.
       </Logic>
       <Logic id="cancellation-refund" name="Cancellation Refund Logic">
-        Initiate a full refund through the original payment method. If refund fails (e.g., payment provider error), create a store credit for the full amount and notify the user. Refund processing should complete within 5-10 business days depending on payment provider.
-      </Logic>
-    </Policy>
-    <Policy id="order-failure-recovery" name="Order Failure Recovery"
-      rule="If order creation fails after payment succeeds, the system must automatically initiate a refund and notify the user"
-      enforcement="must"
-    >
-      Prevents the worst-case scenario where a user is charged but no order is recorded.
-      <Logic id="order-failure-detection" name="Failure Detection Logic">
-        After successful payment capture, if the order persistence step fails (database error, timeout), immediately log a critical alert with the payment transaction ID.
-      </Logic>
-      <Logic id="order-failure-refund" name="Automatic Refund Logic">
-        Trigger an automatic void (if within capture window) or refund on the payment. Send the user an email explaining the issue and confirming the refund. Include a support reference number for follow-up.
+        Initiate a full refund through the original payment method. If refund fails, create a store credit for the full amount and notify the user.
       </Logic>
     </Policy>
+
+    <Scenario id="sc-cancel-in-window" name="Order cancelled within grace period"
+      given="A confirmed order placed 20 minutes ago with status 'confirmed'"
+      when="The member clicks 'Cancel Order'"
+      then="The order transitions to 'cancelled', a full refund is initiated, and inventory holds are released"
+      policy="cancellation-window"
+      actor="member-shopper"
+    />
+    <Scenario id="sc-cancel-after-window" name="Cancel attempt after 30-minute window"
+      given="A confirmed order placed 45 minutes ago with status 'confirmed'"
+      when="The member attempts to cancel via the order detail page"
+      then="The system rejects the cancellation with CANCEL_WINDOW_EXPIRED and displays a customer support contact"
+      policy="cancellation-window"
+      actor="member-shopper"
+    />
   </Section>
 
+
   <Link id="cart-to-payment" from="cart" to="payment" relationship="depends-on"
-    description="Cart must be finalized before payment"
-  >
-    Checkout moves from cart validation to payment authorization.
-  </Link>
+    description="Cart must be finalized before payment can proceed"
+  />
   <Link id="payment-to-shipping" from="payment" to="shipping" relationship="depends-on"
     description="Payment must succeed before shipping is arranged"
-  >
-    Successful payment unlocks fulfillment choice and pricing.
-  </Link>
+  />
   <Link id="shipping-to-confirmation" from="shipping" to="order-confirmation" relationship="depends-on"
     description="Shipping selection completes the order"
-  >
-    After shipping selection, the order is finalized and confirmed.
-  </Link>
+  />
+  <Link id="fraud-validates-payment" from="fraud-screening" to="payment-idempotency" relationship="validates"
+    description="Fraud screening must pass before any idempotency key is committed to a charge"
+  />
 </Feature>
diff --git a/packages/cli/src/commands/studio.ts b/packages/cli/src/commands/studio.ts
index 6860451..72b9188 100644
--- a/packages/cli/src/commands/studio.ts
+++ b/packages/cli/src/commands/studio.ts
@@ -1,8 +1,8 @@
-import { defineCommand } from "citty";
-import { spawn, exec } from "node:child_process";
-import { createServer } from "node:net";
+import { exec, spawn } from "node:child_process";
 import { createRequire } from "node:module";
+import { createServer } from "node:net";
 import { dirname, join, resolve } from "node:path";
+import { defineCommand } from "citty";
 
 function isPortFree(port: number): Promise<boolean> {
 	return new Promise((resolve) => {
@@ -17,11 +17,7 @@ function isPortFree(port: number): Promise<boolean> {
 
 function openBrowser(url: string): void {
 	const cmd =
-		process.platform === "darwin"
-			? "open"
-			: process.platform === "win32"
-				? "start"
-				: "xdg-open";
+		process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
 	exec(`${cmd} ${url}`);
 }
 
diff --git a/packages/core/src/grammar.ts b/packages/core/src/grammar.ts
index e0e0524..f37e1ee 100644
--- a/packages/core/src/grammar.ts
+++ b/packages/core/src/grammar.ts
@@ -3,19 +3,33 @@ import type { GrammarTable } from "./types/grammar.js";
 /**
  * Canonical grammar table defining allowed parent → children relationships.
  *
- * - Feature: top-level container. Can hold Section, Definition, Policy, Constraint, Link, Logic.
- * - Section: grouping container (recursive). Same children as Feature minus Logic.
+ * - Feature: top-level container. Can hold all block types except nested Feature.
+ *   Outcome is exclusive to Feature (not allowed in Section).
+ * - Section: grouping container (recursive). Same children as Feature minus Logic and Outcome.
  * - Policy: can contain nested Logic blocks for detailed execution rules.
- * - Definition, Constraint, Link, Logic: leaf blocks with no children.
+ * - Actor, Definition, Constraint, Link, Logic, Outcome, Scenario: leaf blocks with no children.
  */
 export const GRAMMAR_TABLE: GrammarTable = {
-	Feature: ["Section", "Definition", "Policy", "Constraint", "Link", "Logic"],
-	Section: ["Section", "Definition", "Policy", "Constraint", "Link"],
+	Feature: [
+		"Section",
+		"Definition",
+		"Policy",
+		"Constraint",
+		"Link",
+		"Logic",
+		"Actor",
+		"Outcome",
+		"Scenario",
+	],
+	Section: ["Section", "Definition", "Policy", "Constraint", "Link", "Actor", "Scenario"],
 	Definition: [],
 	Policy: ["Logic"],
 	Constraint: [],
 	Link: [],
 	Logic: [],
+	Actor: [],
+	Outcome: [],
+	Scenario: [],
 } as const;
 
 /**
diff --git a/packages/core/src/parser/mdx-to-pmast.ts b/packages/core/src/parser/mdx-to-pmast.ts
index 6f24bcb..5a27269 100644
--- a/packages/core/src/parser/mdx-to-pmast.ts
+++ b/packages/core/src/parser/mdx-to-pmast.ts
@@ -2,6 +2,63 @@ import { PMDocumentSchema } from "../schema/blocks.js";
 import type { Block, PMDocument } from "../types/ast.js";
 import type { ExtractedBlock } from "./remark-product-model.js";
 
+/**
+ * Coerce a value that may be a stringified number (from MDX expression attributes)
+ * into a JS number.  Returns undefined if the value is not numeric.
+ */
+function coerceNumber(value: unknown): number | undefined {
+	if (typeof value === "number") return value;
+	if (typeof value === "string") {
+		const n = Number(value);
+		return Number.isNaN(n) ? undefined : n;
+	}
+	return undefined;
+}
+
+/**
+ * Transform native <Field /> attributes into a FieldSpec-compatible object.
+ *
+ * Handles:
+ * - `values="USD,EUR"` → `enumValues: ["USD","EUR"]`  (comma-separated enum values)
+ * - `required` (boolean attribute, present = true)
+ * - `min={1}` / `max={99}` (JSX expression string → number coercion)
+ */
+function transformFieldAttrs(raw: Record<string, unknown>): Record<string, unknown> {
+	const field: Record<string, unknown> = { ...raw };
+
+	// Convert comma-separated `values` attribute → `enumValues` array
+	if (typeof field.values === "string") {
+		field.enumValues = field.values
+			.split(",")
+			.map((v) => v.trim())
+			.filter(Boolean);
+		field.values = undefined;
+	}
+
+	// Coerce numeric constraints
+	const min = coerceNumber(field.min);
+	if (min !== undefined) field.min = min;
+
+	const max = coerceNumber(field.max);
+	if (max !== undefined) field.max = max;
+
+	// `required` is a boolean attribute — already `true` when present without value.
+	// Handle the edge-case where it arrives as the string "false".
+	if (field.required === "false") field.required = false;
+
+	return field;
+}
+
+/**
+ * Parse a space-separated actor string (e.g. "guest member") into an array of IDs.
+ * Returns undefined if the value is absent or empty.
+ */
+function parseActorList(value: unknown): string[] | undefined {
+	if (typeof value !== "string") return undefined;
+	const ids = value.trim().split(/\s+/).filter(Boolean);
+	return ids.length > 0 ? ids : undefined;
+}
+
 /**
  * Transform an extracted block into a typed Block.
  * Handles nested children for Feature and Section blocks.
@@ -16,27 +73,53 @@ function transformBlock(extracted: ExtractedBlock): Record<string, unknown> {
 		block.content = extracted.content;
 	}
 
-	// Parse JSON-encoded fields attribute for Definition blocks
-	if (extracted.type === "Definition" && typeof block.fields === "string") {
-		try {
-			block.fields = JSON.parse(block.fields as string);
-		} catch {
-			// Leave as-is; Zod validation will catch the error
-		}
-	}
+	// ── Definition: resolve fields from native <Field /> children or legacy JSON ──
+	if (extracted.type === "Definition") {
+		const fieldChildren = block.fieldChildren as Record<string, unknown>[] | undefined;
 
-	// Parse JSON-encoded enumValues within fields
-	if (extracted.type === "Definition" && Array.isArray(block.fields)) {
-		block.fields = (block.fields as Record<string, unknown>[]).map((field) => {
-			if (typeof field.enumValues === "string") {
+		if (Array.isArray(fieldChildren) && fieldChildren.length > 0) {
+			// Native <Field /> children take priority
+			block.fields = fieldChildren.map(transformFieldAttrs);
+			block.fieldChildren = undefined;
+		} else {
+			// Legacy JSON-encoded fields attribute (deprecated but still supported)
+			if (typeof block.fields === "string") {
 				try {
-					return { ...field, enumValues: JSON.parse(field.enumValues as string) };
+					block.fields = JSON.parse(block.fields as string);
 				} catch {
-					return field;
+					// Leave as-is; Zod validation will catch the error
 				}
 			}
-			return field;
-		});
+
+			// Parse JSON-encoded enumValues within legacy fields
+			if (Array.isArray(block.fields)) {
+				block.fields = (block.fields as Record<string, unknown>[]).map((field) => {
+					if (typeof field.enumValues === "string") {
+						try {
+							return { ...field, enumValues: JSON.parse(field.enumValues as string) };
+						} catch {
+							return field;
+						}
+					}
+					return field;
+				});
+			}
+		}
+
+		// Always clean up leftover fieldChildren key
+		block.fieldChildren = undefined;
+	}
+
+	// ── Policy / Constraint: parse space-separated actor list → string[] ──
+	// Only transform when actor is a string; leave non-string values intact so
+	// Zod can surface a meaningful validation error rather than silently discarding them.
+	if (extracted.type === "Policy" || extracted.type === "Constraint") {
+		if (typeof block.actor === "string") {
+			const actorList = parseActorList(block.actor);
+			if (actorList !== undefined) {
+				block.actor = actorList;
+			}
+		}
 	}
 
 	if (extracted.children.length > 0) {
diff --git a/packages/core/src/parser/remark-product-model.ts b/packages/core/src/parser/remark-product-model.ts
index 7843598..a237246 100644
--- a/packages/core/src/parser/remark-product-model.ts
+++ b/packages/core/src/parser/remark-product-model.ts
@@ -67,8 +67,25 @@ function normalizeContent(raw: string): string | undefined {
 	return normalized.length > 0 ? normalized : undefined;
 }
 
+/**
+ * Extract attributes from a raw MdxJsxFlowElement into a plain record.
+ */
+function extractRawAttributes(node: MdxJsxFlowElement): Record<string, unknown> {
+	const attrs: Record<string, unknown> = {};
+	for (const attr of node.attributes) {
+		if ("name" in attr && typeof attr.name === "string") {
+			attrs[attr.name] = extractAttributeValue(attr);
+		}
+	}
+	return attrs;
+}
+
 /**
  * Extract block data from an MDX JSX element and its children.
+ *
+ * Special handling for `<Field />` child elements inside `<Definition>`:
+ * they are collected into `attributes.fieldChildren` as raw attribute records,
+ * rather than being treated as child blocks.
  */
 function extractBlock(node: MdxJsxFlowElement): ExtractedBlock | null {
 	const tagName = node.name;
@@ -77,17 +94,25 @@ function extractBlock(node: MdxJsxFlowElement): ExtractedBlock | null {
 	const result = BlockTypeSchema.safeParse(tagName);
 	if (!result.success) return null;
 
-	const attributes: Record<string, unknown> = {};
-	for (const attr of node.attributes) {
-		if ("name" in attr && typeof attr.name === "string") {
-			attributes[attr.name] = extractAttributeValue(attr);
-		}
-	}
+	const attributes: Record<string, unknown> = extractRawAttributes(node);
 
 	const children: ExtractedBlock[] = [];
 	const contentFragments: string[] = [];
+
 	for (const child of node.children) {
 		if (isMdxJsxFlowElement(child)) {
+			// Collect native <Field /> children into fieldChildren, but only for Definition blocks.
+			// Allowing <Field /> under other block types would silently inject `fieldChildren` into
+			// strict schemas (e.g. Feature) causing Zod parse failures.
+			if (tagName === "Definition" && child.name === "Field") {
+				const fieldAttrs = extractRawAttributes(child);
+				if (!Array.isArray(attributes.fieldChildren)) {
+					attributes.fieldChildren = [];
+				}
+				(attributes.fieldChildren as Record<string, unknown>[]).push(fieldAttrs);
+				continue;
+			}
+
 			const extracted = extractBlock(child);
 			if (extracted) {
 				children.push(extracted);
diff --git a/packages/core/src/schema/blocks.ts b/packages/core/src/schema/blocks.ts
index fc8e790..11efb81 100644
--- a/packages/core/src/schema/blocks.ts
+++ b/packages/core/src/schema/blocks.ts
@@ -32,6 +32,16 @@ export const PolicyBlockSchema = z.object({
 	content: BlockContentSchema,
 	rule: z.string().min(1, "Policy must have a rule"),
 	enforcement: z.enum(["must", "should", "may"]).default("must"),
+	/**
+	 * Semantic event name that fires this policy (e.g. "cart.item.add", "payment.capture.success").
+	 * Human-readable and searchable — not evaluated at runtime.
+	 */
+	trigger: z.string().optional(),
+	/**
+	 * Space-separated list of Actor IDs this policy applies to.
+	 * Parsed into an array during MDX transformation (e.g. actor="guest member" → ["guest","member"]).
+	 */
+	actor: z.array(BlockIdSchema).optional(),
 	children: z.array(LogicBlockSchema).optional(),
 });
 
@@ -42,6 +52,11 @@ export const ConstraintBlockSchema = z.object({
 	description: z.string().optional(),
 	content: BlockContentSchema,
 	condition: z.string().min(1, "Constraint must have a condition"),
+	/**
+	 * Space-separated list of Actor IDs this constraint applies to.
+	 * Parsed into an array during MDX transformation.
+	 */
+	actor: z.array(BlockIdSchema).optional(),
 });
 
 export const LinkBlockSchema = z.object({
@@ -49,7 +64,88 @@ export const LinkBlockSchema = z.object({
 	id: BlockIdSchema.optional(),
 	from: BlockIdSchema,
 	to: BlockIdSchema,
-	relationship: z.enum(["depends-on", "extends", "conflicts-with", "implements"]),
+	/**
+	 * Semantic relationship between the two blocks.
+	 * - depends-on    : `from` requires `to` to function
+	 * - extends       : `from` specialises or builds upon `to`
+	 * - conflicts-with: `from` and `to` cannot be active simultaneously
+	 * - implements    : `from` is a concrete realisation of `to`
+	 * - triggers      : `from` causes `to` to activate or fire
+	 * - supersedes    : `from` replaces `to` (e.g. v2 replacing v1)
+	 * - validates     : `from` must pass before `to` can proceed
+	 * - enables       : `from` unlocks or gates `to`
+	 * - blocks        : `from` prevents `to` while it is active
+	 */
+	relationship: z.enum([
+		"depends-on",
+		"extends",
+		"conflicts-with",
+		"implements",
+		"triggers",
+		"supersedes",
+		"validates",
+		"enables",
+		"blocks",
+	]),
+	description: z.string().optional(),
+	content: BlockContentSchema,
+});
+
+/**
+ * Actor block — a first-class user role or persona.
+ * Reference an Actor's `id` in the `actor` attribute of Policy, Constraint, or Scenario
+ * to explicitly scope who a requirement applies to.
+ */
+export const ActorBlockSchema = z.object({
+	type: z.literal("Actor"),
+	id: BlockIdSchema,
+	name: z.string().min(1),
+	description: z.string().optional(),
+	content: BlockContentSchema,
+});
+
+/**
+ * Outcome block — a measurable product success criterion.
+ * Allowed only inside Feature blocks. Anchors a feature to a concrete,
+ * quantitative definition of success.
+ */
+export const OutcomeBlockSchema = z.object({
+	type: z.literal("Outcome"),
+	id: BlockIdSchema,
+	name: z.string().min(1),
+	/** The metric being tracked (e.g. "conversion_rate", "p99_latency_ms") */
+	metric: z.string().min(1),
+	/** Target value to reach (e.g. "75%", "200ms") */
+	target: z.string().min(1),
+	/** Measurement window (e.g. "30d", "Q2-2026") */
+	timeframe: z.string().min(1),
+	/** Current baseline value before the feature ships (e.g. "68%") */
+	baseline: z.string().optional(),
+	/** Team or individual accountable for this outcome */
+	owner: z.string().optional(),
+	description: z.string().optional(),
+	content: BlockContentSchema,
+});
+
+/**
+ * Scenario block — a structured acceptance criterion (Given / When / Then).
+ * Links a human-readable test scenario directly to a Policy and optional Actor.
+ */
+export const ScenarioBlockSchema = z.object({
+	type: z.literal("Scenario"),
+	id: BlockIdSchema,
+	name: z.string().min(1),
+	/** The precondition state (e.g. "A cart with 50 items") */
+	given: z.string().min(1),
+	/** The triggering action (e.g. "The user attempts to add a 51st item") */
+	when: z.string().min(1),
+	/** The expected outcome (e.g. "System returns CART_LIMIT_EXCEEDED") */
+	// biome-ignore lint/suspicious/noThenProperty: `then` is a domain field in Scenario (Given/When/Then BDD pattern)
+	then: z.string().min(1),
+	/** Optional reference to the Policy block this scenario validates */
+	policy: BlockIdSchema.optional(),
+	/** Optional reference to an Actor block that performs the action */
+	actor: BlockIdSchema.optional(),
 	description: z.string().optional(),
 	content: BlockContentSchema,
 });
@@ -62,6 +158,9 @@ const NonContainerBlockSchema = z.union([
 	ConstraintBlockSchema,
 	LinkBlockSchema,
 	LogicBlockSchema,
+	ActorBlockSchema,
+	OutcomeBlockSchema,
+	ScenarioBlockSchema,
 ]);
 
 type NonContainerBlock = z.infer<typeof NonContainerBlockSchema>;
diff --git a/packages/core/src/schema/fields.ts b/packages/core/src/schema/fields.ts
index a5cea04..905a77c 100644
--- a/packages/core/src/schema/fields.ts
+++ b/packages/core/src/schema/fields.ts
@@ -4,6 +4,11 @@ import { FieldTypeSchema } from "./primitives.js";
 /**
  * Schema for a field specification within a Definition block.
  * Defines the name, type, requiredness, and optional constraints of a data field.
+ *
+ * Fields can be authored either as native MDX child elements:
+ *   <Field name="quantity" type="number" required min={1} max={99} />
+ *
+ * or as a legacy JSON-encoded `fields` attribute on the Definition block (deprecated).
  */
 export const FieldSpecSchema = z.object({
 	name: z.string().min(1, "Field name is required"),
@@ -12,12 +17,26 @@ export const FieldSpecSchema = z.object({
 	description: z.string().optional(),
 	enumValues: z.array(z.string()).optional(),
 	default: z.union([z.string(), z.number(), z.boolean()]).optional(),
+	/** Minimum value — valid for `number` fields */
+	min: z.number().optional(),
+	/** Maximum value — valid for `number` fields */
+	max: z.number().optional(),
+	/** Regex pattern constraint — valid for `string` fields */
+	pattern: z.string().optional(),
 });
 
 /**
- * Validate that enum fields have enumValues defined.
+ * Validate that enum fields have enumValues defined,
+ * and that min/max/pattern are only used on appropriate field types.
  */
 export const ValidatedFieldSpecSchema = FieldSpecSchema.refine(
 	(field) => field.type !== "enum" || (field.enumValues && field.enumValues.length > 0),
 	{ message: "Enum fields must have at least one enumValues entry" },
-);
+)
+	.refine(
+		(field) => (field.min === undefined && field.max === undefined) || field.type === "number",
+		{ message: "min/max constraints are only valid for number fields" },
+	)
+	.refine((field) => field.pattern === undefined || field.type === "string", {
+		message: "pattern constraint is only valid for string fields",
+	});
diff --git a/packages/core/src/schema/index.ts b/packages/core/src/schema/index.ts
index f2d651f..7040924 100644
--- a/packages/core/src/schema/index.ts
+++ b/packages/core/src/schema/index.ts
@@ -9,14 +9,17 @@ export {
 export { FieldSpecSchema, ValidatedFieldSpecSchema } from "./fields.js";
 
 export {
+	ActorBlockSchema,
 	BlockSchema,
 	ConstraintBlockSchema,
 	DefinitionBlockSchema,
 	FeatureBlockSchema,
 	LinkBlockSchema,
 	LogicBlockSchema,
+	OutcomeBlockSchema,
 	PMDocumentSchema,
 	PolicyBlockSchema,
+	ScenarioBlockSchema,
 	SectionBlockSchema,
 } from "./blocks.js";
 
diff --git a/packages/core/src/schema/primitives.ts b/packages/core/src/schema/primitives.ts
index 72b9145..6a560af 100644
--- a/packages/core/src/schema/primitives.ts
+++ b/packages/core/src/schema/primitives.ts
@@ -34,6 +34,9 @@ export const BlockTypeSchema = z.enum([
 	"Constraint",
 	"Link",
 	"Logic",
+	"Actor",
+	"Outcome",
+	"Scenario",
 ]);
 
 /**
diff --git a/packages/core/src/types/ast.ts b/packages/core/src/types/ast.ts
index 0e42ad1..d8f8712 100644
--- a/packages/core/src/types/ast.ts
+++ b/packages/core/src/types/ast.ts
@@ -1,13 +1,16 @@
 import type { z } from "zod";
 import type {
+	ActorBlockSchema,
 	BlockSchema,
 	ConstraintBlockSchema,
 	DefinitionBlockSchema,
 	FeatureBlockSchema,
 	LinkBlockSchema,
 	LogicBlockSchema,
+	OutcomeBlockSchema,
 	PMDocumentSchema,
 	PolicyBlockSchema,
+	ScenarioBlockSchema,
 } from "../schema/blocks.js";
 import type { FieldSpecSchema } from "../schema/fields.js";
 import type {
@@ -37,6 +40,9 @@ export type PolicyBlock = z.infer<typeof PolicyBlockSchema>;
 export type ConstraintBlock = z.infer<typeof ConstraintBlockSchema>;
 export type LinkBlock = z.infer<typeof LinkBlockSchema>;
 export type LogicBlock = z.infer<typeof LogicBlockSchema>;
+export type ActorBlock = z.infer<typeof ActorBlockSchema>;
+export type OutcomeBlock = z.infer<typeof OutcomeBlockSchema>;
+export type ScenarioBlock = z.infer<typeof ScenarioBlockSchema>;
 export type { SectionBlock } from "../schema/blocks.js";
 export type FeatureBlock = z.infer<typeof FeatureBlockSchema>;
 
diff --git a/packages/core/src/validator/rules/link-integrity.ts b/packages/core/src/validator/rules/link-integrity.ts
index 98e4754..3290c89 100644
--- a/packages/core/src/validator/rules/link-integrity.ts
+++ b/packages/core/src/validator/rules/link-integrity.ts
@@ -1,16 +1,42 @@
 import type { Block, PMDocument } from "../../types/ast.js";
 import type { ValidationDiagnostic } from "../../types/validation.js";
 
+interface LinkTarget {
+	id?: string;
+	from: string;
+	to: string;
+}
+
+interface ActorReference {
+	blockId?: string;
+	actorIds: string[];
+	context: string;
+}
+
+interface ScenarioReference {
+	blockId?: string;
+	policyId?: string;
+	actorId?: string;
+}
+
 /**
- * Check that all Link block targets (from/to) reference existing block IDs.
+ * Check that all reference targets resolve to existing block IDs:
+ * - Link `from` / `to`
+ * - Policy / Constraint `actor` list
+ * - Scenario `policy` and `actor` references
  */
 export function checkLinkIntegrity(document: PMDocument): ValidationDiagnostic[] {
 	const diagnostics: ValidationDiagnostic[] = [];
 	const allIds = new Set<string>();
-	const links: Array<{ id?: string; from: string; to: string }> = [];
+	const actorIds = new Set<string>();
+	const policyIds = new Set<string>();
+	const links: LinkTarget[] = [];
+	const actorRefs: ActorReference[] = [];
+	const scenarioRefs: ScenarioReference[] = [];
 
-	collectIdsAndLinks(document.blocks, allIds, links);
+	collectRefs(document.blocks, allIds, actorIds, policyIds, links, actorRefs, scenarioRefs);
 
+	// ── Link from/to ──────────────────────────────────────────
 	for (const link of links) {
 		if (!allIds.has(link.from)) {
 			diagnostics.push({
@@ -28,29 +54,86 @@ export function checkLinkIntegrity(document: PMDocument): ValidationDiagnostic[]
 		}
 	}
 
+	// ── Actor references (Policy / Constraint actor lists) ────
+	for (const ref of actorRefs) {
+		for (const actorId of ref.actorIds) {
+			if (!actorIds.has(actorId)) {
+				diagnostics.push({
+					severity: "error",
+					message: `${ref.context} actor "${actorId}" does not reference an existing Actor block ID`,
+					blockId: ref.blockId,
+				});
+			}
+		}
+	}
+
+	// ── Scenario policy / actor references ────────────────────
+	for (const ref of scenarioRefs) {
+		if (ref.policyId && !policyIds.has(ref.policyId)) {
+			diagnostics.push({
+				severity: "error",
+				message: `Scenario "policy" target "${ref.policyId}" does not reference an existing Policy block ID`,
+				blockId: ref.blockId,
+			});
+		}
+		if (ref.actorId && !actorIds.has(ref.actorId)) {
+			diagnostics.push({
+				severity: "error",
+				message: `Scenario "actor" target "${ref.actorId}" does not reference an existing Actor block ID`,
+				blockId: ref.blockId,
+			});
+		}
+	}
+
 	return diagnostics;
 }
 
-function collectIdsAndLinks(
+function collectRefs(
 	blocks: Block[],
 	allIds: Set<string>,
-	links: Array<{ id?: string; from: string; to: string }>,
+	actorIds: Set<string>,
+	policyIds: Set<string>,
+	links: LinkTarget[],
+	actorRefs: ActorReference[],
+	scenarioRefs: ScenarioReference[],
 ): void {
 	for (const block of blocks) {
 		if ("id" in block && typeof block.id === "string") {
 			allIds.add(block.id);
+			if (block.type === "Actor") actorIds.add(block.id);
+			if (block.type === "Policy") policyIds.add(block.id);
 		}
 
 		if (block.type === "Link") {
-			links.push({
-				id: block.id,
-				from: block.from,
-				to: block.to,
+			links.push({ id: block.id, from: block.from, to: block.to });
+		}
+
+		if ((block.type === "Policy" || block.type === "Constraint") && Array.isArray(block.actor)) {
+			actorRefs.push({
+				blockId: block.id,
+				actorIds: block.actor as string[],
+				context: `${block.type} "${block.id}"`,
+			});
+		}
+
+		if (block.type === "Scenario") {
+			scenarioRefs.push({
+				blockId: block.id,
+				policyId: block.policy,
+				actorId: block.actor,
 			});
 		}
 
 		if ("children" in block && Array.isArray(block.children)) {
-			collectIdsAndLinks(block.children as Block[], allIds, links);
+			collectRefs(
+				block.children as Block[],
+				allIds,
+				actorIds,
+				policyIds,
+				links,
+				actorRefs,
+				scenarioRefs,
+			);
 		}
 	}
 }
diff --git a/packages/core/src/validator/rules/workspace-link-integrity.ts b/packages/core/src/validator/rules/workspace-link-integrity.ts
index 633ff7e..ee7e22f 100644
--- a/packages/core/src/validator/rules/workspace-link-integrity.ts
+++ b/packages/core/src/validator/rules/workspace-link-integrity.ts
@@ -8,16 +8,42 @@ interface LinkTarget {
 	to: string;
 }
 
+interface ActorReference {
+	blockId?: string;
+	actorIds: string[];
+	context: string;
+}
+
+interface ScenarioReference {
+	blockId?: string;
+	policyId?: string;
+	actorId?: string;
+}
+
 /**
- * Check that all link targets resolve to existing IDs across the workspace.
+ * Check that all reference targets resolve to existing IDs across the workspace:
+ * - Link `from` / `to`
+ * - Policy / Constraint `actor` lists
+ * - Scenario `policy` and `actor` references
  */
 export function checkWorkspaceLinkIntegrity(workspace: PMWorkspace): ValidationDiagnostic[] {
 	const diagnostics: ValidationDiagnostic[] = [];
 
+	// Build typed ID sets by traversing all modules once up-front
+	const workspaceActorIds = new Set<string>();
+	const workspacePolicyIds = new Set<string>();
+	for (const mod of workspace.modules) {
+		collectTypedIds(mod.document.blocks, workspaceActorIds, workspacePolicyIds);
+	}
+
 	for (const module of workspace.modules) {
 		const links: LinkTarget[] = [];
-		collectLinks(module.document.blocks, links);
+		const actorRefs: ActorReference[] = [];
+		const scenarioRefs: ScenarioReference[] = [];
+
+		collectRefs(module.document.blocks, links, actorRefs, scenarioRefs);
 
+		// ── Link from/to ──────────────────────────────────────────
 		for (const link of links) {
 			if (!(link.from in workspace.idIndex)) {
 				diagnostics.push({
@@ -27,7 +53,6 @@ export function checkWorkspaceLinkIntegrity(workspace: PMWorkspace): ValidationD
 					path: module.filePath,
 				});
 			}
-
 			if (!(link.to in workspace.idIndex)) {
 				diagnostics.push({
 					severity: "error",
@@ -37,23 +62,86 @@ export function checkWorkspaceLinkIntegrity(workspace: PMWorkspace): ValidationD
 				});
 			}
 		}
+
+		// ── Actor references ──────────────────────────────────────
+		for (const ref of actorRefs) {
+			for (const actorId of ref.actorIds) {
+				if (!workspaceActorIds.has(actorId)) {
+					diagnostics.push({
+						severity: "error",
+						message: `${ref.context} actor "${actorId}" does not reference an existing Actor block ID in workspace`,
+						blockId: ref.blockId,
+						path: module.filePath,
+					});
+				}
+			}
+		}
+
+		// ── Scenario policy / actor references ────────────────────
+		for (const ref of scenarioRefs) {
+			if (ref.policyId && !workspacePolicyIds.has(ref.policyId)) {
+				diagnostics.push({
+					severity: "error",
+					message: `Scenario "policy" target "${ref.policyId}" does not reference an existing Policy block ID in workspace`,
+					blockId: ref.blockId,
+					path: module.filePath,
+				});
+			}
+			if (ref.actorId && !workspaceActorIds.has(ref.actorId)) {
+				diagnostics.push({
+					severity: "error",
+					message: `Scenario "actor" target "${ref.actorId}" does not reference an existing Actor block ID in workspace`,
+					blockId: ref.blockId,
+					path: module.filePath,
+				});
+			}
+		}
 	}
 
 	return diagnostics;
 }
 
-function collectLinks(blocks: Block[], links: LinkTarget[]): void {
+function collectTypedIds(blocks: Block[], actorIds: Set<string>, policyIds: Set<string>): void {
+	for (const block of blocks) {
+		if ("id" in block && typeof block.id === "string") {
+			if (block.type === "Actor") actorIds.add(block.id);
+			if (block.type === "Policy") policyIds.add(block.id);
+		}
+		if ("children" in block && Array.isArray(block.children)) {
+			collectTypedIds(block.children as Block[], actorIds, policyIds);
+		}
+	}
+}
+
+function collectRefs(
+	blocks: Block[],
+	links: LinkTarget[],
+	actorRefs: ActorReference[],
+	scenarioRefs: ScenarioReference[],
+): void {
 	for (const block of blocks) {
 		if (block.type === "Link") {
-			links.push({
-				id: block.id,
-				from: block.from,
-				to: block.to,
+			links.push({ id: block.id, from: block.from, to: block.to });
+		}
+
+		if ((block.type === "Policy" || block.type === "Constraint") && Array.isArray(block.actor)) {
+			actorRefs.push({
+				blockId: block.id,
+				actorIds: block.actor as string[],
+				context: `${block.type} "${block.id}"`,
+			});
+		}
+
+		if (block.type === "Scenario") {
+			scenarioRefs.push({
+				blockId: block.id,
+				policyId: block.policy,
+				actorId: block.actor,
 			});
 		}
 
 		if ("children" in block && Array.isArray(block.children)) {
-			collectLinks(block.children as Block[], links);
+			collectRefs(block.children as Block[], links, actorRefs, scenarioRefs);
 		}
 	}
 }
diff --git a/packages/core/tests/fixtures/valid-full.product.mdx b/packages/core/tests/fixtures/valid-full.product.mdx
index 2d22c33..14cae8d 100644
--- a/packages/core/tests/fixtures/valid-full.product.mdx
+++ b/packages/core/tests/fixtures/valid-full.product.mdx
@@ -1,35 +1,62 @@
 <Feature id="checkout" name="Checkout Flow">
   End-to-end purchase flow from cart through payment confirmation.
 
+  <Actor id="guest-user" name="Guest User"
+    description="Unauthenticated visitor browsing or in early checkout"
+  />
+  <Actor id="member-user" name="Authenticated Member"
+    description="User with a verified account and payment method on file"
+  />
+
+  <Outcome id="checkout-cvr" name="Checkout Conversion Rate"
+    metric="conversion_rate"
+    baseline="68%"
+    target="75%"
+    timeframe="30d"
+    owner="checkout-pm"
+  />
+
   <Section id="cart-section" name="Shopping Cart">
     Manages cart state before a user begins payment.
-    <Definition id="cart-item" name="Cart Item" version="1.0.0"
-      fields='[{"name":"productId","type":"string","required":true},{"name":"quantity","type":"number","required":true},{"name":"price","type":"number","required":true}]'
-    >
+    <Definition id="cart-item" name="Cart Item" version="1.0.0">
       Canonical line-item contract for checkout calculations.
+      <Field name="productId" type="string" required />
+      <Field name="quantity" type="number" required min={1} max={99} />
+      <Field name="price" type="number" required />
+      <Field name="currency" type="enum" values="USD,EUR,GBP,KRW" required />
     </Definition>
     <Policy id="max-quantity" name="Max Quantity Policy"
+      trigger="cart.item.add"
+      actor="guest-user member-user"
       rule="A single cart item cannot exceed 99 units"
       enforcement="must"
     >
       Prevent oversized orders that violate fulfillment constraints.
       <Logic id="max-qty-guard" name="Quantity Guard">
-        If requested quantity > 99, reject update and return validation error.
+        If requested quantity exceeds 99, reject the update and return a validation error.
       </Logic>
     </Policy>
     <Constraint id="positive-price" name="Positive Price"
       condition="price must be greater than 0"
+      actor="guest-user member-user"
     >
       Every cart item price must remain positive.
     </Constraint>
+    <Scenario id="sc-cart-limit" name="Cart at capacity"
+      given="A cart containing exactly 99 items"
+      when="The user attempts to set quantity to 100 on a cart item"
+      then="The system rejects the update and returns QUANTITY_EXCEEDED"
+      policy="max-quantity"
+      actor="guest-user"
+    />
   </Section>
 
   <Section id="payment-section" name="Payment">
     Payment capture and tokenized authorization workflows.
-    <Definition id="payment-method" name="Payment Method" version="1.0.0"
-      fields='[{"name":"type","type":"enum","required":true,"enumValues":["credit_card","paypal","apple_pay"]},{"name":"token","type":"string","required":true}]'
-    >
+    <Definition id="payment-method" name="Payment Method" version="1.0.0">
       Supported payment instruments and token payload.
+      <Field name="type" type="enum" values="credit_card,paypal,apple_pay" required />
+      <Field name="token" type="string" required />
     </Definition>
   </Section>
 
diff --git a/packages/core/tests/grammar.test.ts b/packages/core/tests/grammar.test.ts
index 7a3a3ea..eb1d4fe 100644
--- a/packages/core/tests/grammar.test.ts
+++ b/packages/core/tests/grammar.test.ts
@@ -2,9 +2,9 @@ import { describe, expect, it } from "vitest";
 import { GRAMMAR_TABLE, ROOT_BLOCK_TYPES } from "../src/grammar.js";
 
 describe("GRAMMAR_TABLE", () => {
-	it("defines all 7 block types", () => {
+	it("defines all 10 block types", () => {
 		const types = Object.keys(GRAMMAR_TABLE);
-		expect(types).toHaveLength(7);
+		expect(types).toHaveLength(10);
 		expect(types).toContain("Feature");
 		expect(types).toContain("Section");
 		expect(types).toContain("Definition");
@@ -12,6 +12,9 @@ describe("GRAMMAR_TABLE", () => {
 		expect(types).toContain("Constraint");
 		expect(types).toContain("Link");
 		expect(types).toContain("Logic");
+		expect(types).toContain("Actor");
+		expect(types).toContain("Outcome");
+		expect(types).toContain("Scenario");
 	});
 
 	it("Feature can hold all non-Feature block types", () => {
@@ -21,11 +24,20 @@ describe("GRAMMAR_TABLE", () => {
 		expect(GRAMMAR_TABLE.Feature).toContain("Constraint");
 		expect(GRAMMAR_TABLE.Feature).toContain("Link");
 		expect(GRAMMAR_TABLE.Feature).toContain("Logic");
+		expect(GRAMMAR_TABLE.Feature).toContain("Actor");
+		expect(GRAMMAR_TABLE.Feature).toContain("Outcome");
+		expect(GRAMMAR_TABLE.Feature).toContain("Scenario");
 		expect(GRAMMAR_TABLE.Feature).not.toContain("Feature");
 	});
 
-	it("Section excludes Logic children", () => {
+	it("Section excludes Logic and Outcome children", () => {
 		expect(GRAMMAR_TABLE.Section).not.toContain("Logic");
+		expect(GRAMMAR_TABLE.Section).not.toContain("Outcome");
+	});
+
+	it("Section allows Actor and Scenario children", () => {
+		expect(GRAMMAR_TABLE.Section).toContain("Actor");
+		expect(GRAMMAR_TABLE.Section).toContain("Scenario");
 	});
 
 	it("Policy allows only Logic children", () => {
@@ -37,6 +49,9 @@ describe("GRAMMAR_TABLE", () => {
 		expect(GRAMMAR_TABLE.Constraint).toEqual([]);
 		expect(GRAMMAR_TABLE.Link).toEqual([]);
 		expect(GRAMMAR_TABLE.Logic).toEqual([]);
+		expect(GRAMMAR_TABLE.Actor).toEqual([]);
+		expect(GRAMMAR_TABLE.Outcome).toEqual([]);
+		expect(GRAMMAR_TABLE.Scenario).toEqual([]);
 	});
 });
 
diff --git a/packages/core/tests/parser.test.ts b/packages/core/tests/parser.test.ts
index 10e3bbf..abb06fe 100644
--- a/packages/core/tests/parser.test.ts
+++ b/packages/core/tests/parser.test.ts
@@ -1,7 +1,81 @@
 import { describe, expect, it } from "vitest";
 import { parse } from "../src/parser/index.js";
 
-describe("parser", () => {
+describe("parser — Definition fields", () => {
+	it("parses native <Field /> children into fields array", async () => {
+		const source = `
+<Feature id="checkout" name="Checkout Flow">
+  <Definition id="cart-item" name="Cart Item" version="1.0.0">
+    Cart item schema.
+    <Field name="productId" type="string" required />
+    <Field name="quantity" type="number" required min={1} max={99} />
+    <Field name="currency" type="enum" values="USD,EUR,GBP" required />
+  </Definition>
+</Feature>
+`;
+		const doc = await parse(source, { version: "1.0.0", title: "Checkout" });
+		const feature = doc.blocks[0];
+		const definition = feature && "children" in feature ? feature.children?.[0] : undefined;
+		expect(definition?.type).toBe("Definition");
+		if (definition?.type !== "Definition") return;
+
+		expect(definition.fields).toHaveLength(3);
+		expect(definition.fields[0]).toMatchObject({
+			name: "productId",
+			type: "string",
+			required: true,
+		});
+		expect(definition.fields[1]).toMatchObject({
+			name: "quantity",
+			type: "number",
+			min: 1,
+			max: 99,
+		});
+		expect(definition.fields[2]).toMatchObject({
+			name: "currency",
+			type: "enum",
+			enumValues: ["USD", "EUR", "GBP"],
+		});
+	});
+
+	it("parses legacy JSON-encoded fields attribute (backward compatibility)", async () => {
+		const source = `
+<Feature id="checkout" name="Checkout Flow">
+  <Definition id="cart-item" name="Cart Item" version="1.0.0"
+    fields='[{"name":"productId","type":"string","required":true}]'
+  >
+    Cart item schema body text.
+  </Definition>
+</Feature>
+`;
+		const doc = await parse(source, { version: "1.0.0", title: "Checkout" });
+		const feature = doc.blocks[0];
+		const definition = feature && "children" in feature ? feature.children?.[0] : undefined;
+		expect(definition?.type).toBe("Definition");
+		if (definition?.type !== "Definition") return;
+		expect(definition.fields).toHaveLength(1);
+		expect(definition.fields[0]?.name).toBe("productId");
+	});
+
+	it("prefers native <Field /> children over JSON fields attribute when both present", async () => {
+		const source = `
+<Feature id="checkout" name="Checkout Flow">
+  <Definition id="cart-item" name="Cart Item" version="1.0.0"
+    fields='[{"name":"legacy","type":"string","required":true}]'
+  >
+    <Field name="native" type="string" required />
+  </Definition>
+</Feature>
+`;
+		const doc = await parse(source, { version: "1.0.0", title: "Checkout" });
+		const feature = doc.blocks[0];
+		const definition = feature && "children" in feature ? feature.children?.[0] : undefined;
+		if (definition?.type !== "Definition") return;
+		expect(definition.fields[0]?.name).toBe("native");
+	});
+});
+
+describe("parser — block content", () => {
 	it("parses block body text into content", async () => {
 		const source = `
 <Feature id="checkout" name="Checkout Flow">
@@ -13,10 +87,8 @@ describe("parser", () => {
   </Definition>
 </Feature>
 `;
-
-		const document = await parse(source, { version: "1.0.0", title: "Checkout" });
-		const feature = document.blocks[0];
-		expect(feature?.type).toBe("Feature");
+		const doc = await parse(source, { version: "1.0.0", title: "Checkout" });
+		const feature = doc.blocks[0];
 		expect(feature && "content" in feature ? feature.content : undefined).toContain(
 			"Checkout flow summary text.",
 		);
@@ -39,19 +111,122 @@ describe("parser", () => {
   </Policy>
 </Feature>
 `;
-
-		const document = await parse(source, { version: "1.0.0", title: "Checkout" });
+		const doc = await parse(source, { version: "1.0.0", title: "Checkout" });
 		const policy =
-			document.blocks[0] && "children" in document.blocks[0]
-				? document.blocks[0].children?.[0]
-				: undefined;
+			doc.blocks[0] && "children" in doc.blocks[0] ? doc.blocks[0].children?.[0] : undefined;
 		expect(policy?.type).toBe("Policy");
 		expect(policy && "children" in policy ? policy.children?.[0]?.type : undefined).toBe("Logic");
 	});
+});
 
-	it("rejects unsupported status/priority attributes on Feature", async () => {
-		const source = `<Feature id="checkout" name="Checkout Flow" status="approved" priority="p0" />`;
+describe("parser — Actor block", () => {
+	it("parses an Actor block", async () => {
+		const source = `
+<Feature id="checkout" name="Checkout Flow">
+  <Actor id="guest" name="Guest User" description="Unauthenticated visitor" />
+</Feature>
+`;
+		const doc = await parse(source, { version: "1.0.0", title: "Checkout" });
+		const actor =
+			doc.blocks[0] && "children" in doc.blocks[0] ? doc.blocks[0].children?.[0] : undefined;
+		expect(actor?.type).toBe("Actor");
+		if (actor?.type !== "Actor") return;
+		expect(actor.id).toBe("guest");
+		expect(actor.description).toBe("Unauthenticated visitor");
+	});
+});
 
+describe("parser — Outcome block", () => {
+	it("parses an Outcome block", async () => {
+		const source = `
+<Feature id="checkout" name="Checkout Flow">
+  <Outcome id="cvr" name="Checkout Conversion Rate"
+    metric="conversion_rate"
+    target="75%"
+    timeframe="30d"
+    baseline="68%"
+    owner="checkout-pm"
+  />
+</Feature>
+`;
+		const doc = await parse(source, { version: "1.0.0", title: "Checkout" });
+		const outcome =
+			doc.blocks[0] && "children" in doc.blocks[0] ? doc.blocks[0].children?.[0] : undefined;
+		expect(outcome?.type).toBe("Outcome");
+		if (outcome?.type !== "Outcome") return;
+		expect(outcome.metric).toBe("conversion_rate");
+		expect(outcome.target).toBe("75%");
+		expect(outcome.baseline).toBe("68%");
+	});
+});
+
+describe("parser — Scenario block", () => {
+	it("parses a Scenario block with policy and actor references", async () => {
+		const source = `
+<Feature id="checkout" name="Checkout Flow">
+  <Scenario id="sc-1" name="Cart limit scenario"
+    given="A cart with 99 items"
+    when="User adds a 100th item"
+    then="System returns CART_LIMIT_EXCEEDED"
+    policy="max-qty"
+    actor="guest"
+  />
+</Feature>
+`;
+		const doc = await parse(source, { version: "1.0.0", title: "Checkout" });
+		const scenario =
+			doc.blocks[0] && "children" in doc.blocks[0] ? doc.blocks[0].children?.[0] : undefined;
+		expect(scenario?.type).toBe("Scenario");
+		if (scenario?.type !== "Scenario") return;
+		expect(scenario.given).toBe("A cart with 99 items");
+		expect(scenario.policy).toBe("max-qty");
+		expect(scenario.actor).toBe("guest");
+	});
+});
+
+describe("parser — Policy actor and trigger", () => {
+	it("parses Policy trigger and space-separated actor into array", async () => {
+		const source = `
+<Feature id="checkout" name="Checkout Flow">
+  <Policy id="max-qty" name="Max Quantity"
+    trigger="cart.item.add"
+    actor="guest member"
+    rule="Cannot exceed 99"
+    enforcement="must"
+  />
+</Feature>
+`;
+		const doc = await parse(source, { version: "1.0.0", title: "Checkout" });
+		const policy =
+			doc.blocks[0] && "children" in doc.blocks[0] ? doc.blocks[0].children?.[0] : undefined;
+		expect(policy?.type).toBe("Policy");
+		if (policy?.type !== "Policy") return;
+		expect(policy.trigger).toBe("cart.item.add");
+		expect(policy.actor).toEqual(["guest", "member"]);
+	});
+});
+
+describe("parser — Link relationships", () => {
+	it("parses new relationship types", async () => {
+		const source = `
+<Feature id="checkout" name="Checkout Flow">
+  <Section id="fraud" name="Fraud" />
+  <Section id="payment" name="Payment" />
+  <Link from="fraud" to="payment" relationship="validates" />
+</Feature>
+`;
+		const doc = await parse(source, { version: "1.0.0", title: "Checkout" });
+		const link =
+			doc.blocks[0] && "children" in doc.blocks[0] ? doc.blocks[0].children?.[2] : undefined;
+		expect(link?.type).toBe("Link");
+		if (link?.type !== "Link") return;
+		expect(link.relationship).toBe("validates");
+	});
+});
+
+describe("parser — errors", () => {
+	it("rejects unsupported attributes on Feature", async () => {
+		const source = `<Feature id="checkout" name="Checkout Flow" status="approved" priority="p0" />`;
 		await expect(parse(source, { version: "1.0.0", title: "Checkout" })).rejects.toThrow();
 	});
 });
diff --git a/packages/core/tests/schema.test.ts b/packages/core/tests/schema.test.ts
index 2382cd8..f1c237a 100644
--- a/packages/core/tests/schema.test.ts
+++ b/packages/core/tests/schema.test.ts
@@ -1,5 +1,6 @@
 import { describe, expect, it } from "vitest";
 import {
+	ActorBlockSchema,
 	BlockIdSchema,
 	ConstraintBlockSchema,
 	DefinitionBlockSchema,
@@ -7,8 +8,10 @@ import {
 	FieldTypeSchema,
 	LinkBlockSchema,
 	LogicBlockSchema,
+	OutcomeBlockSchema,
 	PMDocumentSchema,
 	PolicyBlockSchema,
+	ScenarioBlockSchema,
 	SemVerSchema,
 } from "../src/schema/index.js";
 
@@ -58,7 +61,7 @@ describe("primitives", () => {
 
 describe("block schemas", () => {
 	describe("DefinitionBlockSchema", () => {
-		it("accepts a valid definition", () => {
+		it("accepts a valid definition with flat fields", () => {
 			const def = DefinitionBlockSchema.parse({
 				type: "Definition",
 				id: "user",
@@ -70,6 +73,29 @@ describe("block schemas", () => {
 			expect(def.fields).toHaveLength(1);
 		});
 
+		it("accepts fields with min/max constraints", () => {
+			const def = DefinitionBlockSchema.parse({
+				type: "Definition",
+				id: "item",
+				name: "Item",
+				version: "1.0.0",
+				fields: [{ name: "quantity", type: "number", required: true, min: 1, max: 99 }],
+			});
+			expect(def.fields[0]?.min).toBe(1);
+			expect(def.fields[0]?.max).toBe(99);
+		});
+
+		it("accepts fields with pattern constraint", () => {
+			const def = DefinitionBlockSchema.parse({
+				type: "Definition",
+				id: "order",
+				name: "Order",
+				version: "1.0.0",
+				fields: [{ name: "orderId", type: "string", required: true, pattern: "^ORD-\\d+$" }],
+			});
+			expect(def.fields[0]?.pattern).toBe("^ORD-\\d+$");
+		});
+
 		it("rejects a definition without fields", () => {
 			expect(() =>
 				DefinitionBlockSchema.parse({
@@ -84,7 +110,7 @@ describe("block schemas", () => {
 	});
 
 	describe("PolicyBlockSchema", () => {
-		it("accepts a valid policy", () => {
+		it("accepts a valid policy with default enforcement", () => {
 			const policy = PolicyBlockSchema.parse({
 				type: "Policy",
 				id: "max-qty",
@@ -101,6 +127,19 @@ describe("block schemas", () => {
 			});
 			expect(policy.enforcement).toBe("must");
 		});
+
+		it("accepts a policy with trigger and actor list", () => {
+			const policy = PolicyBlockSchema.parse({
+				type: "Policy",
+				id: "max-qty",
+				name: "Max Quantity",
+				rule: "Cannot exceed 99",
+				trigger: "cart.item.add",
+				actor: ["guest", "member"],
+			});
+			expect(policy.trigger).toBe("cart.item.add");
+			expect(policy.actor).toEqual(["guest", "member"]);
+		});
 	});
 
 	describe("ConstraintBlockSchema", () => {
@@ -113,17 +152,53 @@ describe("block schemas", () => {
 			});
 			expect(c.condition).toBe("value > 0");
 		});
+
+		it("accepts a constraint with actor list", () => {
+			const c = ConstraintBlockSchema.parse({
+				type: "Constraint",
+				id: "positive",
+				name: "Positive Value",
+				condition: "value > 0",
+				actor: ["guest"],
+			});
+			expect(c.actor).toEqual(["guest"]);
+		});
 	});
 
 	describe("LinkBlockSchema", () => {
-		it("accepts a valid link", () => {
-			const link = LinkBlockSchema.parse({
-				type: "Link",
-				from: "blockA",
-				to: "blockB",
-				relationship: "depends-on",
-			});
-			expect(link.relationship).toBe("depends-on");
+		it("accepts all original relationship types", () => {
+			for (const rel of ["depends-on", "extends", "conflicts-with", "implements"]) {
+				const link = LinkBlockSchema.parse({
+					type: "Link",
+					from: "blockA",
+					to: "blockB",
+					relationship: rel,
+				});
+				expect(link.relationship).toBe(rel);
+			}
+		});
+
+		it("accepts new relationship types", () => {
+			for (const rel of ["triggers", "supersedes", "validates", "enables", "blocks"]) {
+				const link = LinkBlockSchema.parse({
+					type: "Link",
+					from: "blockA",
+					to: "blockB",
+					relationship: rel,
+				});
+				expect(link.relationship).toBe(rel);
+			}
+		});
+
+		it("rejects an unknown relationship type", () => {
+			expect(() =>
+				LinkBlockSchema.parse({
+					type: "Link",
+					from: "blockA",
+					to: "blockB",
+					relationship: "replaces",
+				}),
+			).toThrow();
 		});
 	});
 
@@ -139,8 +214,81 @@ describe("block schemas", () => {
 		});
 	});
 
+	describe("ActorBlockSchema", () => {
+		it("accepts a valid actor", () => {
+			const actor = ActorBlockSchema.parse({
+				type: "Actor",
+				id: "guest-user",
+				name: "Guest User",
+				description: "Unauthenticated visitor",
+			});
+			expect(actor.type).toBe("Actor");
+			expect(actor.id).toBe("guest-user");
+		});
+
+		it("requires id and name", () => {
+			expect(() => ActorBlockSchema.parse({ type: "Actor" })).toThrow();
+		});
+	});
+
+	describe("OutcomeBlockSchema", () => {
+		it("accepts a valid outcome", () => {
+			const outcome = OutcomeBlockSchema.parse({
+				type: "Outcome",
+				id: "checkout-cvr",
+				name: "Checkout Conversion Rate",
+				metric: "conversion_rate",
+				target: "75%",
+				timeframe: "30d",
+				baseline: "68%",
+				owner: "checkout-pm",
+			});
+			expect(outcome.metric).toBe("conversion_rate");
+			expect(outcome.target).toBe("75%");
+		});
+
+		it("requires metric, target, timeframe", () => {
+			expect(() =>
+				OutcomeBlockSchema.parse({
+					type: "Outcome",
+					id: "cvr",
+					name: "CVR",
+				}),
+			).toThrow();
+		});
+	});
+
+	describe("ScenarioBlockSchema", () => {
+		it("accepts a valid scenario", () => {
+			const scenario = ScenarioBlockSchema.parse({
+				type: "Scenario",
+				id: "sc-cart-limit",
+				name: "Cart at capacity",
+				given: "A cart with 99 items",
+				when: "User adds a 100th item",
+				// biome-ignore lint/suspicious/noThenProperty: domain field (BDD Given/When/Then)
+				then: "System returns CART_LIMIT_EXCEEDED",
+				policy: "max-quantity",
+				actor: "guest-user",
+			});
+			expect(scenario.given).toBe("A cart with 99 items");
+			expect(scenario.policy).toBe("max-quantity");
+			expect(scenario.actor).toBe("guest-user");
+		});
+
+		it("requires given, when, then", () => {
+			expect(() =>
+				ScenarioBlockSchema.parse({
+					type: "Scenario",
+					id: "sc-x",
+					name: "X",
+				}),
+			).toThrow();
+		});
+	});
+
 	describe("FeatureBlockSchema", () => {
-		it("accepts a feature with children", () => {
+		it("accepts a feature with Definition children", () => {
 			const feature = FeatureBlockSchema.parse({
 				type: "Feature",
 				id: "checkout",
@@ -158,7 +306,36 @@ describe("block schemas", () => {
 			expect(feature.children).toHaveLength(1);
 		});
 
-		it("rejects unsupported status/priority fields", () => {
+		it("accepts a feature with Actor, Outcome and Scenario children", () => {
+			const feature = FeatureBlockSchema.parse({
+				type: "Feature",
+				id: "checkout",
+				name: "Checkout",
+				children: [
+					{ type: "Actor", id: "guest", name: "Guest User" },
+					{
+						type: "Outcome",
+						id: "cvr",
+						name: "Conversion Rate",
+						metric: "conversion_rate",
+						target: "75%",
+						timeframe: "30d",
+					},
+					{
+						type: "Scenario",
+						id: "sc-1",
+						name: "Scenario 1",
+						given: "State A",
+						when: "Action B",
+						// biome-ignore lint/suspicious/noThenProperty: domain field (BDD Given/When/Then)
+						then: "Result C",
+					},
+				],
+			});
+			expect(feature.children).toHaveLength(3);
+		});
+
+		it("rejects unsupported top-level attributes on Feature", () => {
 			expect(() =>
 				FeatureBlockSchema.parse({
 					type: "Feature",
diff --git a/packages/core/tests/validator.test.ts b/packages/core/tests/validator.test.ts
index c0e258b..0e2f09f 100644
--- a/packages/core/tests/validator.test.ts
+++ b/packages/core/tests/validator.test.ts
@@ -77,6 +77,102 @@ describe("grammar-rules", () => {
 		expect(diagnostics).toHaveLength(1);
 		expect(diagnostics[0]?.message).toContain("not allowed at document root");
 	});
+
+	it("allows Actor, Outcome, Scenario as Feature children", () => {
+		const doc = makeDoc({
+			blocks: [
+				{
+					type: "Feature",
+					id: "f1",
+					name: "Feature 1",
+					children: [
+						{ type: "Actor", id: "guest", name: "Guest" },
+						{
+							type: "Outcome",
+							id: "cvr",
+							name: "CVR",
+							metric: "conversion_rate",
+							target: "75%",
+							timeframe: "30d",
+						},
+						{
+							type: "Scenario",
+							id: "sc-1",
+							name: "Scenario",
+							given: "G",
+							when: "W",
+							// biome-ignore lint/suspicious/noThenProperty: domain field (BDD Given/When/Then)
+							then: "T",
+						},
+					],
+				},
+			],
+		});
+		const diagnostics = checkGrammarRules(doc);
+		expect(diagnostics).toHaveLength(0);
+	});
+
+	it("allows Actor and Scenario as Section children", () => {
+		const doc = makeDoc({
+			blocks: [
+				{
+					type: "Feature",
+					id: "f1",
+					name: "Feature 1",
+					children: [
+						{
+							type: "Section",
+							id: "sec-1",
+							name: "Section 1",
+							children: [
+								{ type: "Actor", id: "guest", name: "Guest" },
+								{
+									type: "Scenario",
+									id: "sc-1",
+									name: "Scenario",
+									given: "G",
+									when: "W",
+									// biome-ignore lint/suspicious/noThenProperty: domain field (BDD Given/When/Then)
+									then: "T",
+								},
+							],
+						},
+					],
+				},
+			],
+		});
+		const diagnostics = checkGrammarRules(doc);
+		expect(diagnostics).toHaveLength(0);
+	});
+
+	it("rejects Outcome as a Section child", () => {
+		const doc = makeDoc({
+			blocks: [
+				{
+					type: "Feature",
+					id: "f1",
+					name: "Feature 1",
+					children: [
+						{
+							type: "Section",
+							id: "sec-1",
+							name: "Section 1",
+							children: [
+								{
+									type: "Outcome" as "Actor",
+									id: "cvr",
+									name: "CVR",
+								} as PMDocument["blocks"][number],
+							],
+						},
+					],
+				},
+			],
+		});
+		const diagnostics = checkGrammarRules(doc);
+		expect(diagnostics).toHaveLength(1);
+		expect(diagnostics[0]?.message).toContain('"Outcome" is not allowed as a child of "Section"');
+	});
 });
 
 describe("id-uniqueness", () => {
@@ -176,4 +272,136 @@ describe("link-integrity", () => {
 		const diagnostics = checkLinkIntegrity(doc);
 		expect(diagnostics).toHaveLength(0);
 	});
+
+	it("validates new relationship types in links", () => {
+		const doc = makeDoc({
+			blocks: [
+				{
+					type: "Feature",
+					id: "f1",
+					name: "F",
+					children: [
+						{ type: "Actor", id: "a1", name: "Actor 1" },
+						{
+							type: "Link",
+							from: "f1",
+							to: "a1",
+							relationship: "enables",
+						},
+					],
+				},
+			],
+		});
+		const diagnostics = checkLinkIntegrity(doc);
+		expect(diagnostics).toHaveLength(0);
+	});
+
+	it("detects broken Policy actor references", () => {
+		const doc = makeDoc({
+			blocks: [
+				{
+					type: "Feature",
+					id: "f1",
+					name: "F",
+					children: [
+						{
+							type: "Policy",
+							id: "p1",
+							name: "Policy",
+							rule: "Some rule",
+							actor: ["nonexistent-actor"],
+						},
+					],
+				},
+			],
+		});
+		const diagnostics = checkLinkIntegrity(doc);
+		expect(diagnostics).toHaveLength(1);
+		expect(diagnostics[0]?.message).toContain("nonexistent-actor");
+	});
+
+	it("passes when Policy actor references a valid Actor block", () => {
+		const doc = makeDoc({
+			blocks: [
+				{
+					type: "Feature",
+					id: "f1",
+					name: "F",
+					children: [
+						{ type: "Actor", id: "guest", name: "Guest" },
+						{
+							type: "Policy",
+							id: "p1",
+							name: "Policy",
+							rule: "Some rule",
+							actor: ["guest"],
+						},
+					],
+				},
+			],
+		});
+		const diagnostics = checkLinkIntegrity(doc);
+		expect(diagnostics).toHaveLength(0);
+	});
+
+	it("detects broken Scenario policy reference", () => {
+		const doc = makeDoc({
+			blocks: [
+				{
+					type: "Feature",
+					id: "f1",
+					name: "F",
+					children: [
+						{
+							type: "Scenario",
+							id: "sc-1",
+							name: "Scenario",
+							given: "G",
+							when: "W",
+							// biome-ignore lint/suspicious/noThenProperty: domain field (BDD Given/When/Then)
+							then: "T",
+							policy: "nonexistent-policy",
+						},
+					],
+				},
+			],
+		});
+		const diagnostics = checkLinkIntegrity(doc);
+		expect(diagnostics).toHaveLength(1);
+		expect(diagnostics[0]?.message).toContain("nonexistent-policy");
+	});
+
+	it("passes when Scenario references valid policy and actor", () => {
+		const doc = makeDoc({
+			blocks: [
+				{
+					type: "Feature",
+					id: "f1",
+					name: "F",
+					children: [
+						{ type: "Actor", id: "guest", name: "Guest" },
+						{
+							type: "Policy",
+							id: "p1",
+							name: "Policy",
+							rule: "Some rule",
+						},
+						{
+							type: "Scenario",
+							id: "sc-1",
+							name: "Scenario",
+							given: "G",
+							when: "W",
+							// biome-ignore lint/suspicious/noThenProperty: domain field (BDD Given/When/Then)
+							then: "T",
+							policy: "p1",
+							actor: "guest",
+						},
+					],
+				},
+			],
+		});
+		const diagnostics = checkLinkIntegrity(doc);
+		expect(diagnostics).toHaveLength(0);
+	});
 });