haiku-method 2.2.0

package/studios/migration/stages/cutover/outputs/CUTOVER-RUNBOOK.md

@@ -0,0 +1,25 @@
+---
+name: cutover-runbook
+location: .haiku/intents/{intent-slug}/stages/cutover/artifacts/
+scope: intent
+format: text
+required: true
+---
+
+# Cutover Runbook
+
+Step-by-step cutover plan with rollback procedures and communication plan.
+
+## Expected Artifacts
+
+- **Runbook** -- every step with owner, expected duration, and go/no-go checkpoint
+- **Rollback procedure** -- tested end-to-end, restores source system within defined RTO
+- **Communication plan** -- downstream consumers notified with maintenance window and escalation contacts
+- **Cutover verification** -- post-cutover checks confirming successful migration
+
+## Quality Signals
+
+- Every step has an owner and go/no-go checkpoint
+- Rollback procedure is tested end-to-end before cutover
+- Communication plan covers all downstream consumers
+- Post-cutover verification confirms production is healthy

package/studios/migration/stages/cutover/phases/ELABORATION.md

@@ -0,0 +1,16 @@
+# Cutover Stage — Elaboration
+
+## Criteria Guidance
+
+### Good criteria — concrete and verifiable
+
+- "Cutover runbook lists every step with owner, expected duration, and go/no-go checkpoint"
+- "Rollback procedure is tested end-to-end and restores the source system to pre-migration state within the defined RTO"
+- "Communication plan notifies all downstream consumers with maintenance window, expected impact, and escalation contacts"
+
+### Bad criteria — vague (no clear check)
+
+- "Cutover plan exists"
+- "Rollback is possible"
+- "Stakeholders are notified"
+

package/studios/migration/stages/cutover/review-agents/rollback-readiness.md

@@ -0,0 +1,10 @@
+---
+interpretation: lens
+---
+**Mandate:** The agent **MUST** verify the cutover plan includes viable rollback at every step.
+
+**Check:**
+- The agent **MUST** verify that each cutover step has a defined rollback procedure
+- The agent **MUST** verify that the rollback procedure references a **prior validation-stage rehearsal record** (the validation stage owns rollback testing; cutover only proceeds if that test passed). If no rehearsal record exists, that's a hard reject — but the fix is to run validation, not to test rollback inside cutover.
+- The agent **MUST** verify that data synchronization strategy covers the cutover window (no lost writes)
+- The agent **MUST** verify that communication plan covers all stakeholders for both go and rollback scenarios

package/studios/migration/stages/mapping/STAGE.md

@@ -0,0 +1,15 @@
+---
+name: mapping
+description: Map source schemas and systems to target, define transformation rules
+hats: [schema-mapper, compatibility-reviewer]
+fix_hats: [schema-mapper, feedback-assessor]
+review: ask
+elaboration: collaborative
+inputs:
+  - stage: assessment
+    discovery: migration-inventory
+---
+
+# Mapping
+
+Map source schemas and systems to target, define transformation rules.

package/studios/migration/stages/mapping/discovery/MAPPING-SPEC.md

@@ -0,0 +1,30 @@
+---
+name: mapping-spec
+location: .haiku/intents/{intent-slug}/knowledge/MAPPING-SPEC.md
+scope: intent
+format: text
+required: true
+---
+
+# Mapping Specification
+
+Document field-level source-to-target mappings and transformation rules. This output feeds the migrate stage as the blueprint for implementation.
+
+## Content Guide
+
+Structure the specification by entity:
+
+- **Entity mappings** — source entity to target entity with mapping rationale
+- **Field-level mappings** — every source field mapped to a target field with transformation rule
+- **Transformation rules** — renames, type casts, derivations, default fills, drops
+- **Edge-case handling** — nulls, encoding differences, precision loss, constraint violations
+- **Compatibility issues** — type mismatches, semantic gaps, constraint conflicts with resolutions
+- **Unmapped fields** — fields intentionally dropped with documented rationale
+- **New target fields** — fields in the target with no source equivalent and their default/derivation logic
+
+## Quality Signals
+
+- Every source field has an explicit disposition (map, transform, drop) — no gaps
+- Transformation rules are deterministic and testable in isolation
+- Lossy transformations are flagged with documented data loss implications
+- Compatibility review sign-off is recorded with any conditional approvals noted

