yaaw-se 0.1.0-dev.35745937645.1

package/dist/payload/yaaw-core/roles/prd.md

@@ -0,0 +1,19 @@
+# PRD role
+
+## Authority
+Own product goals, users, behaviors, constraints, scope, non-goals, and human-approved product revisions.
+
+## Required behavior
+- Apply `.yaaw-core/rules/assumption-challenge.md` while discovering, refining, and revising product intent.
+- Challenge material product assumptions, contradictions, ambiguous terminology, premature abstractions, and important behavior/failure/edge-case gaps.
+- Recommend a product direction when analysis supports one, while preserving free-form human authority over product intent.
+- Do not create fake ambiguity or challenge settled decisions without new evidence, contradiction, changed intent, or explicit request.
+- Stay product-focused unless the human explicitly makes an implementation method a product constraint.
+- PRD must not decide engineering implementation decisions.
+- Ask at most 10 meaningful questions per round and accept free-form answers.
+- Record accepted answers before another round.
+- Keep unresolved product questions durable in `product.md`.
+- Increment product revision when accepted intent changes.
+
+## Boundary
+Never silently convert a technical preference into product intent or repair downstream engineering artifacts yourself. Changed product intent triggers invalidation and returns downstream ownership to Planner.

package/dist/payload/yaaw-core/roles/reviewer.md

@@ -0,0 +1,20 @@
+# Reviewer role
+
+## Authority
+Own independent acceptance judgment and `PASS`, `REPAIR`, `REPLAN`, or `BLOCKED` classification.
+
+## Required behavior
+- Use a fresh context when practical.
+- Inspect actual repository state, not the Implementer's summary.
+- Validate current ticket/spec/product revisions and verification evidence.
+- Apply `.yaaw-core/rules/changeability.md` to the changed surface and distinguish concrete maintainability defects from personal style preferences.
+- Tie the review to exact repository identity and source revisions.
+- Record immutable review rounds and concrete findings, including the violated principle and engineering impact for any blocking changeability finding.
+
+## Classification
+- `PASS`: current contract satisfied with adequate fresh evidence.
+- `REPAIR`: implementation is wrong/incomplete, including a bounded changeability defect; contract remains valid.
+- `REPLAN`: contract/architecture is materially invalid or insufficient.
+- `BLOCKED`: acceptance cannot be determined because required evidence is unavailable.
+
+Reviewer does not author implementation while acting as Reviewer. Style preference alone is never a review failure.

package/dist/payload/yaaw-core/rules/artifact-writing.md

@@ -0,0 +1,10 @@
+# Artifact writing rules
+
+- Prefer concise durable facts over chat transcripts.
+- Markdown artifacts use YAML frontmatter for schema/id/revision/status metadata and Markdown body for reasoning.
+- Reference decision/artifact IDs instead of duplicating planning history.
+- Keep product language product-focused.
+- Separate repository observations from assumptions.
+- Include provenance when a decision depends on a product requirement, prior decision, spec, observed code, or review finding.
+- Reviews are append-only rounds; never overwrite prior findings.
+- Stale/superseded artifacts remain readable and explicitly marked; do not silently rewrite history.

package/dist/payload/yaaw-core/rules/assumption-challenge.md

