haiku-method 2.2.0

package/studios/legal/stages/review/STAGE.md

@@ -0,0 +1,19 @@
+---
+name: review
+description: Conduct legal review and compliance check
+hats: [reviewer, compliance-officer, verifier]
+fix_hats: [reviewer, feedback-assessor]
+review: external
+elaboration: autonomous
+inputs:
+  - stage: draft
+    output: draft-document
+  - stage: research
+    discovery: research-memo
+  - stage: intake
+    discovery: legal-brief
+---
+
+# Review
+
+Conduct legal review and compliance check.

package/studios/legal/stages/review/discovery/REVIEW-FINDINGS.md

@@ -0,0 +1,29 @@
+---
+name: review-findings
+location: .haiku/intents/{intent-slug}/knowledge/REVIEW-FINDINGS.md
+scope: intent
+format: text
+required: true
+---
+
+# Review Findings
+
+Legal review results with categorized findings, compliance assessment, and remediation recommendations.
+
+## Content Guide
+
+Structure findings for efficient document revision:
+
+- **Findings summary** -- overview of review results with issue counts by severity
+- **Critical findings** -- must-fix issues that affect enforceability or create material risk
+- **Important findings** -- should-fix issues that improve protection or clarity
+- **Advisory findings** -- optional improvements for consideration
+- **Compliance assessment** -- regulatory requirement mapping with gap analysis
+- **Risk opinion** -- residual risk assessment for each identified exposure
+
+## Quality Signals
+
+- Findings are categorized by severity with clear remediation guidance
+- Compliance mapping shows which provisions satisfy which requirements
+- Risk opinion quantifies residual risk rather than using vague characterizations
+- Every critical finding has a specific remediation recommendation

package/studios/legal/stages/review/hats/compliance-officer.md

@@ -0,0 +1,13 @@
+**Focus:** Verify the document complies with all applicable regulations across relevant jurisdictions.
+
+**Responsibilities:**
+- Map each regulatory requirement to the specific provision that satisfies it
+- Identify compliance gaps with specific remediation recommendations
+- Verify jurisdiction-specific requirements are addressed
+- Assess the document against current regulatory enforcement trends
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** check compliance against a generic list without considering jurisdiction specifics
+- The agent **MUST NOT** approve compliance without documenting the mapping between requirements and provisions
+- The agent **MUST NOT** ignore recent regulatory changes or enforcement actions
+- The agent **MUST NOT** treat compliance as a checkbox exercise rather than substantive analysis

package/studios/legal/stages/review/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/legal/stages/review/hats/reviewer.md

@@ -0,0 +1,16 @@
+---
+interpretation: lens
+---
+**Focus:** Conduct substantive legal review of the draft document to ensure it achieves the stated legal objectives and protects the organization's interests.
+
+**Responsibilities:**
+- Review each provision for legal sufficiency and enforceability
+- Identify provisions that create unintended obligations or exposures
+- Verify the document achieves the objectives stated in the legal brief
+- Categorize findings by severity (critical, important, advisory)
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** perform only a surface review without analyzing legal implications
+- The agent **MUST NOT** identify issues without providing specific remediation recommendations
+- The agent **MUST NOT** approve documents without verifying they address all identified risks
+- The agent **MUST NOT** focus on minor style issues while missing substantive legal problems

package/studios/legal/stages/review/hats/verifier.md

@@ -0,0 +1,26 @@
+**Focus:** Validate the per-unit operational artifact for the review stage of legal. Units here are review decision — operational steps with concrete preconditions, actions, and post-condition checks. Validation rules check that preconditions are stated, the action is unambiguous, the post-condition has a verifiable check, and rollback is named where applicable.
+
+**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. Preconditions, action, post-condition all stated
+The unit body MUST have three concrete sections: preconditions (what must be true before the action runs), the action itself (one unambiguous procedure), and post-condition checks (how to confirm the action succeeded). Reject if any of the three is missing or vague.
+
+### 2. Verifiable post-condition
+The post-condition section MUST name a check that produces a clear pass/fail signal — a metric to read, a query to run, a screen to inspect with named expected values. "Verify by eye that things look good" is a reject.
+
+### 3. Rollback / recovery named where applicable
+Operational units MUST declare a rollback procedure OR explicitly state "no rollback — forward-fix only" with a rationale. Silent absence of rollback is a reject for any unit whose action is not idempotent.
+
+### 4. Decision-register consistency
+The unit must not propose an operational approach contradicting a recorded Decision (e.g., blue-green deploy when Decision N chose canary). Cite the Decision ID.
+
+### 5. Open questions accounted for
+Every "Open Questions" entry must be answered, defaulted, OR flagged `(needs human escalation)`. Operational open questions left to runtime are how outages happen.