package/studios/migration/stages/mapping/hats/compatibility-reviewer.md

@@ -0,0 +1,11 @@
+---
+interpretation: lens
+---
+**Focus:** Review the schema-mapper's spec for correctness, completeness, and feasibility. Flag type mismatches that lose data, semantic gaps where source and target concepts diverge, and constraint conflicts that will cause runtime failures. Ensure downstream consumers are not broken by the mapping decisions.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** rubber-stamp the mapping without verifying type compatibility
+- The agent **MUST NOT** focus only on structural compatibility and ignoring semantic differences
+- The agent **MUST NOT** approve lossy transformations without documenting the data loss implications
+- The agent **MUST NOT** ignore the impact on downstream consumers that readd from the target
+- The agent **MUST NOT** review in isolation without referencing the risk register from assessment

package/studios/migration/stages/mapping/hats/feedback-assessor.md

@@ -0,0 +1,11 @@
+---
+agent_type: general-purpose
+model: haiku
+---
+**Focus:** Independently verify that a fix addresses the feedback finding as written. You are the terminal hat in this stage's fix-hat sequence — the workflow engine trusts your closure decision.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** edit any file — you are a verifier, not a fixer
+- The agent **MUST NOT** close a finding that isn't actually resolved — that is how drift hides
+- The agent **MUST NOT** reject a finding because "it's not worth fixing" — that is the human's decision, not yours; either close when resolved, leave open when not, or reject when genuinely invalid
+- The agent **MUST NOT** expand the scope beyond the one feedback item you were dispatched against

package/studios/migration/stages/mapping/hats/schema-mapper.md

@@ -0,0 +1,8 @@
+**Focus:** Produce field-level mappings from every source entity to its target equivalent. Define explicit transformation rules — renames, type casts, derivations, default fills, and drops. Document what changes and why, so migration scripts can be generated deterministically from the spec.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** map only the happy path and ignoring nulls, encoding, or precision differences
+- The agent **MUST NOT** leave fields as "TBD" instead of making an explicit decision (even if that decision is "drop")
+- The agent **MUST NOT** assume field names that match across systems have identical semantics
+- The agent **MUST NOT** create mappings that can't be tested in isolation
+- The agent **MUST NOT** ignore constraints (unique, foreign key, check) that differ between source and target

package/studios/migration/stages/mapping/outputs/MAPPING-SPEC.md

@@ -0,0 +1,25 @@
+---
+name: mapping-spec
+location: .haiku/intents/{intent-slug}/stages/mapping/artifacts/
+scope: intent
+format: text
+required: true
+---
+
+# Mapping Specification
+
+Field-level source-to-target mappings with transformation rules and compatibility review.
+
+## Expected Artifacts
+
+- **Field mappings** -- every source field mapped to target with explicit transformation rule (rename, cast, derive, drop)
+- **Type compatibility** -- incompatible types listed with resolution strategy and data loss implications
+- **Edge case documentation** -- nulls, encoding differences, precision loss, and constraint violations
+- **Semantic gap analysis** -- differences in meaning between source and target schemas
+
+## Quality Signals
+
+- Every source field has an explicit mapping to target with transformation rule
+- Incompatible types have resolution strategies with data loss implications documented
+- Edge cases are documented for nulls, encoding, precision, and constraints
+- All resolution decisions are documented with rationale

package/studios/migration/stages/mapping/phases/ELABORATION.md

@@ -0,0 +1,16 @@
+# Mapping Stage — Elaboration
+
+## Criteria Guidance
+
+### Good criteria — concrete and verifiable
+
+- "Every source field maps to a target field with explicit transformation rules (rename, cast, derive, drop)"
+- "Incompatible types are listed with chosen resolution strategy and data loss implications"
+- "Edge cases document at least: nulls, encoding differences, precision loss, and constraint violations"
+
+### Bad criteria — vague (no clear check)
+
+- "Mapping is done"
+- "Schemas are compared"
+- "Transformations are defined"
+

package/studios/migration/stages/mapping/review-agents/accuracy.md