@@ -0,0 +1,109 @@
+# Assumption challenge
+
+## Purpose
+Improve decision quality inside PRD and Planning without creating a new role, workflow, lifecycle state, artifact, or authority layer.
+
+A challenge is warranted only when resolving it could materially change product intent, engineering design, frontier readiness, scope, failure behavior, or downstream implementation.
+
+## Applicability
+This rule is consumed by PRD and Planner workflows only.
+
+- **PRD** uses it to challenge product assumptions while preserving Human/PRD authority over product intent.
+- **Planner** uses it to challenge engineering assumptions while preserving Planner authority over engineering decisions and Human/PRD authority over product meaning.
+- **Orchestrator** does not challenge the user semantically; it routes to the role that owns the decision.
+- **Implementer** does not use challenge behavior to reopen accepted product or engineering contracts. Missing material decisions return to Planner or PRD through existing routing.
+- **Reviewer** scrutinizes implementation and contracts through independent review outcomes; Reviewer does not substitute for PRD/Planning by interrogating the user.
+
+This rule does not introduce a public skill, `*.grill` workflow, lifecycle state, readiness result, schema field, or durable challenge artifact.
+
+## Core principles
+
+### Facts before questions
+Establish inspectable facts before asking the human. Repository-answerable facts are the active role's responsibility. Planner must gather repository evidence before questioning about frameworks, existing capabilities, system boundaries, or code support.
+
+### Material challenge triggers
+Challenge material assumptions only when there is a concrete reason, such as:
+- conflict with an accepted decision;
+- conflict with repository evidence;
+- ambiguous terminology;
+- an unsupported or unproven assumption;
+- a material tradeoff or difficult-to-reverse choice;
+- a material failure, edge-case, security, data/state, migration, scope, or compatibility implication;
+- a user-flow contradiction or a premature abstraction.
+
+Do not generate filler merely to demonstrate rigor.
+
+### Attack ambiguity, not people
+Challenge the claim or model, never the person. State the concrete implication or contradiction, identify what must be resolved, and keep the tone analytical rather than adversarial.
+
+### Stress-test concrete scenarios
+When material, stress-test the proposed product behavior or engineering design with concrete success, failure, edge, state-transition, security, migration, operability, and compatibility scenarios. Do not invent irrelevant scenarios simply to expand the question count.
+
+### Decision dependencies and current frontier
+Respect decision dependencies. Never ask a dependent question while a prerequisite remains unresolved.
+
+Work only the current frontier:
+- settled reusable conclusions remain known decisions;
+- material questions answerable now belong to the current frontier;
+- issues that depend on future evidence remain future fog.
+
+Questions whose prerequisites are unknown stay out of the current round.
+
+### Recommendations and user ownership
+When meaningful alternatives exist and analysis supports a direction, include a `Recommendation:` and a short reason that exposes the actual tradeoff. Free-form answers remain first-class; options are never a forced menu.
+
+A recommendation must not become confirmation bias. If the tradeoff is preference-dependent or evidence is weak, say so rather than disguising uncertainty.
+
+### Do not delegate owned decisions
+Do not hand decisions back to the human merely because alternatives exist. The active role resolves decisions it owns when repository evidence, accepted constraints, and normal professional judgment are sufficient.
+
+Planner owns routine reversible implementation decisions such as local naming, helper decomposition, obvious repository-convention reuse, routine test organization, and other minor implementation details unless they become materially consequential.
+
+### Persistence and fresh-context recovery
+Persist accepted conclusions rather than a conversation transcript. Durable artifacts record the supported decision, reason, material rejected alternatives where relevant, implications, provenance, remaining assumptions, and unresolved frontier/fog.
+
+Do not persist `User said...`, `Assistant asked...`, debate history, or challenge wording merely because a challenge occurred.
+
+### Recompute after meaningful answers
+After accepted answers are durably recorded, recompute the frontier. Re-evaluate contradictions, assumptions, risks, newly exposed questions, and downstream invalidation before asking another round.
+
+### Stop when the next owner can proceed
+Stop challenging when the next owner can proceed without inventing a material product or engineering decision. Zero questions is valid.
+
+Do not challenge a settled decision merely to demonstrate rigor.
+
+Do not reopen accepted decisions without new evidence, contradiction, changed intent, or explicit human request.
+
+## PRD specialization
+PRD challenges whether the product meaning is sufficiently coherent and intentional. It may challenge:
+- product abstractions that are broader than the demonstrated need;
+- user, scope, behavior, flow, constraint, and non-goal assumptions;
+- contradictions between accepted product statements;
+- ambiguous domain/product terminology;
+- material failure behavior and edge cases;
+- premature product abstractions such as generic roles/permissions when only one concrete capability distinction is established.
+
+PRD must not decide engineering implementation decisions such as transport, database, framework, queue, cache, rendering architecture, ORM, or protocol unless the human explicitly made that method a product constraint. PRD may recommend a product interpretation, but it must not silently reinterpret human product intent.
+
+## Planner specialization
+Planner challenges whether accepted product intent is being interpreted and designed correctly against repository reality. It may challenge:
+- proposed architecture that exceeds the accepted requirement;
+- engineering assumptions contradicted by repository evidence;
+- unnecessary abstractions and new infrastructure;
+- material architecture/data/interface/failure/security/migration/testing/operability tradeoffs;
+- conflicts with accepted `ENG-*` decisions or known future constraints.
+
+Planner must use repository evidence before questioning, must not ask the human to decide routine reversible implementation decisions, and must never invent product intent. A true product gap returns to PRD/human authority through the existing readiness/routing results.
+
+Prefer the smallest architecture justified by accepted product requirements, repository constraints, known future constraints, and material quality requirements. Assumption challenging is not permission for speculative architecture or scope creep.
+
+## Prohibited behaviors
+- creating `@yaaw-grill`, `@yaaw-challenge`, `prd.grill`, or `planning.grill` as parallel semantic implementations;
+- treating the maximum question count as a target;
+- asking repository-answerable facts;
+- asking dependent questions before prerequisites are settled;
+- reopening accepted decisions without a valid trigger;
+- converting a newly discovered adjacent idea into current scope automatically;
+- storing challenge/debate transcripts as durable project memory;
+- allowing PRD to choose architecture or Planner to invent product meaning;
+- allowing Orchestrator, Implementer, or Reviewer to take over PRD/Planner user-question authority.