package/studios/legal/stages/review/outputs/REVIEW-FINDINGS.md

@@ -0,0 +1,25 @@
+---
+name: review-findings
+location: .haiku/intents/{intent-slug}/stages/review/artifacts/
+scope: intent
+format: text
+required: true
+---
+
+# Review Findings
+
+Legal review results with categorized issues, compliance mapping, and risk opinion.
+
+## Expected Artifacts
+
+- **Categorized findings** -- each issue rated as critical (must fix), important (should fix), or advisory (consider)
+- **Compliance mapping** -- each regulatory requirement mapped to the draft provision that satisfies it
+- **Gap analysis** -- regulatory requirements not adequately addressed in the draft
+- **Risk opinion** -- residual risk quantified for each exposure with acceptance or mitigation recommendation
+
+## Quality Signals
+
+- Findings are categorized by severity with specific remediation guidance
+- Compliance check maps every regulatory requirement to a draft provision
+- Gap analysis identifies unaddressed requirements
+- Risk opinion quantifies residual risk with clear recommendations

package/studios/legal/stages/review/phases/ELABORATION.md

@@ -0,0 +1,16 @@
+# Review Stage — Elaboration
+
+## Criteria Guidance
+
+### Good criteria — concrete and verifiable
+
+- "Review findings document categorizes each issue as critical (must fix), important (should fix), or advisory (consider)"
+- "Compliance check maps each regulatory requirement to the specific draft provision that satisfies it, with gap analysis"
+- "Risk opinion quantifies residual risk for each identified exposure with recommended acceptance or mitigation"
+
+### Bad criteria — vague (no clear check)
+
+- "Review is complete"
+- "Document is compliant"
+- "Issues are noted"
+

package/studios/legal/stages/review/review-agents/risk-coverage.md

@@ -0,0 +1,10 @@
+---
+interpretation: lens
+---
+**Mandate:** The agent **MUST** verify all identified risks are adequately addressed and compliance requirements are met.
+
+**Check:**
+- The agent **MUST** verify that every risk from the intake assessment has a corresponding protective provision or documented risk acceptance
+- The agent **MUST** verify that compliance mapping covers all applicable regulations with specific provision references
+- The agent **MUST** verify that review findings are categorized by severity with actionable remediation guidance
+- The agent **MUST** verify that no material compliance gaps remain unaddressed

package/studios/libdev/STUDIO.md

@@ -0,0 +1,15 @@
+---
+name: library-development
+slug: libdev
+description: Lifecycle for libraries, SDKs, and CLI tools
+stages: [inception, development, security, release]
+category: engineering
+default_model: sonnet
+---
+
+# Library Development
+
+Lifecycle for libraries, SDKs, and CLI tools. Differs from application
+development: no product or design phases — inception directly covers discovery
+and API surface (semver policy, public contract, extension points), development
+builds against that contract, and release publishes rather than deploys.

package/studios/libdev/examples/retry-middleware-lib/intent.md

@@ -0,0 +1,18 @@
+---
+title: retry-middleware-lib
+studio: libdev
+stages: [inception, development, security, release]
+status: complete
+---
+
+# Retry Middleware Library
+
+Extract the in-house retry logic into a standalone open-source middleware library for Node and Bun runtimes. Default strategy is exponential backoff with decorrelated jitter; users can plug custom strategies via interface.
+
+## Goals
+
+- Node + Bun support; no Deno in initial release
+- Decorrelated-jitter exponential backoff as the default strategy
+- Pluggable strategy interface with at least 3 built-ins (fixed, exponential, decorrelated-jitter)
+- 100% branch coverage, fuzz-tested failure injection
+- Semver 1.0.0 release with migration notes from the internal version