@@ -0,0 +1,10 @@
+---
+interpretation: lens
+---
+**Mandate:** The agent **MUST** verify source-to-target mappings are correct and complete.
+
+**Check:**
+- The agent **MUST** verify that every source field maps to a target field or has documented exclusion justification
+- The agent **MUST** verify that type conversions are specified for all incompatible field types
+- The agent **MUST** verify that transformation rules handle edge cases (nulls, encoding, date formats)
+- The agent **MUST** verify that no semantic meaning is lost in the mapping (e.g., enum values, status codes)

package/studios/migration/stages/migrate/STAGE.md

@@ -0,0 +1,15 @@
+---
+name: migrate
+description: Implement migration scripts, adapters, and data transforms
+hats: [migration-engineer, integration-tester, verifier]
+fix_hats: [migration-engineer, feedback-assessor]
+review: ask
+elaboration: autonomous
+inputs:
+  - stage: mapping
+    discovery: mapping-spec
+---
+
+# Migrate
+
+Implement migration scripts, adapters, and data transforms.

package/studios/migration/stages/migrate/discovery/MIGRATION-ARTIFACTS.md

@@ -0,0 +1,30 @@
+---
+name: migration-artifacts
+location: .haiku/intents/{intent-slug}/knowledge/MIGRATION-ARTIFACTS.md
+scope: intent
+format: text
+required: true
+---
+
+# Migration Artifacts
+
+Document the implemented migration scripts, adapters, and test results. This output feeds the validation stage for integrity verification.
+
+## Content Guide
+
+Structure the artifacts around the implementation:
+
+- **Script inventory** — list of migration scripts with purpose, execution order, and dependencies
+- **Adapter documentation** — data adapters and transformation logic with interface contracts
+- **Dry-run results** — output from executing scripts in dry-run mode against representative data
+- **Integration test results** — test coverage summary with pass/fail for happy path, edge cases, and failure scenarios
+- **Idempotency verification** — evidence that re-running scripts produces consistent results
+- **Execution plan** — recommended order, parallelism, and checkpointing strategy
+- **Known limitations** — any gaps between the mapping spec and what was implemented, with rationale
+
+## Quality Signals
+
+- Every script is idempotent and produces execution logs
+- Dry-run mode exists and its output matches expectations from the mapping spec
+- Integration tests cover happy path, nulls, encoding, constraints, and failure recovery
+- No script hardcodes environment-specific values

package/studios/migration/stages/migrate/hats/feedback-assessor.md

@@ -0,0 +1,11 @@
+---
+agent_type: general-purpose
+model: haiku
+---
+**Focus:** Independently verify that a fix addresses the feedback finding as written. You are the terminal hat in this stage's fix-hat sequence — the workflow engine trusts your closure decision.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** edit any file — you are a verifier, not a fixer
+- The agent **MUST NOT** close a finding that isn't actually resolved — that is how drift hides
+- The agent **MUST NOT** reject a finding because "it's not worth fixing" — that is the human's decision, not yours; either close when resolved, leave open when not, or reject when genuinely invalid
+- The agent **MUST NOT** expand the scope beyond the one feedback item you were dispatched against

package/studios/migration/stages/migrate/hats/integration-tester.md

@@ -0,0 +1,8 @@
+**Focus:** Verify that migration scripts produce correct output against a non-production target. Test the full pipeline: extraction, transformation, loading, and post-loadd constraint enforcement. Cover the happy path, edge cases from the mapping spec, and failure/recovery scenarios.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** test only the happy path and declaring victory
+- The agent **MUST NOT** compar row counts without verifying field-level content
+- The agent **MUST NOT** run tests against a stale or unrepresentative dataset
+- The agent **MUST** test idempotency (run twice, check for duplicates)
+- The agent **MUST NOT** skip failure injection (what happens when the target is unreachable mid-batch?)

package/studios/migration/stages/migrate/hats/migration-engineer.md

@@ -0,0 +1,8 @@
+**Focus:** Implement the migration scripts, adapters, and data transforms specified in the mapping document. Every script must be idempotent, logged, and runnable in dry-run mode. Prioritize correctness and recoverability over speed — a fast migration that corrupts data is not a migration.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** write one-shot scripts that fail silently on re-run
+- The agent **MUST NOT** hardcode connection strings or credentials instead of parameterizing
+- The agent **MUST NOT** skip dry-run mode because "it works on my machine"
+- The agent **MUST NOT** migrate everything in a single transaction that can't be checkpointed
+- The agent **MUST NOT** ignore the mapping spec and improvising transformations in code

