kyzo

The review lens for judging any code, seal, or story against the storage architecture's caliber — not "did it pass the meter" but "is this the best it can be." Use when QA'ing a sealed task, assessing a story, or judging whether built code rises to decisions.md and the storage architecture. Not a checklist pass; a wisdom pass.

Ideal target-state file map for KyzoDB — where each seat lives and what it owns. Use before placing a construct, naming a file, choosing a zone, or judging whether code sits in the wrong place. Not current-tree inventory (read the tree) and not per-construct coding law (rust-* skills).

Create precise, high-context direction for LLMs as Q/A/E triplets — the hardest question, the ruled answer, the enforcement that makes it stick. Use when writing specs, rulings, migration destinies, agent priming, review standards, or any context where an LLM must make a choice exactly the way you would.

Gate whether a working set of atoms/clusters is closed under dependency edges (OPEN lists crossings). Use after organize-work when the border must be a real min-cut. Not organize-work. Not architecture-design.

Hoist all reads to session entry and sink all writes to session exit around a pure Decision middle. Use when a host/session path mixes IO with meaning. Not name-and-seat-construct. Not organize-work.

Name a construct's kind of truth and seat it in exactly one zone (KEEP or SPLIT). Use when placing or splitting a type/module/bag under zone law and future pressure. Not io-inversion. Not architecture-design. Not organize-work.

Partition stories/requirements into MECE clusters ordered by dependency. Use when re-slicing many items on wrong seams or turning planning smear into a build partition. Not closure-check (border gate). Not architecture-design. Not write-story.

Build the three plumbing constructs — composition root, config-once injection, sealed public door — the only places a kyzo binary or host assembles the engine and crosses its own public contract. Fires before writing main.rs or a CLI entrypoint, an env var read outside config, a host (kyzo-bin/kyzo-wasm) function that imports engine internals or caches results, or a runner/orchestrator/step-list function sequencing domain work by hand.

Fires when a kyzo boundary crossing is about to be hand-rolled instead of built as the matching construct in rust-adapters-success — unwrap/expect/panic! on external input, a hand-indexed byte parser with no bounds check or fuzz target, an unowned grammar rule, a second serialization path for a value that already has one, a reply-inspection function choosing a variant before ordered construction, or an untyped/unnamed refusal with no reason or span.

Fires when a kyzo value's binary order is about to be produced or compared wrong instead of via the matching construct in rust-order-success — a derived or hand-written Ord/Hash with no stated order law, an f32/f64 field in an ordered/stored type, a second discriminant competing with Tag, an evaluator importing a model type's Ord for query semantics, a sentinel value standing for "unbounded" or "none", or a released encoding changed with no FormatVersion decision.

Fires when kyzo mutable state or a live handle is about to land somewhere wrong instead of the matching construct in rust-state-success — a second capability handle converging the same state, RefCell/Mutex added to a single-owner struct as a borrow-checker workaround, a read/write or sealed/unsealed distinction enforced by a bool flag instead of a type split, a public raw constructor for an interned code, a code/row/column serialized past its epoch, or an unfinished protocol (open transaction, held lock) with no Drop-bound release.

Fires when kyzo domain data is about to be shaped wrong instead of as the matching construct in rust-values-success — a bare primitive field, a pub field on a would-be newtype, an unproven Vec/HashMap, an Option<T> standing for meaningful absence, a String-typed kind/status field, a match/if-let ladder re-deriving a sum type's own fact, a HashMap backing a domain collection, a bool encoding a domain decision, or a field the ontology never declared.

Fires when kyzo behavior is about to be written wrong instead of as the matching construct in rust-verbs-success — a free function computing from a struct's fields from outside the type, a &mut self method mutating nested state in place instead of reassigning it, a sealed/committed bool flag policing a lifecycle the type system should enforce, unwrap/expect/panic! or Option/bool standing in for a typed Result refusal on a reachable input, or a stub method body (todo!()/unimplemented!()).