package/studios/libdev/examples/retry-middleware-lib/pre-intent.yml

@@ -0,0 +1,17 @@
+related:
+  - software
+  - documentation
+  - security-assessment
+turns:
+  - role: user
+    text: "Extract our retry logic into an open-source middleware library."
+  - role: agent
+    text: "Which runtimes — Node only, or also Bun and Deno?"
+  - role: user
+    text: "Node and Bun. Skip Deno for now."
+  - role: agent
+    text: "Backoff strategies — exponential, decorrelated jitter, user-defined?"
+  - role: user
+    text: "Exponential with decorrelated jitter as the default. Let users plug their own."
+  - role: agent
+    text: "Got it — Node + Bun, decorrelated-jitter default, pluggable strategies."

package/studios/libdev/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/libdev/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/libdev/review-agents/cross-stage-consistency.md

@@ -0,0 +1,17 @@
+---
+scope: intent
+interpretation: lens
+---
+**Mandate:** Verify the intent's artifacts are internally consistent across stages. You are the only reviewer that sees the whole intent at once — your job is to catch seams that per-stage reviewers miss.
+
+**Check:**
+- The agent **MUST** verify that each stage's outputs align with what upstream stages specified — no dropped requirements, no silent scope expansion
+- The agent **MUST** verify that naming is consistent across stages — a concept named one thing upstream should carry the same name downstream
+- The agent **MUST** verify that stages' declared outputs exist at the paths their unit frontmatter promised
+- The agent **MUST** verify that the stages collectively deliver the intent's stated goal (read `intent.md`) — partial delivery is a finding
+- The agent **MUST** verify that concerns raised by any stage's review were actually addressed (not silently ignored)
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** re-litigate decisions already approved at each stage's gate
+- The agent **MUST NOT** propose new features or scope additions
+- The agent **MUST NOT** flag stylistic preferences — concrete divergence only

package/studios/libdev/stages/development/STAGE.md

@@ -0,0 +1,20 @@
+---
+name: development
+description: Implement the library against the API contract from inception
+hats: [planner, builder, reviewer]
+fix_hats: [builder, feedback-assessor]
+review: [external, ask]
+elaboration: collaborative
+inputs:
+  - stage: inception
+    discovery: discovery
+  - stage: inception
+    discovery: api-surface
+---
+
+# Development
+
+Implement the library against the public API surface defined in inception.
+Public API stability is a hard constraint — any change that breaks the
+contract requires explicit review and a semver bump. Internal refactoring is
+free; public signature changes are not.

package/studios/libdev/stages/development/hats/builder.md

@@ -0,0 +1,8 @@
+**Focus:** Implement the library to match the API surface exactly. Write code AND the tests that prove the contract holds. Public behavior is load-bearing — if the implementation doesn't match the documented surface, consumers will break when they upgrade.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** deviate from the API surface signatures — if the signature needs to change, flag it for review and don't proceed
+- The agent **MUST** write tests that exercise the public API, not internal helpers
+- The agent **MUST** preserve the documented error model — error types are part of the contract
+- The agent **MUST NOT** introduce new public exports not in the API surface
+- The agent **MUST** keep internal-only symbols clearly marked (underscored, internal namespace, etc.)

package/studios/libdev/stages/development/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/libdev/stages/development/hats/planner.md