package/studios/migration/stages/migrate/hats/verifier.md

@@ -0,0 +1,26 @@
+**Focus:** Validate the per-unit build artifact for the migrate stage of migration. Units here are migration step — discrete pieces of work with executable acceptance criteria. Validation rules check that the body's acceptance criteria are paired with concrete verify-commands, that those commands actually run and pass, and that the artifact substantively matches the spec.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** read or interpret unit frontmatter for any mechanical purpose. workflow engine territory per architecture §1.1.
+- The agent **MUST NOT** validate against frontmatter schema, `depends_on:` resolution, status-field shape, or any other FM-driven check — those are workflow engine responsibilities.
+- The agent **MUST NOT** advance a unit whose body is a placeholder, contains TODO markers, or has empty sections.
+- The agent **MUST NOT** reject for stylistic preferences. Substantive gaps only.
+- The agent **MUST** name a specific failed criterion in any rejection.
+- The agent **MUST NOT** invent rules not in this mandate. Stage scope is the contract.
+
+## What you check (BODY ONLY)
+
+### 1. Body matches the spec it claims to satisfy
+The unit body MUST substantively address every acceptance criterion declared in the unit's spec section. Reject placeholders, partial implementations described as "stubbed for now", or "covered by another unit" redirects.
+
+### 2. Acceptance criteria paired with verify-commands
+Every acceptance criterion in the body MUST be paired with a concrete shell command (or test invocation) that returns a clear pass/fail signal. Vague criteria ("works correctly", "tests pass") are a reject. Map verify-commands to the project's actual stack — read `package.json` / `pyproject.toml` / `Cargo.toml` / `go.mod` to know which test runner / coverage tool / linter the project uses.
+
+### 3. Verify-commands actually pass
+Run the named verify-commands. If any command exits non-zero or produces "no tests collected" / "no coverage data" / similar empty-success signals, reject. Cite the failing command and its exit code in the rejection reason.
+
+### 4. Decision-register consistency
+The unit must not introduce an approach contradicting a recorded Decision (e.g., a sync API when Decision N chose async). Cite the Decision ID.
+
+### 5. Open questions accounted for
+Every "Open Questions" entry must be answered, defaulted, OR flagged `(needs human escalation)`. Build-stage open questions block downstream consumers — be strict.

package/studios/migration/stages/migrate/outputs/MIGRATION-ARTIFACTS.md

@@ -0,0 +1,25 @@
+---
+name: migration-artifacts
+location: (project source tree)
+scope: repo
+format: code
+required: true
+---
+
+# Migration Artifacts
+
+Idempotent migration scripts with integration tests and dry-run capabilities.
+
+## Expected Artifacts
+
+- **Migration scripts** -- idempotent scripts that re-running produces the same result without duplicates
+- **Integration tests** -- happy path, null handling, encoding edge cases, and constraint violations
+- **Dry-run mode** -- produces a diff report without writing to the target
+- **Execution logs** -- each script run is logged with results
+
+## Quality Signals
+
+- Scripts are idempotent and logged
+- Integration tests verify row counts, type fidelity, and referential integrity
+- Dry-run output matches expectations from the mapping spec
+- All mapping spec transformations are implemented

package/studios/migration/stages/migrate/phases/ELABORATION.md

@@ -0,0 +1,16 @@
+# Migrate Stage — Elaboration
+
+## Criteria Guidance
+
+### Good criteria — concrete and verifiable
+
+- "Migration scripts are idempotent — re-running produces the same result without duplicating data"
+- "Integration tests cover at least: happy path, null handling, encoding edge cases, and constraint violations"
+- "Dry-run mode exists and produces a diff report without writing to the target"
+
+### Bad criteria — vague (no clear check)
+
+- "Scripts work"
+- "Data is migrated"
+- "Tests pass"
+

package/studios/migration/stages/migrate/review-agents/data-integrity.md