Fires when kyzo plumbing is about to be written wrong instead of as the matching construct in rust-wiring-success — an env var read outside the config struct, a runner/orchestrator/step-list function sequencing domain work by hand in an entrypoint, a host crate importing engine internals, a host-side cache or shadow state the engine can't account for, or unwrap/expect on a request path.

Build the four boundary-crossing constructs — boundary decode, owned parse rule, wire envelope, ordered TryFrom lift — the only shapes for data crossing into or out of the kyzo engine. Fires before touching bytes from disk, a network request, a foreign file format, or an FFI/WASM boundary; before writing a parser or grammar rule with no typed owner; or before writing unwrap/expect on external input, a hand-rolled byte-indexing parser, or an untyped String error at a boundary.

Build the one law's compare/encode authority — identity-and-order-before-bytes, the Tag prefix doctrine, structural vs query-semantic order, and unbounded-as-variant — the only place a kyzo value's binary order is allowed to originate. Fires before deriving or hand-writing Ord/PartialOrd/Hash on a domain type, before adding or changing a value kind's byte encoding, before introducing a second cross-type discriminant, before writing a sentinel value (i64::MAX, -1, empty string) to mean "unbounded" or "none", or before an evaluator borrows a model type's Ord for query-semantic comparison.

Build kyzo's zone-native live-state constructs — capability handle, species pair, building-to-sealed lifecycle, epoch-scoped currency, drop-bound resource — the only shapes mutable state and transport/storage handles are allowed to take. Fires before holding a cursor, transaction, lock, or client as a struct field; before writing a manager/engine/service struct with an interior-mutability field added ad hoc; before writing a reader/writer pair with the invariant checked at runtime; before letting an index answer a search before it's finished building; or before an interned code, row, or column that might outlive its evaluation epoch.

Build the five proven shapes for a kyzo domain fact — newtype scalar, value object, concept struct, proven collection, sum type — the only representations for data inside the engine. Fires before writing a bare primitive field, a pub field on a would-be newtype, a struct composing raw primitives, a Vec<T>/HashMap<K,V> field, an Option<T> field standing for a meaningful absence, a String-typed kind/status field, or a match/if-let chain selecting behavior by an unproven discriminant.

Build the four behavior constructs — derivation, transition, consuming verb, total refusal — the only legal method shapes in kyzo engine code. Fires before writing a free function that computes from a struct's fields, a &mut self method that mutates a field in place instead of reassigning it, a method returning Option or panicking/unwrapping on a reachable input instead of Result with a named reason and span, a self-by-value method with no reason ownership is taken, or a sealed/committed bool flag.

optimizes content

Governs how you approach building anything. Use when the task is to design, architect, build, implement, or plan a program, system, feature, module, data model, or workflow. Trigger the moment you are about to write a numbered plan, an implementation checklist, a "first X then Y" sequence, or a build order. Also trigger on "plan how to build," "outline the steps," "design the flow," "figure out the order of operations," or "what's the approach." Apply it even when the user only describes a system and expects code: the correct first move is to model the domain, not sequence work.

Investigate before answering questions about the current program or repository. Use when the user asks how code works, why behavior occurs, whether something exists, where logic lives, what a construct means, or any question whose answer can be verified by reading or searching the code. Inspect the relevant sources and resolve unknowns before answering. Do not substitute general software knowledge, speculation, praise, or introductory exposition for investigation.

Mandatory requirements for developing evals in Phoenix Arize. The primary purpose of Phoenix is VISUAL consumption of information by people.

forge skill yaml description fields for claude code routing. use when drafting, shortening, or auditing metadata that must distinguish a skill from nearby skills, remove filler or duplicated trigger language, prevent overbroad activation, and return a revised description with a deletion note.

derive the max-purity design for a zone or construct from the product telos before reading any code, then judge existing code or a proposal as distance from that design. use when seating or minting a construct, ruling which zone owns a truth, choosing between engineering approaches mid-build, or judging whether legacy code, a new-seat proposal, or an exposed behavior is deliberate design or inherited accident. not for looking up an already-ruled seat (architecture-map) or writing the story that carries the work (write-story).