agent-skill-kit 3.9.135

package/.agent/skills/code-constitution/rules/doctrines/architecture/architecture-doctrine.md

@@ -0,0 +1,188 @@
+---
+name: architecture-doctrine
+version: "3.9.134"
+status: LOCKED
+authority: CONSTITUTIONAL
+parent: master-constitution
+---
+
+# 🏛️ PikaKit Architecture Doctrine  
+**(System Architecture & Boundary Law)**
+
+This doctrine defines the **architectural laws** governing how PikaKit is
+structured, scaled, and evolved.
+
+Architecture exists to:
+- Prevent silent data corruption
+- Prevent system-wide inconsistency
+- Prevent “working but wrong” systems
+
+If architecture is violated,  
+the system may appear functional — **but it is already broken**.
+
+---
+
+## 1. Architectural Intent
+
+PikaKit is a **data-trust platform**, not a feature-driven application.
+
+The architecture prioritizes:
+- Correctness over speed
+- Predictability over flexibility
+- Explicit ownership over convenience
+
+Any design that obscures ownership  
+is architecturally invalid.
+
+---
+
+## 2. System Boundary Law (NON-NEGOTIABLE)
+
+The system is divided into **strict, enforceable boundaries**:
+
+### Backend
+- Source of truth
+- Data ingestion and normalization
+- Persistence and aggregation
+- Cost, rate-limit, and integrity control
+
+### Frontend
+- Rendering and presentation
+- User interaction
+- Visual state only
+- NO truth ownership
+
+### External Systems
+- Untrusted dependencies
+- Volatile availability
+- Never authoritative
+
+Crossing these boundaries **without mediation**
+is an architectural violation.
+
+---
+
+## 3. Single Source of Truth Law
+
+Every piece of **critical data** MUST have:
+
+- One authoritative owner
+- One normalization path
+- One persistence strategy
+
+Multiple truths are worse than missing data.
+
+Client-side arbitration of truth  
+is strictly forbidden.
+
+---
+
+---
+
+## 4. Dependency Direction Law
+
+Dependencies MUST flow **inward** toward the core:
+External Services
+        ↓
+     Backend
+        ↓
+     Frontend
+
+The frontend MUST NEVER:
+- Depend directly on external APIs (production)
+- Reconstruct backend meaning
+- Patch missing data
+
+If the frontend can “fix” backend data,  
+the architecture is invalid.
+
+---
+
+## 5. Scalability Invariants
+
+Scalability is a **first-order architectural property**,  
+not a later optimization.
+
+The system MUST:
+- Scale users independently of external dependencies
+- Absorb traffic spikes without amplification
+- Fail gracefully under partial outages
+- Preserve data correctness under load
+
+If scaling requires architectural rewrite,  
+the original design is invalid.
+
+---
+
+## 6. Evolution Without Erosion Law
+
+Architecture may evolve,  
+but MUST NOT erode.
+
+### Allowed Evolution
+- Additive extensions
+- Explicit migrations
+- Backward-compatible improvements
+
+### Forbidden Evolution
+- Layering exceptions
+- Feature-driven shortcuts
+- “Temporary” architecture without removal plans
+- Accumulating special cases
+
+Erosion is failure by accumulation.
+
+---
+
+## 7. Architectural Anti-Patterns (ZERO TOLERANCE)
+
+The following are considered **architectural violations**:
+
+- Blurred or shared data ownership
+- Feature-specific architecture
+- Client-side truth decisions
+- Hidden coupling between layers
+- Implicit contracts
+- Architecture that relies on “tribal knowledge”
+
+These patterns must be **rejected**, not mitigated.
+
+---
+
+## 8. Enforcement Rule
+
+Any design or implementation that:
+
+- Violates a system boundary
+- Obscures data ownership
+- Introduces implicit coupling
+- Requires special context to be safe
+
+**MUST be rejected**, regardless of delivery pressure.
+
+---
+
+## Final Authority
+
+This doctrine overrides:
+- Feature requirements
+- Framework defaults
+- Tooling constraints
+- Short-term optimization goals
+
+PikaKit architecture exists to protect:
+
+**Long-term trust · Correctness · Scalability**
+
+Not developer convenience.
+
+---
+
+**Status:** LOCKED  
+**Version:** 1.0.0  
+**Parent:** PikaKit Master Constitution  
+**Override Permission:** NONE
+
+---
+
+⚡ PikaKit v3.9.134

package/.agent/skills/code-constitution/rules/doctrines/backend/backend-data-engine-doctrine.md