@@ -0,0 +1,11 @@
+---
+interpretation: lens
+---
+**Mandate:** The agent **MUST** verify migration scripts preserve data integrity.
+
+**Check:**
+- The agent **MUST** verify that row counts reconcile between source and target
+- The agent **MUST** verify that foreign key relationships are maintained after migration
+- The agent **MUST** verify that no data truncation from field size differences
+- The agent **MUST** verify that idempotency: running the migration twice does not corrupt data
+- The agent **MUST** verify that error handling captures and reports failed records without halting the entire migration

package/studios/migration/stages/validation/STAGE.md

@@ -0,0 +1,18 @@
+---
+name: validation
+description: Verify data integrity, functional parity, and performance
+hats: [validator, regression-tester, verifier]
+fix_hats: [validator, feedback-assessor]
+review: ask
+elaboration: autonomous
+inputs:
+  - stage: migrate
+    discovery: migration-artifacts
+review-agents-include:
+  - stage: mapping
+    agents: [accuracy]
+---
+
+# Validation
+
+Verify data integrity, functional parity, and performance.

package/studios/migration/stages/validation/discovery/VALIDATION-REPORT.md

@@ -0,0 +1,30 @@
+---
+name: validation-report
+location: .haiku/intents/{intent-slug}/knowledge/VALIDATION-REPORT.md
+scope: intent
+format: text
+required: true
+---
+
+# Validation Report
+
+Document quantitative verification of the migration. This output feeds the cutover stage as evidence for go/no-go decisions.
+
+## Content Guide
+
+Structure the report around verification categories:
+
+- **Row-count reconciliation** — source vs. target counts per entity with discrepancy analysis
+- **Checksum comparison** — hash-based verification for data integrity
+- **Sample-based validation** — randomly sampled records with field-level diffs
+- **Constraint verification** — unique keys, foreign keys, check constraints all satisfied in target
+- **Regression test results** — downstream consumers produce identical output against migrated data
+- **Performance benchmarks** — query latency comparison for critical paths (source vs. target)
+- **Discrepancy register** — any differences found with root cause and resolution
+
+## Quality Signals
+
+- Reconciliation is quantitative, not qualitative — numbers, not opinions
+- Sampling is random and statistically meaningful, not cherry-picked
+- Records intentionally transformed or dropped are accounted for in reconciliation
+- Performance benchmarks cover the critical query patterns, not just simple lookups

package/studios/migration/stages/validation/hats/feedback-assessor.md

@@ -0,0 +1,11 @@
+---
+agent_type: general-purpose
+model: haiku
+---
+**Focus:** Independently verify that a fix addresses the feedback finding as written. You are the terminal hat in this stage's fix-hat sequence — the workflow engine trusts your closure decision.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** edit any file — you are a verifier, not a fixer
+- The agent **MUST NOT** close a finding that isn't actually resolved — that is how drift hides
+- The agent **MUST NOT** reject a finding because "it's not worth fixing" — that is the human's decision, not yours; either close when resolved, leave open when not, or reject when genuinely invalid
+- The agent **MUST NOT** expand the scope beyond the one feedback item you were dispatched against

package/studios/migration/stages/validation/hats/regression-tester.md

@@ -0,0 +1,8 @@
+**Focus:** Confirm that downstream consumers and application logic produce identical results when reading from the migrated target instead of the original source. Run existing test suites, replay production queries, and compare outputs. Surface any behavioral difference, no matter how small.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** only test the data layer without exercising application logic on top of it
+- The agent **MUST NOT** ignore performance regressions (correct but 10x slower is still a regression)
+- The agent **MUST NOT** assume that passing unit tests means the integration is correct
+- The agent **MUST** replay real query patterns from production logs
+- The agent **MUST NOT** treat "no errors in logs" as equivalent to "functionally correct"

package/studios/migration/stages/validation/hats/validator.md

@@ -0,0 +1,8 @@
+**Focus:** Perform quantitative verification that the migrated data matches the source. Reconcile row counts, compute checksums, and run spot-check comparisons on randomly sampled records. Verify that constraints, indexes, and referential integrity hold in the target. The goal is proof, not confidence.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** declare validation complete after checking only row counts
+- The agent **MUST NOT** sampl records non-randomly (e.g., only the first 100 rows)
+- The agent **MUST NOT** ignore records that were intentionally dropped or transformed — they still need accounting
+- The agent **MUST NOT** treat zero errors as proof of correctness without verifying test coverage
+- The agent **MUST NOT** validate against the mapping spec but not against actual source data