@@ -0,0 +1,7 @@
+**Focus:** Plan how to implement the library against the API surface defined in inception. Sequence the work so public-facing primitives are built first (they're the hardest to change later) and internal implementation follows.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** propose changes to the API surface at this stage — that contract is fixed
+- The agent **MUST** plan the public surface implementation before internal helpers
+- The agent **MUST** identify test strategy upfront, not defer it
+- The agent **MUST NOT** add dependencies not listed as acceptable in discovery

package/studios/libdev/stages/development/hats/reviewer.md

@@ -0,0 +1,10 @@
+---
+interpretation: lens
+---
+**Focus:** Review the implementation against the API surface and the completion criteria. The reviewer catches contract drift — places where the code "works" but doesn't match what was promised in inception.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** pass a unit where the implementation exports symbols not in the API surface
+- The agent **MUST NOT** pass a unit where error handling diverges from the documented error model
+- The agent **MUST** explicitly check tests cover the public API entry points
+- The agent **MUST NOT** approve code that depends on internal symbols from other parts of the library (layering violations)

package/studios/libdev/stages/development/outputs/CODE.md

@@ -0,0 +1,29 @@
+---
+name: code
+location: (project source tree)
+scope: repo
+format: code
+required: true
+---
+
+# Code
+
+Library implementation output — code and tests written directly to the project source tree. This is not a document; it is the working library that satisfies the API surface contract and unit completion criteria.
+
+## Content Guide
+
+- **Match the API surface exactly** — every exported symbol's signature and error model
+- **Write tests against the public API** — tests should look like consumer code, not internal inspection
+- **Keep internal symbols clearly internal** — naming conventions, export gates, or language-specific visibility
+- **Follow ecosystem idioms** — use the language's conventional patterns for libraries (e.g., Node.js package structure, Python packaging, Rust crate layout)
+
+## Completion
+
+Complete when all unit completion criteria pass verification, the reviewer approves, and `api-compatibility` confirms no unintended breaking changes.
+
+## Quality Signals
+
+- Public API matches the inception-phase API Surface document exactly
+- Tests exercise every declared public entry point and error path
+- Internal symbols are not accessible or re-exported by accident
+- Code follows language/ecosystem idioms for libraries

package/studios/libdev/stages/development/review-agents/api-compatibility.md

@@ -0,0 +1,11 @@
+---
+interpretation: lens
+---
+**Mandate:** The agent **MUST** verify the implementation does not introduce breaking changes to the public API surface relative to what was declared in inception.
+
+**Check:**
+- The agent **MUST** verify no public symbol was removed or renamed
+- The agent **MUST** verify no public signature was changed (parameter added, type narrowed, return type widened)
+- The agent **MUST** verify no error type was added or removed from the documented error model
+- The agent **MUST** flag any behavior change to an existing public entry point that would be observable to consumers (stricter validation, changed default, different ordering, etc.)
+- The agent **MUST** require an explicit semver impact note if any of the above are present

package/studios/libdev/stages/development/review-agents/correctness.md

@@ -0,0 +1,10 @@
+---
+interpretation: lens
+---
+**Mandate:** The agent **MUST** verify the implementation matches the API surface contract and the unit completion criteria.
+
+**Check:**
+- The agent **MUST** verify every exported symbol matches the API surface signature (name, parameters, return type)
+- The agent **MUST** verify the error model matches: error types thrown match what the surface declares
+- The agent **MUST** verify no public symbol exists that's not declared in the API surface
+- The agent **MUST** verify all completion criteria have verification commands that pass

package/studios/libdev/stages/development/review-agents/test-quality.md

@@ -0,0 +1,10 @@
+---
+interpretation: lens
+---
+**Mandate:** The agent **MUST** verify tests actually exercise the public API in representative ways.
+
+**Check:**
+- The agent **MUST** verify tests call the public API the way consumers would (not through internal backdoors)
+- The agent **MUST** verify tests cover each error path declared in the API surface
+- The agent **MUST** verify tests cover edge cases for every public entry point (empty inputs, boundary values, type edge cases)
+- The agent **MUST** flag tests that are tightly coupled to internal implementation and would break under legitimate refactoring

package/studios/libdev/stages/inception/STAGE.md

@@ -0,0 +1,16 @@
+---
+name: inception
+description: Understand the problem, define API surface, and elaborate into units
+hats: [researcher, api-architect, distiller, verifier]
+fix_hats: [researcher, feedback-assessor]
+review: ask
+elaboration: collaborative
+inputs: []
+---
+
+# Inception
+
+Library inception covers both discovery (what problem does this solve, who are the target consumers, what's the competitive landscape) AND API shape
+(public surface, semver policy, extension points, error model). Unlike
+application development there is no separate product or design phase — API
+decisions are made here because the API *is* the product.

package/studios/libdev/stages/inception/discovery/API-SURFACE.md

@@ -0,0 +1,43 @@
+---
+name: api-surface
+location: .haiku/intents/{intent-slug}/knowledge/API-SURFACE.md
+scope: intent
+format: text
+required: true
+---
+
+# API Surface
+
+The public contract this library exposes to consumers. Once published, changes to this surface are breaking changes. This document is the canonical reference for what consumers can depend on.
+
+## Content Guide
+
+### Public Entry Points
+- **Every exported symbol** — functions, classes, types, constants, modules
+- **Signatures** — full type signatures for every public symbol (parameters, return types, throws)
+- **Purpose** — one-line description of what each entry point is for
+
+### Error Model
+- **Error mechanism** — how errors are surfaced (exceptions, result types, error callbacks, sentinel values)
+- **Error classes/codes** — complete enumeration of error types consumers may encounter
+- **Error stability** — which error types are part of the public contract (and thus breaking to change)
+
+### Extension Points
+- **Customization hooks** — how consumers extend or customize behavior (plugins, middleware, subclassing, config)
+- **Stability of extension points** — which extension points are stable vs. experimental
+
+### Semver Policy
+- **What constitutes a breaking change** — signature changes are obvious; behavioral changes, new required parameters, stricter validation, and error-type changes all count
+- **Deprecation policy** — how long deprecated APIs remain before removal
+
+### Stability Tiers
+- **Stable** — full semver guarantees
+- **Experimental** — subject to change without major version bump, opt-in only
+- **Internal** — not part of public contract, consumers must not depend on
+
+## Quality Signals
+
+- Every exported symbol is documented with full type signature
+- Error model is complete — consumers know every error they can receive
+- Extension points are explicit about stability
+- Semver policy answers "is X a breaking change?" for non-obvious cases

package/studios/libdev/stages/inception/discovery/DISCOVERY.md

@@ -0,0 +1,41 @@
+---
+name: discovery
+location: .haiku/intents/{intent-slug}/knowledge/DISCOVERY.md
+scope: intent
+format: text
+required: true
+---
+
+# Discovery
+
+Comprehensive understanding of the problem this library solves, who consumes it, and the ecosystem context. This is the foundation for all downstream libdev stages.
+
+## Content Guide
+
+### Problem & Consumers
+- **Problem statement** — what consumers cannot do today without this library, framed in consumer terms
+- **Target consumers** — who integrates this library, at what technical level, in what context (backend service, CLI, SDK, etc.)
+- **Adoption path** — how a new consumer discovers, evaluates, installs, and first uses the library
+
+### Ecosystem Landscape
+- **Existing libraries** — specific named competitors with a brief description of their approach
+- **What works in existing libraries** — patterns worth adopting
+- **Gaps in existing libraries** — where competitors fall short that this library addresses
+
+### Scope
+- **Goals** — what this library explicitly does
+- **Non-goals** — what this library explicitly will NOT do, to prevent scope creep
+- **Out of scope for v1** — things deferred to later versions
+
+### Non-functional Requirements
+- **Language/runtime** — target language, minimum version, supported platforms
+- **Dependencies** — what dependencies are acceptable, which to avoid (heavy, abandoned, incompatible licenses)
+- **Performance expectations** — if relevant, order-of-magnitude targets
+- **Documentation expectations** — how consumers will learn the library
+
+## Quality Signals
+
+- A consumer unfamiliar with the intent can understand why this library should exist and who it's for
+- Competitor libraries are named with links, not described abstractly
+- Non-goals are explicit and specific
+- Target consumers are concrete (e.g., "Node.js backend devs building REST APIs") not generic ("developers")

package/studios/libdev/stages/inception/hats/api-architect.md

@@ -0,0 +1,8 @@
+**Focus:** Design the public API surface — the contract that consumers will depend on. This is load-bearing work because once published, changing the public surface breaks every consumer. Decisions here set the semver policy and dictate how painful every future release will be.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** design internal implementation details — only what consumers will see
+- The agent **MUST NOT** expose framework primitives that leak into consumer code (e.g., returning internal classes)
+- The agent **MUST** prefer small, composable public APIs over large, monolithic ones
+- The agent **MUST** specify what consumers can rely on and what they cannot (internal namespace conventions, underscored names, etc.)
+- The agent **MUST NOT** design for hypothetical future consumers — design for the users identified in discovery

package/studios/libdev/stages/inception/hats/distiller.md

@@ -0,0 +1,7 @@
+**Focus:** Decompose the intent into verifiable units. Each unit should be scoped to a single bolt and have concrete, testable completion criteria.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** create units with vague criteria like "implementation complete"
+- The agent **MUST** ensure the unit DAG is acyclic
+- The agent **MUST** scope each unit to a single bolt
+- The agent **MUST NOT** skip API surface units — consumers depend on that contract

package/studios/libdev/stages/inception/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/libdev/stages/inception/hats/researcher.md

@@ -0,0 +1,7 @@
+**Focus:** Understand the problem this library solves, who consumes it, and what the competitive landscape looks like in this ecosystem. Libraries live or die by adoption — establish who will use it, why they'd pick it over alternatives, and what consumer experience the library needs to deliver.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** propose the API surface here — that's the api-architect's job
+- The agent **MUST NOT** skip ecosystem survey — libraries fail most often by ignoring what consumers already use
+- The agent **MUST** ground the discovery in real consumer needs, not hypothetical users
+- The agent **MUST** identify non-goals explicitly — scope creep kills libraries

package/studios/libdev/stages/inception/hats/verifier.md

@@ -0,0 +1,27 @@
+**Focus:** Validate the per-unit knowledge artifact for library inception. Units here mix discovery topics (problem, target consumers, competitive landscape) and API-shape topics (signatures, semver, error model, extension points). Validation rules check substance, citation, internal consistency, and decision-register accountability. NOT executable verify-commands or DAG validity.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** read or interpret unit frontmatter. workflow engine territory.
+- The agent **MUST NOT** validate against execution-spec rules.
+- The agent **MUST NOT** advance a unit with placeholders or empty sections.
+- The agent **MUST** name a specific failed criterion in any rejection.
+
+## What you check (BODY ONLY)
+
+### 1. Artifact answers its topic
+The body MUST deliver substantive content on the unit's stated topic. For API-surface units, "substantive" means: every exported function/type has its full signature AND a one-paragraph rationale. For discovery units, substantive means: actual analysis with sources, not an outline.
+
+### 2. Sources cited (discovery topics) / Rationale cited (API-shape topics)
+- Discovery units: non-trivial claims (competitor library popularity, API style choices in the ecosystem, install-size benchmarks) MUST cite npm registry data, GitHub stars/issues, official docs, etc.
+- API-shape units: every signature decision MUST have a rationale paragraph explaining why that shape over alternatives. Reject "API is good" without justification.
+
+### 3. Internal consistency
+- API surface MUST NOT introduce types/functions inconsistent with the project's existing public surface (unless explicitly intentional and documented).
+- Semver classification MUST match the surface change being introduced (a new required parameter on an existing public function is `major`, not `minor`).
+- Mission and body content must align.
+
+### 4. Decision-register consistency
+The unit must not propose an API shape contradicting a recorded Decision (e.g., "use callbacks" when Decision N chose "use Promises"). Cite the Decision ID.
+
+### 5. Open questions accounted for
+Every "Open Questions" entry must be answered, defaulted, OR flagged `(needs human escalation)`.

package/studios/libdev/stages/inception/outputs/KNOWLEDGE.md

@@ -0,0 +1,24 @@
+---
+name: knowledge
+location: .haiku/intents/{intent-slug}/knowledge/
+scope: intent
+format: directory
+required: false
+---
+
+# Knowledge
+
+Supporting research and notes gathered during inception that inform downstream stages but aren't the canonical discovery or API surface documents. Stored in the intent's `knowledge/` directory.
+
+## Content Guide
+
+Typical contents:
+- **Competitor research** — deeper dives into specific competing libraries
+- **Ecosystem conventions** — language-specific patterns the library should follow
+- **Prototype notes** — quick experiments or spikes that informed API decisions
+- **Open questions** — things raised during inception that need resolution in development
+
+## Quality Signals
+
+- Notes are dated and attributed when sourced externally
+- Open questions are tracked with owner and resolution target