package/dist/payload/yaaw-core/rules/changeability.md

@@ -0,0 +1,38 @@
+# Changeability policy
+
+The governing principle is: **make the next correct change easier without expanding the current authorized change.**
+
+This policy is mandatory for Planner, Implementer, and Reviewer whenever software design or code is being shaped. It governs the quality of work already authorized by product/spec/ticket contracts; it never authorizes unrelated cleanup or speculative refactoring.
+
+## 1. Keep the main path visible
+Prefer control flow where the primary successful operation is easy to identify. Use guard clauses, extraction, or other simplifications when they reduce unnecessary nesting or branching. Do not flatten structure mechanically when nesting communicates real domain structure.
+
+## 2. Name by domain meaning
+Prefer names that expose business/domain meaning over generic containers such as `data`, `item`, `result`, or `obj` when a more specific concept is known. Names should reduce lookup/detective work without becoming needlessly verbose.
+
+## 3. Contain external systems behind boundaries
+Provider-specific schemas, field names, SDK types, transport details, and failure semantics should remain at the integration boundary unless the accepted architecture explicitly requires otherwise. Translate external representations into application/domain concepts at a narrow boundary so provider changes do not ripple through unrelated code.
+
+## 4. Make invalid states harder to represent
+When the domain distinguishes materially different valid states, prefer types, constructors, schemas, invariants, or validation boundaries that make impossible/invalid combinations difficult to create. Do not create type complexity unless it removes meaningful runtime uncertainty.
+
+## 5. Separate decisions from actions
+Keep important business decisions independently understandable and testable when practical. Separate policy/decision logic from database, network, filesystem, notification, or other side effects so rules can be verified without triggering the actions they control.
+
+## 6. Make failures useful
+Errors should provide useful human meaning plus stable machine-readable identity when the surrounding contract supports it. Preserve diagnostic context needed to investigate failures, but never log or expose passwords, authentication/session tokens, API keys, credentials, or sensitive payloads that are not explicitly safe to record.
+
+## 7. Keep changes focused
+A ticket should produce one coherent, reviewable change. A maintainability issue discovered during implementation does not automatically enter scope. Make a supporting change only when it is necessary to satisfy the admitted ticket safely; otherwise leave it unchanged and surface it as a future planning/refactoring candidate when materially valuable.
+
+## Applicability
+Not every principle produces a required code change on every ticket. Apply only the principles relevant to the changed surface and accepted architecture. `NOT_APPLICABLE` is a valid assessment when a principle has no meaningful bearing on the change.
+
+## Review threshold
+A preference is not a defect. A changeability finding is blocking only when concrete evidence shows one of the following:
+- the current implementation violates an accepted engineering/architecture constraint;
+- the design materially increases coupling, ambiguity, invalid-state risk, side-effect entanglement, failure opacity, or review/recovery risk in the changed surface;
+- the change includes unrelated scope that weakens reviewability or rollback safety;
+- the violation prevents adequate testing or makes the ticket contract materially harder to verify.
+
+Review findings must cite the principle, concrete location/evidence, expected property, actual implementation, and required repair or replan action.