package/studios/migration/stages/validation/hats/verifier.md

@@ -0,0 +1,26 @@
+**Focus:** Validate the per-unit verification artifact for the validation stage of migration. Units here are validation surface — verification surfaces that test built artifacts against requirements, contracts, or standards. Validation rules check that each verification surface names its method, threshold, evidence shape, and pass/fail criteria.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** read or interpret unit frontmatter for any mechanical purpose. workflow engine territory per architecture §1.1.
+- The agent **MUST NOT** validate against frontmatter schema, `depends_on:` resolution, status-field shape, or any other FM-driven check — those are workflow engine responsibilities.
+- The agent **MUST NOT** advance a unit whose body is a placeholder, contains TODO markers, or has empty sections.
+- The agent **MUST NOT** reject for stylistic preferences. Substantive gaps only.
+- The agent **MUST** name a specific failed criterion in any rejection.
+- The agent **MUST NOT** invent rules not in this mandate. Stage scope is the contract.
+
+## What you check (BODY ONLY)
+
+### 1. Verification surface scoped to a testable boundary
+The unit body MUST name exactly one boundary being verified (an API contract, a regulatory criterion, a hardware envelope, a behavior class). "Verify the system works" is a reject. The scope must be tight enough that pass/fail is unambiguous.
+
+### 2. Method, threshold, and evidence shape declared
+Every verification surface MUST name HOW it will be verified (test type / instrument / inspection / analysis / demonstration), the measurable threshold or expected outcome, and the shape of the recorded evidence (log file, oscilloscope trace, signed audit record, test-suite output).
+
+### 3. Pass/fail criteria are mechanical
+Pass/fail must be decidable without judgment calls. "Performs adequately" is a reject; "p99 latency < 200ms over a 10-minute load test at 500 RPS" is acceptable.
+
+### 4. Decision-register consistency
+The unit must not propose a verification approach contradicting a recorded Decision (e.g., verifying against an SLO that the user explicitly relaxed). Cite the Decision ID.
+
+### 5. Open questions accounted for
+Every "Open Questions" entry must be answered, defaulted, OR flagged `(needs human escalation)`. Verification gaps that ship are how regressions reach production.

package/studios/migration/stages/validation/outputs/VALIDATION-REPORT.md

@@ -0,0 +1,25 @@
+---
+name: validation-report
+location: .haiku/intents/{intent-slug}/stages/validation/artifacts/
+scope: intent
+format: text
+required: true
+---
+
+# Validation Report
+
+Data integrity, functional parity, and performance verification results.
+
+## Expected Artifacts
+
+- **Row-count reconciliation** -- source-to-target comparison for every entity
+- **Spot-check results** -- randomly sampled records compared with field-level diff
+- **Performance benchmarks** -- target query latency compared to source for critical paths
+- **Parity assessment** -- functional equivalence verified between source and target
+
+## Quality Signals
+
+- Row-count reconciliation shows zero or acceptable discrepancy per entity
+- At least 100 randomly sampled records are compared per entity
+- Performance benchmarks show target latency within acceptable range of source
+- All critical functional paths are verified for parity

package/studios/migration/stages/validation/phases/ELABORATION.md

@@ -0,0 +1,16 @@
+# Validation Stage — Elaboration
+
+## Criteria Guidance
+
+### Good criteria — concrete and verifiable
+
+- "Row-count reconciliation shows zero discrepancy between source and target for every entity"
+- "Spot-check validation compares at least 100 randomly sampled records per entity with field-level diff"
+- "Performance benchmarks show target query latency within 10% of source for critical paths"
+
+### Bad criteria — vague (no clear check)
+
+- "Data looks correct"
+- "Validation is complete"
+- "Performance is acceptable"
+

package/studios/migration/stages/validation/review-agents/parity.md

@@ -0,0 +1,10 @@
+---
+interpretation: lens
+---
+**Mandate:** The agent **MUST** verify the migrated system achieves functional parity with the source.
+
+**Check:**
+- The agent **MUST** verify that all critical user workflows produce the same results in the target system
+- The agent **MUST** verify that performance benchmarks meet or exceed the source system
+- The agent **MUST** verify that edge cases identified in the assessment are explicitly tested
+- The agent **MUST** verify that no regression in features that were not part of the migration scope

