agent-skill-kit 3.9.135

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

@@ -0,0 +1,202 @@
+---
+name: data-integrity-doctrine
+version: "3.9.134"
+status: LOCKED
+authority: CONSTITUTIONAL
+parent: architecture-doctrine
+---
+
+# 📈 PikaKit Chart Data Doctrine  
+**(Financial Truth · Historical Integrity · Visualization Law)**
+
+This doctrine defines the **non-negotiable laws** governing how
+price data is classified, stored, and visualized in PikaKit charts.
+
+Charts are **NOT visual components**.  
+Charts are **financial statements**.
+
+If chart data integrity is violated,  
+user trust is **PERMANENTLY DAMAGED**.
+
+---
+
+## 1. Chart Truth Philosophy
+
+A PikaKit chart represents **historical financial truth**.
+
+It MUST be:
+
+- Accurate
+- Stable
+- Auditable
+- Non-deceptive
+
+Visual excitement MUST NEVER  
+compromise data truth.
+
+---
+
+## 2. Data Classification Law (MANDATORY)
+
+All price data MUST be explicitly classified as **one** of the following.
+
+### 2.1 Historical Data
+
+Historical data is:
+
+- Immutable once written
+- Backfilled from authoritative sources
+- Fully auditable and traceable
+- Used **EXCLUSIVELY** for charts and aggregates
+
+### 2.2 Realtime Data
+
+Realtime data is:
+
+- Ephemeral and transient
+- Non-auditable
+- Display-only
+- NEVER persisted as historical truth
+
+Mixing historical and realtime data  
+is a **HARD VIOLATION**.
+
+---
+
+## 3. Historical Immutability Law (NON-NEGOTIABLE)
+
+Once historical data is written:
+
+- It MUST NEVER be mutated
+- It MUST NEVER be smoothed or interpolated
+- It MUST NEVER be retroactively edited
+
+Corrections MUST occur via:
+
+- Append-only correction records
+- Explicit correction events
+
+Silent mutation is considered  
+**FINANCIAL DATA CORRUPTION**.
+
+---
+
+## 4. Realtime Separation Law
+
+Realtime price data:
+
+- MUST NOT be injected into chart datasets
+- MUST NOT trigger chart re-renders
+- MUST NOT alter historical ranges, highs, or lows
+- MUST NOT affect chart scaling or aggregation
+
+Realtime data exists to inform **the present**,  
+not to rewrite **the past**.
+
+---
+
+## 5. Visualization Integrity Law
+
+Charts MUST:
+
+- Render **ONLY historical data**
+- Maintain stable visual structure
+- Preserve consistent scaling per timeframe
+- Avoid jitter, flicker, or rescaling due to realtime signals
+
+If a chart visually changes due to realtime ticks,  
+the implementation is **INVALID**.
+
+---
+
+## 6. Aggregation & Timeframe Law
+
+All chart aggregation MUST:
+
+- Be derived solely from historical data
+- Use deterministic, documented rules
+- Produce repeatable results for the same input
+
+Timeframe changes MUST:
+
+- Re-aggregate from historical data
+- NEVER rely on realtime ticks
+- NEVER approximate missing points
+
+Approximation for aesthetics  
+is **FORBIDDEN**.
+
+---
+
+## 7. Auditability Requirement
+
+Every chart MUST be defensible under audit.
+
+A chart is INVALID if:
+
+- Any data point cannot be explained individually
+- Any value cannot be traced to a source
+- Any correction lacks historical justification
+- Any aggregation hides raw data inconsistencies
+
+If the data cannot be defended,  
+it MUST NOT be shown.
+
+---
+
+## 8. Chart Anti-Patterns (ZERO TOLERANCE)
+
+The following are considered **chart violations**:
+
+- Mixing realtime ticks into historical series
+- Smoothing or interpolating missing data
+- Rewriting historical points for aesthetics
+- “Fixing” spikes without audit evidence
+- Rebuilding full chart series on every update
+- Letting animation logic influence data structure
+
+These patterns MUST be **REJECTED**, not patched.
+
+---
+
+## 9. Enforcement Rule
+
+Any chart implementation that:
+
+- Misrepresents historical truth
+- Hides data inconsistencies
+- Optimizes visuals over correctness
+- Surprises an experienced analyst
+
+**MUST NOT BE MERGED OR DEPLOYED**.
+
+A misleading chart  
+is worse than no chart.
+
+---
+
+## Final Authority
+
+This doctrine overrides:
+
+- UI convenience
+- Animation preferences
+- Performance shortcuts that alter truth
+- “Looks better” arguments
+
+PikaKit charts exist to protect:
+
+**Truth · Auditability · User Trust**
+
+Not visual flair.
+
+---
+
+**Status:** LOCKED  
+**Version:** 1.0.0  
+**Parent:** PikaKit Architecture Doctrine  
+**Override Permission:** NONE
+
+---
+
+⚡ PikaKit v3.9.134

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