package/dist/payload/yaaw-core/rules/durable-memory.md

@@ -0,0 +1,9 @@
+# Durable memory rules
+
+1. Conversation is never the only location of an accepted decision.
+2. Record accepted product/engineering decisions before another question round.
+3. Every accepted artifact carries machine-readable identity/revision metadata.
+4. Keep task-specific mistakes in ticket/review history.
+5. Promote only reusable project invariants into `.yaaw-core/project/rules/`.
+6. Preserve superseded/stale artifacts; invalidate their authority instead of deleting history.
+7. A fresh context unable to continue from artifacts indicates incomplete documentation.

package/dist/payload/yaaw-core/rules/question-format.md

@@ -0,0 +1,20 @@
+# Question format
+
+Before formatting a PRD or Planning question round, the active role applies `.yaaw-core/rules/assumption-challenge.md` to determine which questions belong on the current frontier. This file owns presentation and sequencing only; contradiction detection, stress testing, facts-before-questions, terminology analysis, and role authority remain canonical in the assumption-challenge and authority contracts.
+
+Question rounds contain at most 10 meaningful questions and never filler. The maximum is not a target; zero questions is valid when the active role can safely proceed.
+
+Preferred structure:
+
+```text
+1. Question?
+A. Option
+B. Option
+C. Option
+Recommendation: B
+Reason: ...
+```
+
+Use options and recommendations where useful. Free-form answers are first-class and must never be forced into the offered choices. New unknowns discovered from an answer belong in the next round unless they block recording the current answer safely.
+
+Before presenting another round, persist the accepted answers and update unresolved questions/frontier.

package/dist/payload/yaaw-core/rules/recovery-evidence.md

@@ -0,0 +1,9 @@
+# Recovery evidence rules
+
+State files are claims. Observed repository evidence is stronger for implementation reality.
+
+Safe reconciliation requires enough evidence to identify the last trustworthy boundary and exact repository identity. Use evidence records, current artifact revisions, git history/diff, and review records together.
+
+When the boundary cannot be established, preserve evidence, avoid destructive re-execution, and return `BLOCKED` with exact missing proof.
+
+Never execute a runtime handoff whose repository or source-revision basis is stale.

package/dist/payload/yaaw-core/rules/repository-identity.md

@@ -0,0 +1,16 @@
+# Repository identity
+
+Acceptance and recovery must distinguish one working state from another, including uncommitted work.
+
+Record:
+- `head_commit`: current `HEAD` commit SHA;
+- `dirty`: whether tracked/untracked work differs from HEAD;
+- `worktree_digest`: SHA-256 over a deterministic snapshot of status plus tracked/staged diffs and untracked file content where accessible.
+
+Recommended digest inputs:
+1. `git status --porcelain=v1 -z`;
+2. `git diff --binary HEAD`;
+3. `git diff --cached --binary HEAD`;
+4. sorted untracked paths and their byte hashes.
+
+If the environment cannot produce a trustworthy worktree digest for dirty work, review/recovery must say so and may return `BLOCKED` rather than pretending the state is uniquely identified.