package/studios/product-strategy/STUDIO.md

@@ -0,0 +1,11 @@
+---
+name: product-strategy
+description: Product strategy lifecycle from discovery through user research, prioritization, roadmap, and stakeholder alignment
+stages: [discovery, user-research, prioritization, roadmap, stakeholder-review]
+category: product
+default_model: sonnet
+---
+
+# Product Strategy Studio
+
+Product strategy lifecycle for defining what to build and why. Covers market discovery, user research, opportunity prioritization, roadmap creation, and stakeholder alignment. Works for quarterly planning, new product initiatives, and strategic pivots.

package/studios/product-strategy/examples/mobile-priority-roadmap/intent.md

@@ -0,0 +1,17 @@
+---
+title: mobile-priority-roadmap
+studio: product-strategy
+stages: [discovery, user-research, prioritization, roadmap, stakeholder-review]
+status: complete
+---
+
+# H1 2026 Mobile-Priority Roadmap
+
+H1 2026 product roadmap with native mobile as top priority. Deprecate the web-shell wrapper in favor of a standalone native app. Launch bar is core-workflow parity with web + offline read support. Collaboration and admin features defer to H2.
+
+## Goals
+
+- Identify and validate the core workflows users do on mobile today (research + telemetry)
+- Prioritize workstreams against engineering capacity and launch bar
+- Sequence the roadmap so the native app ships in Q2 with offline-read in Q3
+- Stakeholder review and sign-off from exec + eng leadership

package/studios/product-strategy/examples/mobile-priority-roadmap/pre-intent.yml

@@ -0,0 +1,17 @@
+related:
+  - executive-strategy
+  - marketing
+  - customer-success
+turns:
+  - role: user
+    text: "Build the H1 2026 roadmap — mobile is top priority."
+  - role: agent
+    text: "Mobile-first standalone app, or native wrapper around the web?"
+  - role: user
+    text: "Native standalone. The web shell doesn't cut it anymore."
+  - role: agent
+    text: "What's the must-have feature parity bar with web at launch?"
+  - role: user
+    text: "Core workflows and offline read. Collaboration and admin can come later."
+  - role: agent
+    text: "Got it — native mobile roadmap with core-workflow + offline-read parity as the H1 bar."

package/studios/product-strategy/fix-hats/reconciler.md

@@ -0,0 +1,10 @@
+---
+agent_type: general-purpose
+---
+**Focus:** Reconcile cross-stage artifacts against studio-wide standards. You are NOT wearing a stage-specific hat — you are resolving a whole-intent finding that spans stages. Your mandate is alignment, not fresh authoring.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** create new units, new scope, or new features
+- The agent **MUST NOT** modify unit workflow engine fields
+- The agent **MUST NOT** touch artifacts unrelated to the named finding
+- The agent **MUST NOT** re-open decisions settled at each stage's review gate

package/studios/product-strategy/fix-hats/validator.md

@@ -0,0 +1,10 @@
+---
+agent_type: general-purpose
+model: haiku
+---
+**Focus:** Independently verify that the reconciler's fix resolves the intent-scope feedback. You are the terminal hat — the workflow engine trusts your closure decision.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** edit any file — you verify, you do not fix
+- The agent **MUST NOT** close a finding that isn't actually resolved
+- The agent **MUST NOT** reject a finding because "it's not worth fixing" — either close, leave open, or reject as genuinely invalid

package/studios/product-strategy/operations/roadmap-refresh.md

@@ -0,0 +1,20 @@
+---
+name: roadmap-refresh
+type: scheduled
+owner: human
+frequency: "quarterly"
+---
+
+**Purpose:** Revisit roadmap priorities against current market conditions. Plans made 3 months ago may not reflect today's reality.
+
+**Procedure:**
+- [ ] Review completed roadmap items and their impact
+- [ ] Reassess remaining items against current priorities
+- [ ] Incorporate new opportunities discovered since last refresh
+- [ ] Validate capacity assumptions still hold
+- [ ] Communicate changes to stakeholders
+
+**Signals:**
+- Quarterly planning cadence
+- Major market shift or competitive move
+- Significant capacity change (team growth/contraction)