@@ -0,0 +1,169 @@
+---
+name: frontend-mobile-doctrine
+version: "3.9.134"
+status: LOCKED
+authority: CONSTITUTIONAL
+parent: architecture-doctrine
+---
+
+# 📱 PikaKit Frontend Mobile Doctrine  
+**(Mobile UX · Layout · Gesture Integrity Law)**
+
+This doctrine defines the **non-negotiable laws** governing how PikaKit’s
+mobile interface is structured, rendered, scrolled, and interacted with.
+
+Mobile UX is **NOT a collection of components**.  
+Mobile UX is a **system of invariants**.
+
+If mobile invariants are violated,  
+the UI may render — but the system is **BROKEN**.
+
+---
+
+## 1. Mobile-First Law
+
+PikaKit is **mobile-first**, not mobile-compatible.
+
+Mobile defines:
+
+- Layout hierarchy
+- Scroll behavior
+- Gesture expectations
+- Performance constraints
+
+Desktop adapts from mobile.  
+Mobile **NEVER** adapts from desktop.
+
+---
+
+## 2. Layout Invariants (NON-NEGOTIABLE)
+
+The following dimensions are **global system invariants**:
+
+- Header height: **56px**
+- TabBar height: **44px**
+- Bottom navigation height: **56px**
+
+Rules:
+
+- Values MUST be consistent across all pages
+- Values MUST NOT be overridden locally
+- Values MUST NOT be duplicated as magic numbers
+- Values MUST be defined in a single global source
+
+Changing any invariant requires  
+**system-wide architectural coordination**.
+
+---
+
+## 3. Scroll Ownership Law
+
+Scroll is a **system-level responsibility**,  
+not a component-level decision.
+
+Hard rules:
+
+- The page root MUST NOT scroll
+- Swipe containers MUST NOT scroll
+- Vertical scrolling MUST exist **ONLY** inside `ScrollContent`
+- Exactly **ONE** vertical scroll container is allowed per screen
+
+Nested or competing scroll containers  
+are **CRITICAL UX VIOLATIONS**.
+
+---
+
+## 4. Structural Hierarchy Law
+
+The mobile layout hierarchy is fixed:
+
+```txt
+Header (non-scrolling)
+  ↓
+TabBar (non-scrolling)
+  ↓
+Swipe / Content Container (non-scrolling)
+  ↓
+ScrollContent (ONLY scrollable layer)
+  ↓
+Bottom Navigation (non-scrolling)
+````
+
+Violating this hierarchy causes:
+
+* Sticky failures
+* Gesture conflicts
+* Scroll desynchronization
+* Platform-specific bugs (especially iOS)
+
+---
+
+## 5. Gesture & Scroll Separation Law
+
+Gestures and scrolling MUST be **strictly separated**.
+
+Rules:
+
+* Gesture handling MUST live outside scroll containers
+* Scroll containers MUST NOT interpret horizontal gestures
+* Swipe logic MUST NOT depend on scroll position or state
+
+Mixing gesture logic with scrolling
+creates undefined behavior and is **FORBIDDEN**.
+
+---
+
+## 6. Mobile UX Anti-Patterns (ZERO TOLERANCE)
+
+The following are considered **critical UX violations**:
+
+* Multiple vertical scroll containers
+* Scrolling headers or tab bars
+* Page-specific layout exceptions
+* Gesture logic inside scroll containers
+* Wrapper components that alter scroll context
+* Using `100vh` without subtracting system UI heights
+
+These patterns MUST be **REMOVED**, not patched.
+
+---
+
+## 7. Consistency Enforcement Rule
+
+If any of the following occur:
+
+* Scroll behavior differs between pages
+* Sticky elements behave inconsistently
+* Gestures feel different across screens
+* iOS and Android behavior diverges
+
+Then the **layout system is broken**
+and MUST be fixed at the architectural level.
+
+Local fixes are **FORBIDDEN**.
+
+---
+
+## Final Authority
+
+This doctrine overrides:
+
+* Framework defaults
+* Component convenience
+* One-off bug fixes
+* Visual experimentation
+
+If a layout solution is easy
+but violates these laws,
+**it is the WRONG solution**.
+
+---
+
+**Status:** LOCKED
+**Version:** 1.0.0
+**Parent:** PikaKit Architecture Doctrine
+**Override Permission:** NONE
+
+---
+
+⚡ PikaKit v3.9.134

package/.agent/skills/code-constitution/rules/doctrines/frontend/interaction-patterns-doctrine.md

@@ -0,0 +1,176 @@
+---
+name: interaction-patterns-doctrine
+version: "3.9.134"
+status: LOCKED
+authority: CONSTITUTIONAL
+parent: frontend-mobile-doctrine
+---
+
+# 👉 PikaKit Swipe Tabs Doctrine  
+**(Universal Swipe · Gesture · Navigation Law)**
+
+This doctrine defines the **single, universal swipe-tab architecture**
+used across PikaKit.
+
+Swipe is **NOT** a visual effect.  
+Swipe is a **navigation primitive**.
+
+If swipe behavior differs between pages,  
+the system is **BROKEN**.
+
+---
+
+## 1. Core Intent
+
+The swipe-tabs system exists to guarantee:
+
+- Predictable gestures
+- Identical interaction across screens
+- iOS-safe scrolling behavior
+- Zero page-specific exceptions
+
+Consistency is more important than animation smoothness.
+
+---
+
+## 2. Single Implementation Law (NON-NEGOTIABLE)
+
+PikaKit MUST have:
+
+- **Exactly ONE swipe implementation**
+- Shared across **ALL** pages
+- No page-specific overrides
+- No conditional gesture logic
+
+Duplicated or specialized swipe logic  
+is a **SYSTEM VIOLATION**.
+
+---
+
+## 3. Swipe vs Scroll Responsibility Law
+
+Swipe and scroll are **mutually exclusive responsibilities**.
+
+Rules:
+
+- Swipe containers MUST NEVER scroll
+- Scroll containers MUST NEVER swipe
+- Swipe logic MUST NOT depend on scroll state
+- Scroll logic MUST NOT interpret horizontal gestures
+
+Violation of separation  
+creates undefined behavior.
+
+---
+
+## 4. Structural Placement Law
+
+Swipe MUST live in the following structure:
+
+```txt
+Header (non-scrolling)
+  ↓
+TabBar (non-scrolling)
+  ↓
+Swipe Container (horizontal only)
+  ↓
+Tab Panel
+  ↓
+ScrollContent (vertical only)
+````
+
+Rules:
+
+* Header and TabBar MUST live OUTSIDE the swipe layer
+* Swipe container MUST NOT be transformed vertically
+* ScrollContent is the ONLY scrollable element
+
+---
+
+## 5. Gesture Arbitration Law
+
+Gesture intent MUST be resolved deterministically.
+
+Rules:
+
+* Horizontal intent → swipe
+* Vertical intent → scroll
+* If vertical movement dominates → swipe MUST cancel
+* Thresholds and velocity rules MUST be global and consistent
+
+Gesture logic MUST be deterministic.
+“Heuristic” behavior is **FORBIDDEN**.
+
+---
+
+## 6. Platform Consistency Law
+
+Swipe behavior MUST:
+
+* Feel identical on every page
+* Behave consistently on iOS and Android
+* Remain stable under partial or aborted gestures
+* Never break sticky layout behavior
+
+If swipe feels different anywhere,
+the implementation is **INVALID**.
+
+---
+
+## 7. Forbidden Patterns (ZERO TOLERANCE)
+
+The following patterns are **STRICTLY FORBIDDEN**:
+
+* Swipe logic attached to scrollable containers
+* Page-specific gesture hacks
+* Conditional swipe enable/disable per screen
+* Mixing `transform`-based swipe with native scrolling
+* Gesture logic based on content height
+* JavaScript hacks that “almost fix” gestures
+
+If swipe feels unreliable,
+the architecture is wrong.
+
+---
+
+## 8. Enforcement Rule
+
+Any swipe-related change that:
+
+* Alters gesture consistency
+* Introduces page-specific behavior
+* Breaks iOS scrolling stability
+* Requires local fixes
+
+**MUST NOT BE MERGED**.
+
+Local patches are forbidden.
+Fixes must occur at the system level.
+
+---
+
+## Final Authority
+
+This doctrine overrides:
+
+* Component convenience
+* Animation experiments
+* Framework gesture defaults
+* Visual polish preferences
+
+PikaKit swipe exists to protect:
+
+**Predictability · Consistency · Navigation Trust**
+
+Not visual flair.
+
+---
+
+**Status:** LOCKED
+**Version:** 1.0.0
+**Parent:** PikaKit Frontend Mobile Doctrine
+**Override Permission:** NONE
+
+---
+
+⚡ PikaKit v3.9.134

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