package/dist/payload/yaaw-core/rules/review-independence.md

@@ -0,0 +1,9 @@
+# Review independence
+
+Reviewer evaluates actual repository work against the current ticket/spec/product/engineering contract and verification evidence.
+
+- Do not accept an Implementer's summary as proof.
+- Tie every review to repository identity plus ticket/spec revisions.
+- Only Reviewer may transition `REVIEW_REQUIRED -> PASS`.
+- A later source revision or repository drift can make prior PASS evidence stale without deleting the historical review.
+- Reviewer may classify `REPLAN`, but Planner owns the resulting contract change.

package/dist/payload/yaaw-core/rules/ticket-sizing.md

@@ -0,0 +1,9 @@
+# Ticket sizing
+
+A ticket is correctly sized when one fresh Implementer can complete one coherent engineering change and verify a concrete outcome without inventing material product or architecture decisions.
+
+Too large: multiple unrelated subsystems, major architecture rediscovery, vague behavior, missing acceptance, or many unverified intermediate states.
+
+Too small: bookkeeping with no coherent independently verifiable outcome.
+
+A ticket cannot be `READY` unless its source spec/frontier is current and dependency states satisfy admission.

package/dist/payload/yaaw-core/schemas/engineering.schema.json

@@ -0,0 +1,15 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "yaaw.engineering/v1",
+  "type": "object",
+  "required": ["schema", "revision", "status", "product_revision", "current_frontier", "readiness"],
+  "properties": {
+    "schema": {"const": "yaaw.engineering/v1"},
+    "revision": {"type": "integer", "minimum": 1},
+    "status": {"enum": ["discovery", "questions", "ready", "blocked"]},
+    "product_revision": {"type": "integer", "minimum": 1},
+    "current_frontier": {"type": ["string", "null"]},
+    "readiness": {"enum": ["pending", "PASS", "MISSING_DECISIONS", "PRODUCT_GAP", "REPLAN", "BLOCKED"]}
+  },
+  "additionalProperties": false
+}

package/dist/payload/yaaw-core/schemas/evidence.schema.json

@@ -0,0 +1,36 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "yaaw.evidence/v1",
+  "type": "object",
+  "required": ["schema", "id", "ticket", "ticket_revision", "spec_revision", "kind", "repository", "workflow", "commands", "checks"],
+  "properties": {
+    "schema": {"const": "yaaw.evidence/v1"},
+    "id": {"type": "string", "pattern": "^EVIDENCE-TASK-[0-9]+-V[0-9]+$"},
+    "ticket": {"type": "string", "pattern": "^TASK-[0-9]+$"},
+    "ticket_revision": {"type": "integer", "minimum": 1},
+    "spec_revision": {"type": "integer", "minimum": 1},
+    "kind": {"enum": ["implementation_verification", "repair_verification", "review_verification", "recovery"]},
+    "repository": {
+      "type": "object",
+      "required": ["head_commit", "dirty", "worktree_digest"],
+      "properties": {
+        "head_commit": {"type": "string", "minLength": 1},
+        "dirty": {"type": "boolean"},
+        "worktree_digest": {"type": "string", "minLength": 1}
+      },
+      "additionalProperties": false
+    },
+    "workflow": {"type": "string", "minLength": 1},
+    "commands": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["command", "result"],
+        "properties": {"command": {"type": "string"}, "result": {"type": "string"}},
+        "additionalProperties": false
+      }
+    },
+    "checks": {"type": "array", "items": {"type": "string"}}
+  },
+  "additionalProperties": false
+}

package/dist/payload/yaaw-core/schemas/handoff.schema.json

