jumpstart-mode 1.1.13 → 1.1.14

package/.jumpstart/skills/saga-orchestration/SKILL.md

@@ -0,0 +1,484 @@
+---
+name: saga-orchestration
+description: Implement saga patterns for distributed transactions and cross-aggregate workflows. Use when coordinating multi-step business processes, handling compensating transactions, or managing long-running workflows.
+---
+
+# Saga Orchestration
+
+Patterns for managing distributed transactions and long-running business processes.
+
+## When to Use This Skill
+
+- Coordinating multi-service transactions
+- Implementing compensating transactions
+- Managing long-running business workflows
+- Handling failures in distributed systems
+- Building order fulfillment processes
+- Implementing approval workflows
+
+## Core Concepts
+
+### 1. Saga Types
+
+```
+Choreography                    Orchestration
+┌─────┐  ┌─────┐  ┌─────┐     ┌─────────────┐
+│Svc A│─►│Svc B│─►│Svc C│     │ Orchestrator│
+└─────┘  └─────┘  └─────┘     └──────┬──────┘
+   │        │        │               │
+   ▼        ▼        ▼         ┌─────┼─────┐
+ Event    Event    Event       ▼     ▼     ▼
+                            ┌────┐┌────┐┌────┐
+                            │Svc1││Svc2││Svc3│
+                            └────┘└────┘└────┘
+```
+
+### 2. Saga Execution States
+
+| State            | Description                    |
+| ---------------- | ------------------------------ |
+| **Started**      | Saga initiated                 |
+| **Pending**      | Waiting for step completion    |
+| **Compensating** | Rolling back due to failure    |
+| **Completed**    | All steps succeeded            |
+| **Failed**       | Saga failed after compensation |
+
+## Templates
+
+### Template 1: Saga Orchestrator Base
+
+```python
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+import uuid
+
+class SagaState(Enum):
+    STARTED = "started"
+    PENDING = "pending"
+    COMPENSATING = "compensating"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
+@dataclass
+class SagaStep:
+    name: str
+    action: str
+    compensation: str
+    status: str = "pending"
+    result: Optional[Dict] = None
+    error: Optional[str] = None
+    executed_at: Optional[datetime] = None
+    compensated_at: Optional[datetime] = None
+
+
+@dataclass
+class Saga:
+    saga_id: str
+    saga_type: str
+    state: SagaState
+    data: Dict[str, Any]
+    steps: List[SagaStep]
+    current_step: int = 0
+    created_at: datetime = field(default_factory=datetime.utcnow)
+    updated_at: datetime = field(default_factory=datetime.utcnow)
+
+
+class SagaOrchestrator(ABC):
+    """Base class for saga orchestrators."""
+
+    def __init__(self, saga_store, event_publisher):
+        self.saga_store = saga_store
+        self.event_publisher = event_publisher
+
+    @abstractmethod
+    def define_steps(self, data: Dict) -> List[SagaStep]:
+        """Define the saga steps."""
+        pass
+
+    @property
+    @abstractmethod
+    def saga_type(self) -> str:
+        """Unique saga type identifier."""
+        pass
+
+    async def start(self, data: Dict) -> Saga:
+        """Start a new saga."""
+        saga = Saga(
+            saga_id=str(uuid.uuid4()),
+            saga_type=self.saga_type,
+            state=SagaState.STARTED,
+            data=data,
+            steps=self.define_steps(data)
+        )
+        await self.saga_store.save(saga)
+        await self._execute_next_step(saga)
+        return saga
+
+    async def handle_step_completed(self, saga_id: str, step_name: str, result: Dict):
+        """Handle successful step completion."""
+        saga = await self.saga_store.get(saga_id)
+
+        # Update step
+        for step in saga.steps:
+            if step.name == step_name:
+                step.status = "completed"
+                step.result = result
+                step.executed_at = datetime.utcnow()
+                break
+
+        saga.current_step += 1
+        saga.updated_at = datetime.utcnow()
+
+        # Check if saga is complete
+        if saga.current_step >= len(saga.steps):
+            saga.state = SagaState.COMPLETED
+            await self.saga_store.save(saga)
+            await self._on_saga_completed(saga)
+        else:
+            saga.state = SagaState.PENDING
+            await self.saga_store.save(saga)
+            await self._execute_next_step(saga)
+
+    async def handle_step_failed(self, saga_id: str, step_name: str, error: str):
+        """Handle step failure - start compensation."""
+        saga = await self.saga_store.get(saga_id)
+
+        # Mark step as failed
+        for step in saga.steps:
+            if step.name == step_name:
+                step.status = "failed"
+                step.error = error
+                break
+
+        saga.state = SagaState.COMPENSATING
+        saga.updated_at = datetime.utcnow()
+        await self.saga_store.save(saga)
+
+        # Start compensation from current step backwards
+        await self._compensate(saga)
+
+    async def _execute_next_step(self, saga: Saga):
+        """Execute the next step in the saga."""
+        if saga.current_step >= len(saga.steps):
+            return
+
+        step = saga.steps[saga.current_step]
+        step.status = "executing"
+        await self.saga_store.save(saga)
+
+        # Publish command to execute step
+        await self.event_publisher.publish(
+            step.action,
+            {
+                "saga_id": saga.saga_id,
+                "step_name": step.name,
+                **saga.data
+            }
+        )
+
+    async def _compensate(self, saga: Saga):
+        """Execute compensation for completed steps."""
+        # Compensate in reverse order
+        for i in range(saga.current_step - 1, -1, -1):
+            step = saga.steps[i]
+            if step.status == "completed":
+                step.status = "compensating"
+                await self.saga_store.save(saga)
+
+                await self.event_publisher.publish(
+                    step.compensation,
+                    {
+                        "saga_id": saga.saga_id,
+                        "step_name": step.name,
+                        "original_result": step.result,
+                        **saga.data
+                    }
+                )
+
+    async def handle_compensation_completed(self, saga_id: str, step_name: str):
+        """Handle compensation completion."""
+        saga = await self.saga_store.get(saga_id)
+
+        for step in saga.steps:
+            if step.name == step_name:
+                step.status = "compensated"
+                step.compensated_at = datetime.utcnow()
+                break
+
+        # Check if all compensations complete
+        all_compensated = all(
+            s.status in ("compensated", "pending", "failed")
+            for s in saga.steps
+        )
+
+        if all_compensated:
+            saga.state = SagaState.FAILED
+            await self._on_saga_failed(saga)
+
+        await self.saga_store.save(saga)
+
+    async def _on_saga_completed(self, saga: Saga):
+        """Called when saga completes successfully."""
+        await self.event_publisher.publish(
+            f"{self.saga_type}Completed",
+            {"saga_id": saga.saga_id, **saga.data}
+        )
+
+    async def _on_saga_failed(self, saga: Saga):
+        """Called when saga fails after compensation."""
+        await self.event_publisher.publish(
+            f"{self.saga_type}Failed",
+            {"saga_id": saga.saga_id, "error": "Saga failed", **saga.data}
+        )
+```
+
+### Template 2: Order Fulfillment Saga
+
+```python
+class OrderFulfillmentSaga(SagaOrchestrator):
+    """Orchestrates order fulfillment across services."""
+
+    @property
+    def saga_type(self) -> str:
+        return "OrderFulfillment"
+
+    def define_steps(self, data: Dict) -> List[SagaStep]:
+        return [
+            SagaStep(
+                name="reserve_inventory",
+                action="InventoryService.ReserveItems",
+                compensation="InventoryService.ReleaseReservation"
+            ),
+            SagaStep(
+                name="process_payment",
+                action="PaymentService.ProcessPayment",
+                compensation="PaymentService.RefundPayment"
+            ),
+            SagaStep(
+                name="create_shipment",
+                action="ShippingService.CreateShipment",
+                compensation="ShippingService.CancelShipment"
+            ),
+            SagaStep(
+                name="send_confirmation",
+                action="NotificationService.SendOrderConfirmation",
+                compensation="NotificationService.SendCancellationNotice"
+            )
+        ]
+
+
+# Usage
+async def create_order(order_data: Dict):
+    saga = OrderFulfillmentSaga(saga_store, event_publisher)
+    return await saga.start({
+        "order_id": order_data["order_id"],
+        "customer_id": order_data["customer_id"],
+        "items": order_data["items"],
+        "payment_method": order_data["payment_method"],
+        "shipping_address": order_data["shipping_address"]
+    })
+
+
+# Event handlers in each service
+class InventoryService:
+    async def handle_reserve_items(self, command: Dict):
+        try:
+            # Reserve inventory
+            reservation = await self.reserve(
+                command["items"],
+                command["order_id"]
+            )
+            # Report success
+            await self.event_publisher.publish(
+                "SagaStepCompleted",
+                {
+                    "saga_id": command["saga_id"],
+                    "step_name": "reserve_inventory",
+                    "result": {"reservation_id": reservation.id}
+                }
+            )
+        except InsufficientInventoryError as e:
+            await self.event_publisher.publish(
+                "SagaStepFailed",
+                {
+                    "saga_id": command["saga_id"],
+                    "step_name": "reserve_inventory",
+                    "error": str(e)
+                }
+            )
+
+    async def handle_release_reservation(self, command: Dict):
+        # Compensating action
+        await self.release_reservation(
+            command["original_result"]["reservation_id"]
+        )
+        await self.event_publisher.publish(
+            "SagaCompensationCompleted",
+            {
+                "saga_id": command["saga_id"],
+                "step_name": "reserve_inventory"
+            }
+        )
+```
+
+### Template 3: Choreography-Based Saga
+
+```python
+from dataclasses import dataclass
+from typing import Dict, Any
+import asyncio
+
+@dataclass
+class SagaContext:
+    """Passed through choreographed saga events."""
+    saga_id: str
+    step: int
+    data: Dict[str, Any]
+    completed_steps: list
+
+
+class OrderChoreographySaga:
+    """Choreography-based saga using events."""
+
+    def __init__(self, event_bus):
+        self.event_bus = event_bus
+        self._register_handlers()
+
+    def _register_handlers(self):
+        self.event_bus.subscribe("OrderCreated", self._on_order_created)
+        self.event_bus.subscribe("InventoryReserved", self._on_inventory_reserved)
+        self.event_bus.subscribe("PaymentProcessed", self._on_payment_processed)
+        self.event_bus.subscribe("ShipmentCreated", self._on_shipment_created)
+
+        # Compensation handlers
+        self.event_bus.subscribe("PaymentFailed", self._on_payment_failed)
+        self.event_bus.subscribe("ShipmentFailed", self._on_shipment_failed)
+
+    async def _on_order_created(self, event: Dict):
+        """Step 1: Order created, reserve inventory."""
+        await self.event_bus.publish("ReserveInventory", {
+            "saga_id": event["order_id"],
+            "order_id": event["order_id"],
+            "items": event["items"]
+        })
+
+    async def _on_inventory_reserved(self, event: Dict):
+        """Step 2: Inventory reserved, process payment."""
+        await self.event_bus.publish("ProcessPayment", {
+            "saga_id": event["saga_id"],
+            "order_id": event["order_id"],
+            "amount": event["total_amount"],
+            "reservation_id": event["reservation_id"]
+        })
+
+    async def _on_payment_processed(self, event: Dict):
+        """Step 3: Payment done, create shipment."""
+        await self.event_bus.publish("CreateShipment", {
+            "saga_id": event["saga_id"],
+            "order_id": event["order_id"],
+            "payment_id": event["payment_id"]
+        })
+
+    async def _on_shipment_created(self, event: Dict):
+        """Step 4: Complete - send confirmation."""
+        await self.event_bus.publish("OrderFulfilled", {
+            "saga_id": event["saga_id"],
+            "order_id": event["order_id"],
+            "tracking_number": event["tracking_number"]
+        })
+
+    # Compensation handlers
+    async def _on_payment_failed(self, event: Dict):
+        """Payment failed - release inventory."""
+        await self.event_bus.publish("ReleaseInventory", {
+            "saga_id": event["saga_id"],
+            "reservation_id": event["reservation_id"]
+        })
+        await self.event_bus.publish("OrderFailed", {
+            "order_id": event["order_id"],
+            "reason": "Payment failed"
+        })
+
+    async def _on_shipment_failed(self, event: Dict):
+        """Shipment failed - refund payment and release inventory."""
+        await self.event_bus.publish("RefundPayment", {
+            "saga_id": event["saga_id"],
+            "payment_id": event["payment_id"]
+        })
+        await self.event_bus.publish("ReleaseInventory", {
+            "saga_id": event["saga_id"],
+            "reservation_id": event["reservation_id"]
+        })
+```
+
+### Template 4: Saga with Timeouts
+
+```python
+class TimeoutSagaOrchestrator(SagaOrchestrator):
+    """Saga orchestrator with step timeouts."""
+
+    def __init__(self, saga_store, event_publisher, scheduler):
+        super().__init__(saga_store, event_publisher)
+        self.scheduler = scheduler
+
+    async def _execute_next_step(self, saga: Saga):
+        if saga.current_step >= len(saga.steps):
+            return
+
+        step = saga.steps[saga.current_step]
+        step.status = "executing"
+        step.timeout_at = datetime.utcnow() + timedelta(minutes=5)
+        await self.saga_store.save(saga)
+
+        # Schedule timeout check
+        await self.scheduler.schedule(
+            f"saga_timeout_{saga.saga_id}_{step.name}",
+            self._check_timeout,
+            {"saga_id": saga.saga_id, "step_name": step.name},
+            run_at=step.timeout_at
+        )
+
+        await self.event_publisher.publish(
+            step.action,
+            {"saga_id": saga.saga_id, "step_name": step.name, **saga.data}
+        )
+
+    async def _check_timeout(self, data: Dict):
+        """Check if step has timed out."""
+        saga = await self.saga_store.get(data["saga_id"])
+        step = next(s for s in saga.steps if s.name == data["step_name"])
+
+        if step.status == "executing":
+            # Step timed out - fail it
+            await self.handle_step_failed(
+                data["saga_id"],
+                data["step_name"],
+                "Step timed out"
+            )
+```
+
+## Best Practices
+
+### Do's
+
+- **Make steps idempotent** - Safe to retry
+- **Design compensations carefully** - They must work
+- **Use correlation IDs** - For tracing across services
+- **Implement timeouts** - Don't wait forever
+- **Log everything** - For debugging failures
+
+### Don'ts
+
+- **Don't assume instant completion** - Sagas take time
+- **Don't skip compensation testing** - Most critical part
+- **Don't couple services** - Use async messaging
+- **Don't ignore partial failures** - Handle gracefully
+
+## Resources
+
+- [Saga Pattern](https://microservices.io/patterns/data/saga.html)
+- [Designing Data-Intensive Applications](https://dataintensive.net/)

package/.jumpstart/skills/scope-creep-detector/SKILL.md

@@ -0,0 +1,75 @@
+---
+name: scope-creep-detector
+description: Compare a current scope draft, SOW, or PRD against discovery notes, transcripts, emails, workshop outputs, and prior versions to surface silent scope expansions, implicit commitments, ambiguity, missing exclusions, and inconsistent acceptance criteria for an AI Innovation Pod or Jump Start engagement. Use this whenever the user needs a scope creep check, SOW vs. discovery diff, hidden-commitment audit, ambiguity scan, or a way to keep the Pod from being held to things never actually scoped, even when phrased as "did we promise that," "is this in scope," "what's drifting," or "audit this SOW against the notes."
+argument-hint: Paste the current scope draft (or SOW / PRD section), the discovery notes / transcripts / emails / workshop outputs, and any prior scope versions if available.
+---
+
+# Scope Creep Detector
+
+## Positioning
+
+Use this skill to protect Pod and Jump Start delivery from silent expansion. The output should let the engagement owner see, line by line, where the current scope is wider, narrower, or fuzzier than what discovery actually supports.
+
+Bias toward concrete diffs and ambiguity calls over generic "watch for scope creep" advice.
+
+## When To Use This
+
+- The user has a scope draft, SOW section, PRD, or backlog and a body of discovery artifacts to compare against.
+- The team needs to harden scope before SOW signature, PRD freeze, or Pod kickoff.
+- Phrased as "did we promise that," "is this in scope," "where did this come from," "is the SOW tight," or "audit this against the notes."
+
+## When Not To Use This Alone
+
+- Do not use this for full SOW critique. Pair with `../sow-proposal-reviewer/SKILL.md`.
+- Do not use this for proposal storytelling. Use `../proposal-narrative/SKILL.md`.
+- Do not use this for raw discovery quality scoring. Use `../discovery-depth-scorecard/SKILL.md`.
+
+## Required Inputs
+
+- current scope draft (SOW scope, PRD, backlog, deliverables list, acceptance criteria),
+- discovery artifacts (notes, transcripts, emails, workshop outputs, exec readouts),
+- prior scope versions if available,
+- any verbal commitments the seller or facilitator remembers.
+
+## Detection Categories
+
+1. Silent expansion — scope item not supported by discovery evidence.
+2. Implicit commitment — verbal promise (in transcripts or emails) not reflected in scope.
+3. Ambiguity — scope language that two reasonable readers will interpret differently.
+4. Missing exclusion — common adjacent ask that is not explicitly out-of-scope.
+5. Acceptance drift — acceptance criteria that exceed or contradict the scoped deliverable.
+6. Dependency gap — scope assumes client / third-party action that is not named with owner and date.
+7. Non-functional drift — NFRs implied in discovery but missing from scope, or vice versa.
+8. Pricing / effort mismatch — scope volume inconsistent with the quoted effort or fee.
+9. Phase boundary blur — Jump Start work that smells like Pod delivery, or vice versa.
+10. AI-specific drift — promises about accuracy, autonomy, or coverage that exceed what the use case can support.
+
+See [references/scope-creep-patterns.md](./references/scope-creep-patterns.md) for canonical examples and the language to use in pushback.
+
+## Workflow
+
+1. Inventory the current scope: deliverables, acceptance criteria, assumptions, exclusions, dependencies, NFRs.
+2. Inventory the discovery evidence: confirmed asks, hypotheses, parking-lot items, verbal commitments.
+3. Diff scope vs. evidence in both directions. Flag items in scope without evidence, and items in evidence not addressed in scope.
+4. Walk the ambiguity, missing exclusion, acceptance drift, and dependency checks.
+5. Score each finding: severity (low / med / high), confidence, and recommended action (tighten language, add exclusion, escalate, accept and document).
+6. Produce the audit using [templates/scope-audit-template.md](./templates/scope-audit-template.md).
+
+## Output Mode
+
+Default artifact:
+
+- Executive summary (overall scope tightness, top three risks).
+- Findings table (category, current scope text, evidence, gap, severity, recommended action).
+- Recommended exclusions and assumptions to add.
+- Recommended acceptance criteria adjustments.
+- Verbal commitments to confirm in writing.
+- Open questions for the seller, facilitator, or sponsor.
+
+## Working Rules
+
+1. Cite evidence (or the absence of it) for every finding.
+2. Distinguish "we promised this" from "the client hopes this."
+3. Treat acceptance criteria as scope. They often expand silently.
+4. Do not strip the client's actual asks; surface them honestly so the team can decide to include, exclude, or defer.
+5. Recommend explicit pushback language only when the gap is concrete and supported.

package/.jumpstart/skills/scope-creep-detector/evals/evals.json

@@ -0,0 +1,30 @@
+{
+  "skill_name": "scope-creep-detector",
+  "evals": [
+    {
+      "id": 1,
+      "prompt": "Audit this SOW scope draft against my discovery notes. Scope says: 'Build a Jump Start prototype agent that drafts responses for customer service inquiries, integrates with Salesforce and similar systems, and is production-ready with SSO. Acceptance: agent accurately answers customer questions across all scenarios.' Discovery notes say: 'Customer wants to test agent on top-3 inquiry types — billing, shipping, returns. They mentioned in the room that broker support would be nice but not critical. Salesforce is the only system in scope. They use Okta. They expect to validate the prototype with a small pilot group.'",
+      "expected_output": "A scope audit identifying ambiguous integration language, acceptance drift, AI-overpromise, missing exclusions, phase boundary blur (Jump Start prototype vs. production-ready), and a verbal commitment (broker support) that needs explicit treatment.",
+      "files": [],
+      "assertions": [
+        {"text": "Audit flags 'and similar systems' as ambiguous and recommends enumerating the systems"},
+        {"text": "Acceptance criterion ('accurately answers across all scenarios') is flagged as AI-overpromise and unbounded"},
+        {"text": "Phase boundary blur (Jump Start prototype labeled 'production-ready with SSO') is flagged"},
+        {"text": "Broker support is identified as a verbal commitment requiring explicit in/out/deferred treatment"},
+        {"text": "Output recommends concrete exclusions to add"},
+        {"text": "Findings include severity and recommended action per item"}
+      ]
+    },
+    {
+      "id": 2,
+      "prompt": "The client just sent over their version of the SOW with a new line under deliverables: 'Knowledge transfer to the client team including documentation, training, and 90 days of post-launch hypercare.' Our pricing didn't include hypercare. How do I respond?",
+      "expected_output": "Pricing/effort mismatch finding with recommended response options (re-price, de-scope hypercare, define hypercare boundaries) and pushback language.",
+      "files": [],
+      "assertions": [
+        {"text": "Audit identifies the pricing mismatch explicitly"},
+        {"text": "Output proposes at least two response options (re-price, scope-down, define boundaries)"},
+        {"text": "Recommended pushback language is professional and tied to concrete fact"}
+      ]
+    }
+  ]
+}

package/.jumpstart/skills/scope-creep-detector/references/scope-creep-patterns.md

@@ -0,0 +1,85 @@
+# Scope Creep Patterns
+
+Canonical examples of how scope silently expands on AI Innovation Pod and Jump Start engagements, with diagnostic language and pushback patterns.
+
+## 1. Silent expansion via examples
+
+- Pattern: discovery cited two document types; SOW says "such as policy and claim documents."
+- Risk: open-ended set; team will be asked for more.
+- Fix: enumerate the document types; add "additional types are out of scope unless added by change order."
+
+## 2. Implicit commitment from verbal yes
+
+- Pattern: seller said in a meeting, "yes, we can also handle the broker portal," but SOW does not name it.
+- Risk: client treats it as scoped.
+- Fix: surface the commitment; either include it explicitly with effort, or document that it is deferred.
+
+## 3. Ambiguous "integration"
+
+- Pattern: SOW says "integrate with Salesforce."
+- Risk: client expects bidirectional sync; team scoped one-way read.
+- Fix: name the direction, the objects, the API path, the event triggers, and the volume.
+
+## 4. Acceptance drift
+
+- Pattern: deliverable is "prototype"; acceptance criterion says "production-ready and integrated with SSO."
+- Risk: prototype effort, production expectations.
+- Fix: align acceptance to deliverable; move production criteria to a follow-on Pod scope.
+
+## 5. Missing exclusion
+
+- Pattern: scope covers building the agent; nothing said about training, change management, or run-state operation.
+- Risk: client assumes "soup to nuts."
+- Fix: add explicit exclusions with names users will recognize ("does not include end-user training or hypercare beyond the two-week post-launch window").
+
+## 6. Dependency without owner
+
+- Pattern: "client will provide data extract."
+- Risk: no name, no date, no format; delivery slips and is blamed on Pod.
+- Fix: name the steward, the format, the date, and the consequence if missed.
+
+## 7. NFR drift
+
+- Pattern: discovery captured "needs to be fast"; scope says nothing about latency.
+- Risk: client expects sub-second; design accepts 5s.
+- Fix: pull NFR into scope explicitly with a target and how it will be measured.
+
+## 8. Pricing / effort mismatch
+
+- Pattern: scope adds two new use cases since pricing was set; fee is unchanged.
+- Risk: margin erosion or quality cuts.
+- Fix: re-price or de-scope; do not silently absorb.
+
+## 9. Phase boundary blur
+
+- Pattern: Jump Start scope includes "set up production observability and run-team handoff."
+- Risk: Jump Start posture (learn fast) loaded with Pod posture (run reliably).
+- Fix: keep Jump Start focused on learning; move production posture to follow-on Pod.
+
+## 10. AI-specific overpromise
+
+- Pattern: "the agent will accurately answer policy questions for all customer scenarios."
+- Risk: unbounded quality claim; impossible acceptance.
+- Fix: bound by an eval set, threshold, and scope of scenarios; tie to release criteria, not absolute claim.
+
+## Pushback language patterns
+
+When a finding is severity High and the client is sensitive, use language like:
+
+- "We want to make sure we deliver what you actually need, so we are tightening this language to avoid ambiguity later."
+- "Our discovery surfaced X; we have scoped X. This adjacent ask is on the parking lot for a follow-on phase, where we can do it justice."
+- "We have heard a verbal yes on this item; we want to either include it formally with the right effort or document it as deferred so neither side is surprised."
+- "Acceptance criteria currently exceed what the prototype is built to demonstrate. We propose moving the production criteria into the Pod scope."
+
+## Diagnostic checklist
+
+Run this against any scope draft:
+
+- Every deliverable has a definition and an acceptance criterion. The criterion does not exceed the deliverable.
+- Every assumption has an owner who can validate it.
+- Every dependency names a steward, format, and date.
+- Every NFR is in scope or explicitly out.
+- Every example list is closed ("limited to A, B, C") not open ("such as").
+- Every verbal commitment is either in scope or in a deferral list.
+- Every adjacent ask the client mentioned has an explicit in / out / deferred decision.
+- Effort and fee match the scope volume.