@@ -0,0 +1,218 @@
+---
+name: backend-data-engine-doctrine
+version: "3.9.134"
+status: LOCKED
+authority: CONSTITUTIONAL
+parent: architecture-doctrine
+---
+
+# 🧱 PikaKit Backend Data Engine Doctrine  
+**(Data Truth · Ingestion · Persistence Law)**
+
+This doctrine defines the **backend data engine laws** governing how PikaKit
+ingests, normalizes, persists, caches, and serves data.
+
+The backend is **NOT** an API relay.  
+The backend is a **data truth engine**.
+
+If backend authority is bypassed,  
+the system is **COMPROMISED** — even if it appears functional.
+
+---
+
+## 1. Data Engine Purpose
+
+The backend exists to protect:
+
+- Data correctness
+- Historical integrity
+- Cost and rate limits
+- Deterministic behavior
+- Long-term scalability
+
+The backend is the **only layer** allowed to interpret external data.
+
+---
+
+## 2. Truth Ownership Law (NON-NEGOTIABLE)
+
+The backend is the **single authoritative owner** of:
+
+- External data ingestion
+- Normalization and aggregation
+- Validation and correction
+- Persistence and storage
+- Cache and freshness policy
+
+The frontend MUST NEVER:
+
+- Call third-party APIs directly (production)
+- Normalize or aggregate raw data
+- Guess, synthesize, or “fix” missing values
+- Persist authoritative data
+
+Any violation is a **DATA INTEGRITY BREACH**.
+
+---
+
+## 3. External Dependency Isolation Law
+
+All third-party data sources MUST be:
+
+- Isolated behind backend APIs
+- Rate-limited centrally
+- Cached and buffered
+- Replaceable without frontend changes
+
+External systems are treated as:
+
+- Unreliable
+- Rate-limited
+- Non-authoritative
+
+They are **inputs**, never system components.
+
+---
+
+## 4. Ingestion Taxonomy Law
+
+All ingestion MUST be explicitly classified.  
+Unclassified ingestion is **FORBIDDEN**.
+
+### 4.1 Backfill Ingestion
+
+- One-time or rare execution
+- Writes immutable historical data
+- Fully auditable and traceable
+- NEVER overwritten
+
+### 4.2 Incremental / Scheduled Ingestion
+
+- Periodic execution
+- Append-only or deterministic overwrite
+- Idempotent by design
+- Safe to retry
+
+### 4.3 Realtime Ingestion
+
+- Ephemeral and transient
+- MUST NEVER be persisted as history
+- Used only for live indicators
+- Discarded after use
+
+Mixing ingestion categories  
+is a **HARD VIOLATION**.
+
+---
+
+## 5. Persistence & Immutability Law
+
+Historical data:
+
+- MUST be immutable once written
+- MUST NOT be smoothed or interpolated
+- MUST NOT be retroactively edited
+
+Corrections MUST occur via:
+
+- Append-only records
+- Explicit correction events
+
+Silent mutation is considered **DATA CORRUPTION**.
+
+---
+
+## 6. Caching & Cost Control Law
+
+Caching is **NOT** an optimization.  
+Caching is a **cost, stability, and safety mechanism**.
+
+The backend MUST:
+
+- Serve cached data by default
+- Refresh data asynchronously
+- Prevent cache stampedes
+- Absorb traffic spikes without amplification
+
+Freshness MUST NEVER:
+
+- Block responses
+- Amplify third-party API usage
+- Compromise system stability
+
+---
+
+## 7. Scaling Invariant
+
+External API usage MUST NOT scale with user count.
+
+The correct model is:
+
+```txt
+External APIs
+      ↓
+   Backend
+      ↓
+Unlimited Clients
+````
+
+If user growth increases third-party calls,
+the architecture is **INVALID**.
+
+---
+
+## 8. Backend Anti-Patterns (ZERO TOLERANCE)
+
+The following are considered **backend violations**:
+
+* Client-side third-party API calls
+* Treating backend as a thin proxy
+* Persisting realtime data as history
+* Per-request external fetches
+* Silent retries hiding corruption
+* Backend logic conditional on frontend behavior
+
+These patterns MUST be **REJECTED**, not patched.
+
+---
+
+## 9. Enforcement Rule
+
+Any backend implementation that:
+
+* Blurs data ownership
+* Leaks external dependency semantics
+* Requires frontend fixes to be “correct”
+* Introduces hidden coupling
+
+**MUST NOT BE MERGED**.
+
+Correctness overrides convenience.
+
+---
+
+## Final Authority
+
+This doctrine overrides:
+
+* Performance shortcuts
+* Framework defaults
+* “Temporary” backend logic
+* Cost-driven compromises that weaken truth
+
+The backend exists to protect:
+
+**Truth · Integrity · Scalability**
+
+Not developer speed.
+
+---
+
+**Status:** LOCKED
+**Version:** 1.0.0
+**Parent:** PikaKit Architecture Doctrine
+**Override Permission:** NONE
+
+---
+
+⚡ PikaKit v3.9.134

package/.agent/skills/code-constitution/rules/doctrines/commercial/commercial-guardrails-doctrine.md

@@ -0,0 +1,196 @@
+---
+name: commercial-guardrails-doctrine
+version: "3.9.134"
+status: LOCKED
+authority: CONSTITUTIONAL
+parent: architecture-doctrine
+---
+
+# 💼 PikaKit Commercial Guardrails Doctrine  
+**(Enterprise Safety · Risk · Business Continuity Law)**
+
+This doctrine defines the **commercial and enterprise guardrails**
+governing how PikaKit evolves in production.
+
+At scale,  
+**technical mistakes become business failures**.
+
+This doctrine exists to protect:
+- User trust
+- Legal exposure
+- Revenue continuity
+- Operational stability
+
+---
+
+## 1. Commercial Risk Philosophy
+
+PikaKit assumes:
+
+- Long-lived systems
+- Paying users
+- Large and distributed teams
+- Regulatory and reputational exposure
+
+Therefore:
+
+- Safety outweighs speed
+- Predictability outweighs experimentation
+- Reversibility outweighs optimization
+
+A slower correct system  
+outperforms a fast broken one.
+
+---
+
+## 2. Change Classification Law (MANDATORY)
+
+Every non-trivial change MUST be explicitly classified as one of:
+
+### Non-Breaking Change
+- Backward-compatible
+- Behavior-preserving
+- No user-visible risk
+
+### Breaking Change
+- Alters external behavior, APIs, or data contracts
+- Requires migration or user adaptation
+
+### Risk-Bearing Change
+- Affects correctness, trust, compliance, or revenue
+- Has non-obvious failure modes
+
+Unclassified changes are treated as  
+**HIGH RISK BY DEFAULT**.
+
+---
+
+## 3. Breaking Change Law (NON-NEGOTIABLE)
+
+Breaking changes are **FORBIDDEN** unless **ALL** conditions are met:
+
+- A documented migration path exists
+- Backward compatibility is preserved during transition
+- Rollback is technically feasible
+- Blast radius is explicitly understood
+- Stakeholders are informed in advance
+
+“If it compiles” or “tests pass”  
+is NOT sufficient justification.
+
+---
+
+## 4. Speculative Change Prohibition
+
+Speculative changes are **STRICTLY FORBIDDEN** in production systems.
+
+Speculative includes:
+
+- Refactors without measurable benefit
+- Architectural rewrites “for cleanliness”
+- Optimizations without proven bottlenecks
+- Technology swaps driven by novelty
+
+Every approved change MUST justify:
+
+- Why now
+- Why this approach
+- Why the risk is acceptable
+
+Curiosity is not a business strategy.
+
+---
+
+## 5. Blast Radius Awareness Law
+
+Before approval, the impact of a change MUST be explicitly understood:
+
+- Who is affected
+- How many users are affected
+- What data is at risk
+- What revenue or trust is at risk
+- How rollback is performed
+
+If blast radius cannot be bounded,  
+the change MUST NOT proceed.
+
+---
+
+## 6. Governance & Escalation Order
+
+When trade-offs exist between:
+
+- Safety vs speed
+- Stability vs innovation
+- Correctness vs delivery
+
+Decisions MUST defer in this order:
+
+1. PikaKit Master Constitution
+2. Architecture Doctrine
+3. Commercial Guardrails (this document)
+4. Performance Doctrine
+5. Review Checklists
+6. Agent Enforcement Protocol
+7. Developer or Agent Preference
+
+Anything lower **cannot override** anything higher.
+
+---
+
+## 7. Commercial Anti-Patterns (ZERO TOLERANCE)
+
+The following are considered **commercial violations**:
+
+- Silent behavior changes
+- Breaking APIs without deprecation
+- Irreversible migrations
+- Unbounded experiments in production
+- “We’ll fix it later” reasoning
+- Launching without rollback paths
+
+If detected, changes MUST be **REVERTED IMMEDIATELY**.
+
+---
+
+## 8. Enforcement Rule
+
+Any change that:
+
+- Risks user trust
+- Weakens legal or compliance posture
+- Introduces irreversible state
+- Trades correctness for delivery speed
+
+**MUST NOT BE MERGED OR DEPLOYED**.
+
+Missed deadlines are recoverable.  
+Lost trust is not.
+
+---
+
+## Final Authority
+
+This doctrine overrides:
+
+- Feature enthusiasm
+- Engineering curiosity
+- Short-term delivery pressure
+- Experimental ambition
+
+PikaKit protects:
+
+**Trust · Stability · Business Continuity**
+
+Because **trust is the business**.
+
+---
+
+**Status:** LOCKED  
+**Version:** 1.0.0  
+**Parent:** PikaKit Architecture Doctrine  
+**Override Permission:** NONE
+
+---
+
+⚡ PikaKit v3.9.134