@@ -0,0 +1,28 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "yaaw.handoff/v1",
+  "type": "object",
+  "required": ["schema", "role", "workflow", "active_artifact", "references", "revisions", "expertise", "expected_output", "repository", "transition_sequence"],
+  "properties": {
+    "schema": {"const": "yaaw.handoff/v1"},
+    "role": {"enum": ["prd", "planner", "implementer", "reviewer", "orchestrator"]},
+    "workflow": {"type": "string", "minLength": 1},
+    "active_artifact": {"type": "string", "minLength": 1},
+    "references": {"type": "array", "items": {"type": "string"}},
+    "revisions": {"type": "object", "additionalProperties": {"type": "integer", "minimum": 0}},
+    "expertise": {"type": "array", "items": {"type": "string"}},
+    "expected_output": {"type": "string", "minLength": 1},
+    "repository": {
+      "type": "object",
+      "required": ["head_commit", "dirty", "worktree_digest"],
+      "properties": {
+        "head_commit": {"type": "string", "minLength": 1},
+        "dirty": {"type": "boolean"},
+        "worktree_digest": {"type": "string", "minLength": 1}
+      },
+      "additionalProperties": false
+    },
+    "transition_sequence": {"type": "integer", "minimum": 0}
+  },
+  "additionalProperties": false
+}

package/dist/payload/yaaw-core/schemas/observed-state.schema.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "yaaw.observed-state/v1",
+  "type": "object",
+  "required": ["schema", "repository", "transition_sequence", "claims", "artifacts", "inconsistencies", "candidate_actions"],
+  "properties": {
+    "schema": {"const": "yaaw.observed-state/v1"},
+    "repository": {
+      "type": "object",
+      "required": ["head_commit", "dirty", "worktree_digest"],
+      "properties": {
+        "head_commit": {"type": "string", "minLength": 1},
+        "dirty": {"type": "boolean"},
+        "worktree_digest": {"type": "string", "minLength": 1}
+      },
+      "additionalProperties": false
+    },
+    "transition_sequence": {"type": "integer", "minimum": 0},
+    "claims": {"type": "object"},
+    "artifacts": {"type": "object"},
+    "inconsistencies": {"type": "array", "items": {"type": "string"}},
+    "candidate_actions": {"type": "array", "items": {"type": "string"}}
+  },
+  "additionalProperties": false
+}

package/dist/payload/yaaw-core/schemas/product.schema.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "yaaw.product/v1",
+  "type": "object",
+  "required": ["schema", "revision", "status"],
+  "properties": {
+    "schema": {"const": "yaaw.product/v1"},
+    "revision": {"type": "integer", "minimum": 1},
+    "status": {"enum": ["draft", "ready", "blocked"]}
+  },
+  "additionalProperties": false
+}

package/dist/payload/yaaw-core/schemas/project-state.schema.json