@@ -0,0 +1,192 @@
+---
+name: learning-engine-doctrine
+version: "3.9.134"
+status: LOCKED
+authority: CONSTITUTIONAL
+parent: architecture-doctrine
+---
+
+# 🧠 PikaKit Learning Engine Doctrine  
+**(Controlled Learning · Reasoning Integrity Law)**
+
+This doctrine defines how PikaKit is **allowed to learn and improve over time**
+without violating architectural, data, or trust invariants.
+
+Learning is power.  
+Uncontrolled learning is **SYSTEM FAILURE**.
+
+PikaKit learns to become **more correct**,  
+not more flexible.
+
+---
+
+## 1. Learning Philosophy
+
+PikaKit does **NOT** learn code.  
+PikaKit does **NOT** learn implementation details.
+
+PikaKit learns:
+
+- Reasoning patterns
+- Decision heuristics
+- Architectural judgment
+
+The goal of learning is:
+
+- Increased correctness
+- Increased predictability
+- Reduced future mistakes
+
+Novelty and cleverness are **NOT goals**.
+
+---
+
+## 2. Learning Authority Law (NON-NEGOTIABLE)
+
+All learning is **strictly subordinate** to:
+
+1. PikaKit Master Constitution
+2. Architecture Doctrine
+3. System Doctrines
+
+Learning MUST NEVER:
+
+- Override a law
+- Weaken an invariant
+- Introduce exceptions
+- Redefine system boundaries
+
+If learning conflicts with doctrine,  
+the learning MUST be **REJECTED**.
+
+---
+
+## 3. Learning Trigger Law
+
+Learning is triggered **ONLY** when at least one of the following occurs:
+
+- A previous agent decision is explicitly corrected
+- A demonstrably superior approach is provided
+- Architectural or systemic reasoning is overridden by the user
+
+Providing code alone  
+does **NOT** trigger learning.
+
+---
+
+## 4. Learning Boundary Law (HARD LIMITS)
+
+The system MUST NEVER learn or internalize:
+
+- Code style or formatting preferences
+- Naming conventions
+- Temporary workarounds
+- Project-specific hacks
+- One-off optimizations
+- UI or aesthetic preferences
+
+Learning MUST target **generalizable reasoning**,  
+never local fixes.
+
+---
+
+## 5. Learning Extraction Protocol
+
+When learning is triggered, the system MUST:
+
+1. Identify the **incorrect assumption**
+2. Identify **why the new reasoning is superior**
+3. Abstract a **technology-agnostic principle**
+4. Validate the principle against all doctrines
+5. Apply learning **only to future reasoning**
+
+If a principle cannot be clearly articulated,  
+learning MUST be **ABORTED**.
+
+---
+
+## 6. Predictability Enforcement Law
+
+Learning MUST increase predictability.
+
+Learning is INVALID if it:
+
+- Surprises an experienced engineer
+- Introduces inconsistent decisions
+- Requires special context to be safe
+- Produces different answers for the same problem
+
+Predictability outranks adaptability.
+
+---
+
+## 7. Learning Rollback Rule
+
+All learning MUST be:
+
+- Explicit
+- Auditable
+- Reversible
+
+If learning degrades system trust or clarity,  
+it MUST be **ROLLED BACK** immediately.
+
+Silent behavioral drift is **FORBIDDEN**.
+
+---
+
+## 8. AI Agent Constraints
+
+AI agents operating under PikaKit:
+
+- Are proposal-only
+- Have zero trust by default
+- Cannot approve or merge changes
+- Must cite applicable doctrines
+- Must explain reasoning transparently
+
+AI assistance MUST NEVER  
+replace human accountability.
+
+---
+
+## 9. Enforcement Rule
+
+Any learning behavior that:
+
+- Weakens doctrine
+- Introduces ambiguity
+- Accumulates exceptions
+- Reduces predictability
+
+**MUST BE DISABLED**.
+
+System safety overrides learning ambition.
+
+---
+
+## Final Authority
+
+This doctrine overrides:
+
+- Adaptive heuristics
+- “Smart” optimizations
+- Self-modifying behavior
+- Unbounded AI learning
+
+PikaKit learns to protect:
+
+**Correctness · Predictability · Trust**
+
+Not novelty.
+
+---
+
+**Status:** LOCKED  
+**Version:** 1.0.0  
+**Parent:** PikaKit Architecture Doctrine  
+**Override Permission:** NONE
+
+---
+
+⚡ PikaKit v3.9.134