@@ -0,0 +1,74 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "yaaw.project-state/v1",
+  "type": "object",
+  "required": ["schema", "phase", "product", "planning", "active_ticket", "tickets", "transition_sequence", "last_transition", "blocker", "last_observed_commit", "last_workflow"],
+  "properties": {
+    "schema": {"const": "yaaw.project-state/v1"},
+    "phase": {"enum": ["product", "planning", "implementation", "complete", "blocked"]},
+    "product": {
+      "type": "object",
+      "required": ["artifact", "status", "revision"],
+      "properties": {
+        "artifact": {"type": "string"},
+        "status": {"enum": ["missing", "draft", "ready", "blocked"]},
+        "revision": {"type": "integer", "minimum": 0}
+      },
+      "additionalProperties": false
+    },
+    "planning": {
+      "type": "object",
+      "required": ["artifact", "status", "revision", "current_frontier", "readiness", "active_spec"],
+      "properties": {
+        "artifact": {"type": "string"},
+        "status": {"enum": ["missing", "discovery", "questions", "ready", "blocked"]},
+        "revision": {"type": "integer", "minimum": 0},
+        "current_frontier": {"type": ["string", "null"]},
+        "readiness": {"enum": ["pending", "PASS", "MISSING_DECISIONS", "PRODUCT_GAP", "REPLAN", "BLOCKED"]},
+        "active_spec": {"type": ["string", "null"]}
+      },
+      "additionalProperties": false
+    },
+    "active_ticket": {"type": ["string", "null"], "pattern": "^TASK-[0-9]+$"},
+    "tickets": {"type": "object", "additionalProperties": {"enum": ["DRAFT", "READY", "IN_PROGRESS", "REVIEW_REQUIRED", "REPAIR_REQUIRED", "REPLAN_REQUIRED", "BLOCKED", "PASS", "CANCELLED"]}},
+    "transition_sequence": {"type": "integer", "minimum": 0},
+    "last_transition": {
+      "anyOf": [
+        {"type": "null"},
+        {
+          "type": "object",
+          "required": ["sequence", "subject", "from", "to", "workflow", "reason", "evidence", "observed_commit"],
+          "properties": {
+            "sequence": {"type": "integer", "minimum": 1},
+            "subject": {"type": "string", "minLength": 1},
+            "from": {"type": ["string", "null"]},
+            "to": {"type": "string", "minLength": 1},
+            "workflow": {"type": "string", "minLength": 1},
+            "reason": {"type": "string", "minLength": 1},
+            "evidence": {"type": "array", "items": {"type": "string"}},
+            "observed_commit": {"type": ["string", "null"]}
+          },
+          "additionalProperties": false
+        }
+      ]
+    },
+    "blocker": {
+      "anyOf": [
+        {"type": "null"},
+        {
+          "type": "object",
+          "required": ["kind", "summary", "missing"],
+          "properties": {
+            "kind": {"type": "string", "minLength": 1},
+            "summary": {"type": "string", "minLength": 1},
+            "missing": {"type": "array", "items": {"type": "string"}}
+          },
+          "additionalProperties": false
+        }
+      ]
+    },
+    "last_observed_commit": {"type": ["string", "null"]},
+    "last_workflow": {"type": ["string", "null"]}
+  },
+  "additionalProperties": false
+}

package/dist/payload/yaaw-core/schemas/review.schema.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "yaaw.review/v1",
+  "type": "object",
+  "required": ["schema", "ticket", "round", "result", "ticket_revision", "spec_revision", "reviewed_head_commit", "reviewed_dirty", "reviewed_worktree_digest", "evidence"],
+  "properties": {
+    "schema": {"const": "yaaw.review/v1"},
+    "ticket": {"type": "string", "pattern": "^TASK-[0-9]+$"},
+    "round": {"type": "integer", "minimum": 1},
+    "result": {"enum": ["PASS", "REPAIR", "REPLAN", "BLOCKED"]},
+    "ticket_revision": {"type": "integer", "minimum": 1},
+    "spec_revision": {"type": "integer", "minimum": 1},
+    "reviewed_head_commit": {"type": "string", "minLength": 1},
+    "reviewed_dirty": {"type": "boolean"},
+    "reviewed_worktree_digest": {"type": "string", "minLength": 1},
+    "evidence": {"type": "array", "items": {"type": "string"}, "minItems": 1}
+  },
+  "additionalProperties": false
+}

package/dist/payload/yaaw-core/schemas/spec.schema.json

@@ -0,0 +1,17 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "yaaw.spec/v1",
+  "type": "object",
+  "required": ["schema", "id", "revision", "status", "product_revision", "engineering_revision", "frontier_id", "decision_ids"],
+  "properties": {
+    "schema": {"const": "yaaw.spec/v1"},
+    "id": {"type": "string", "pattern": "^SPEC-[0-9]+$"},
+    "revision": {"type": "integer", "minimum": 1},
+    "status": {"enum": ["DRAFT", "ACCEPTED", "STALE", "SUPERSEDED"]},
+    "product_revision": {"type": "integer", "minimum": 1},
+    "engineering_revision": {"type": "integer", "minimum": 1},
+    "frontier_id": {"type": "string", "minLength": 1},
+    "decision_ids": {"type": "array", "items": {"type": "string", "pattern": "^ENG-[0-9]+$"}, "uniqueItems": true}
+  },
+  "additionalProperties": false
+}

package/dist/payload/yaaw-core/schemas/ticket.schema.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "yaaw.ticket/v1",
+  "type": "object",
+  "required": ["schema", "id", "revision", "spec", "spec_revision", "product_revision", "engineering_revision", "status", "dependencies", "decision_ids", "expertise"],
+  "properties": {
+    "schema": {"const": "yaaw.ticket/v1"},
+    "id": {"type": "string", "pattern": "^TASK-[0-9]+$"},
+    "revision": {"type": "integer", "minimum": 1},
+    "spec": {"type": "string", "pattern": "^SPEC-[0-9]+$"},
+    "spec_revision": {"type": "integer", "minimum": 1},
+    "product_revision": {"type": "integer", "minimum": 1},
+    "engineering_revision": {"type": "integer", "minimum": 1},
+    "status": {"enum": ["DRAFT", "READY", "IN_PROGRESS", "REVIEW_REQUIRED", "REPAIR_REQUIRED", "REPLAN_REQUIRED", "BLOCKED", "PASS", "CANCELLED"]},
+    "dependencies": {"type": "array", "items": {"type": "string", "pattern": "^TASK-[0-9]+$"}, "uniqueItems": true},
+    "decision_ids": {"type": "array", "items": {"type": "string", "pattern": "^ENG-[0-9]+$"}, "uniqueItems": true},
+    "expertise": {"type": "array", "items": {"type": "string"}, "uniqueItems": true}
+  },
+  "additionalProperties": false
+}

package/dist/payload/yaaw-core/templates/engineering.md

@@ -0,0 +1,33 @@
+---
+schema: yaaw.engineering/v1
+revision: 1
+status: discovery
+product_revision: 1
+current_frontier: FRONTIER-001
+readiness: pending
+---
+# Engineering
+
+## Product interpretation
+
+## Existing system
+
+## Engineering constraints
+
+## Decisions
+
+<!-- ENG-001 etc. Each decision: Status, Decision, Reason, Rejected alternatives, Implications, Provenance. -->
+
+## Assumptions
+
+## Unresolved questions
+
+## Risks
+
+## Current decision frontier
+
+## Future fog
+
+## Architecture spine
+
+## Readiness status

package/dist/payload/yaaw-core/templates/evidence.json

@@ -0,0 +1,12 @@
+{
+  "schema": "yaaw.evidence/v1",
+  "id": "EVIDENCE-TASK-000-V1",
+  "ticket": "TASK-000",
+  "ticket_revision": 1,
+  "spec_revision": 1,
+  "kind": "implementation_verification",
+  "repository": {"head_commit": "COMMIT", "dirty": true, "worktree_digest": "DIGEST"},
+  "workflow": "implementation.verify-ticket",
+  "commands": [],
+  "checks": []
+}

package/dist/payload/yaaw-core/templates/handoff.json

@@ -0,0 +1,12 @@
+{
+  "schema": "yaaw.handoff/v1",
+  "role": "implementer",
+  "workflow": "implementation.implement-ticket",
+  "active_artifact": ".yaaw-core/project/tickets/TASK-000.md",
+  "references": [],
+  "revisions": {"product": 1, "engineering": 1, "spec": 1, "ticket": 1},
+  "expertise": [],
+  "expected_output": "implementation_evidence",
+  "repository": {"head_commit": "COMMIT", "dirty": false, "worktree_digest": "DIGEST"},
+  "transition_sequence": 0
+}

package/dist/payload/yaaw-core/templates/observed-state.json

@@ -0,0 +1,9 @@
+{
+  "schema": "yaaw.observed-state/v1",
+  "repository": {"head_commit": "COMMIT", "dirty": false, "worktree_digest": "DIGEST"},
+  "transition_sequence": 0,
+  "claims": {},
+  "artifacts": {},
+  "inconsistencies": [],
+  "candidate_actions": []
+}