NakaSato

Global workspace instructions and machine-specific configurations for GridTokenX.

Run and verify the end-to-end telemetry data-hop chain — meter onboard (IAM register→verify→claim) → signed DLMS/COSEM ingest into the Aggregator Bridge → owner+wallet resolve → zone Redis stream → 15-min settlement bin → surplus mint over NATS chain.tx.mint → Solana. Use when the user says "hops test", "run the hops", "test telemetry path", "test the mint", "force a surplus", "verify settlement/mint", or wants any leg of the meter→bridge→settlement→chain pipeline exercised and verified hop-by-hop. Drives the live docker stack (compose up). Confirms each trust gate with real log/DB/Redis evidence — never assumes success.

Use when user asks to "build a Solana dapp", "write an Anchor program", "create a token", "debug Solana errors", "set up wallet connection", "test my Solana program", "deploy to devnet", or "explain Solana concepts" (rent, accounts, PDAs, CPIs, etc.). Also use for quick on-chain lookups via public RPC + curl — "what's the balance of <wallet>", "look up transaction <sig>", "token balance for <account>", "check this address on mainnet/devnet". End-to-end Solana development playbook covering wallet connection, Anchor/Pinocchio programs, Codama client generation, LiteSVM/Mollusk/Surfpool testing, security checklists, and JSON-RPC curl lookups against public clusters. Integrates with the Solana MCP server for live documentation search. Prefers framework-kit (@solana/client + @solana/react-hooks) for UI, wallet-standard-first connection (incl. ConnectorKit), @solana/kit for client/RPC code, and @solana/web3-compat for legacy boundaries.

Discover, evaluate, and wire Typst Universe packages (https://typst.app/universe) into the Paper/ academic paper. Use when the user wants a Typst package for a paper need (plots, diagrams, tables, glossary, equations, captions, theorems, citation/bib tooling), says "find a typst package for X", "add <package>", "what package does Y", "create a chart/diagram/table in the paper", or asks to browse Typst Universe. Knows the paper's vendored-font + open-PDF build rules and pins package versions.

Autonomous development loop for a single task — plan, implement, test, summarize. Runs end-to-end without pausing except on hard blockers. Use when the user says "auto-dev <task>", "automatic development", "just build it", or wants a task driven start-to-finish.

Write, fact-check, review, and proofread the Typst research paper (Paper/) against the real gridtokenx codebase. Four modes — (1) FETCH facts/docs from a target service folder and draft cited Typst prose for a paper section (may add net-new content, not only document what exists), (2) VERIFY the paper's claims against existing code and flag drift, (3) REVIEW the paper as a critical preprint reviewer / professor (rigor, contribution, gaps, structure), (4) GRAMMAR recheck the Thai-language prose for correctness and consistency. Use when the user says "doc-paper", "write/expand the paper from <service>", "verify the paper against <code>", "fact-check the paper", "review the paper like a professor", "preprint review", "recheck Thai grammar", or wants paper content grounded in the actual code.

Fetch and convert web content into LLM-friendly markdown using Jina AI Reader. Use when you need to read content from a URL with high fidelity and minimal noise.

Patterns, gotchas, and high-throughput performance guidance for building and maintaining GridTokenX Rust microservices — specifically the chain-bridge service (the Solana signing protocol bridge) and its siblings that use mTLS + SPIFFE identity, connectrpc, NATS JetStream, HashiCorp Vault Transit signing, and Solana RPC. Use this skill whenever the user is working on chain-bridge (crates/chain-bridge-api/src/api/service.rs, crates/chain-bridge-api/src/main.rs, crates/chain-bridge-api/src/middleware.rs, crates/chain-bridge-api/src/nats_consumer/consumer.rs, crates/chain-bridge-api/src/vault.rs), adding a new gRPC handler, adding a new NATS subject, wiring up a new GridTokenX service, debugging mTLS or SPIFFE identity issues, integrating Vault Transit signing, reasoning about RBAC between platform microservices, OR scaling the bridge to high throughput (questions about TPS targets, Vault signing bottlenecks, Solana RPC pooling, NATS worker concurrency, connection reuse, backpressure, latency budgets, or any que

Reviews axum web framework code for routing patterns, extractor usage, middleware, state management, and error handling. Use when reviewing Rust code that uses axum, tower, or hyper for HTTP services. Covers axum 0.7+ patterns including State, Path, Query, Json extractors.

Development guidance for writing idiomatic Rust. Use when: (1) writing new Rust functions or modules, (2) choosing between borrowing, cloning, or ownership patterns, (3) implementing error handling with Result types, (4) optimizing Rust code for performance, (5) configuring clippy and linting for a project, (6) deciding between static and dynamic dispatch, (7) writing documentation or doc tests.

Reviews Rust code for ownership, borrowing, lifetime, error handling, trait design, unsafe usage, and common mistakes. Use when reviewing .rs files, checking borrow checker issues, error handling patterns, or trait implementations. Covers Rust 2024 edition patterns and modern idioms.

Reviews tokio async runtime usage for task management, sync primitives, channel patterns, and runtime configuration. Covers Rust 2024 edition changes including async fn in traits, RPIT lifetime capture, LazyLock, and if-let temporary scoping. Use when reviewing Rust code that uses tokio, async/await patterns, spawn, channels, or async synchronization. Also covers tokio-util, tower, and hyper integration patterns.

Author, edit, and validate GridLAB-D .glm topology files for the smart meter simulator. Use when creating or modifying a grid topology (.glm), adding buses/lines/loads/PV, debugging "validate-topology" errors, fixing missing-bus / disconnected-graph / PV-not-mapped issues, or understanding which GLM object types and fields this backend's parser actually reads.

Run, drive, and test the simulator end-to-end — the uv entry points (app/cli), server vs standalone vs validate-topology modes, the FastAPI lifespan/autostart, hot-swapping topology and telemetry sources at runtime, the pytest suite (coverage, markers), and the Docker image. Use when starting the simulator, reproducing a scenario, switching grids/telemetry, or figuring out how to run a specific test.

Build and control the meter population — MeterGenerator (synthetic fleets, type-mix ratios, PV-per-bus, spreading meters across topology buses) and the meter registry (pinning real meters by id to physical buses for telemetry-driven runs). Use when changing how meters are created, how many there are, how meter types/solar are assigned, how meters map to buses, or wiring a CSV/JSON registry.

Develop the backend simulation — device models (PV/load/AMI), the per-tick feeder solver, reading generation, telemetry sources, and FastAPI routers. Use when adding or changing how meters generate readings, how the grid solver computes voltages/flows/losses, how real telemetry overrides synthetic models, or how a new measurement/field surfaces through the API. (For editing .glm topology files themselves, use glm-topology-authoring instead.)

Develop the Next.js 16 / React 19 simulator dashboard — pages (dashboard, map, topology, meter detail), components (Leaflet/Mapbox maps, Three.js 3D topology, Recharts), the backend API client, WebSocket/polling telemetry, and the React Context providers. Use when adding or changing UI, wiring a new backend endpoint into the frontend, touching the map/3D views, or debugging API-target / proxy issues. Read this BEFORE writing frontend code.

Use this skill when working in the `gridtokenx-blockchain-core` Rust crate, including changes to BlockchainService, ChainBridgeProvider, gRPC Chain Bridge integration, NATS JetStream transaction submission, WalletService encryption, SPIFFE ServiceRole RBAC, priority fees, instruction builders, PDA derivation, token/ATA handling, transaction submission, or proto/chain_bridge.proto. Do not use for the on-chain Anchor programs themselves.

Use this skill whenever the user is working on the on-chain Anchor programs in the GridTokenX Solana repo — the `energy-token`, `governance`, `oracle`, `registry`, or `trading` programs, or anything involving `Anchor.toml` or the per-program `Cargo.toml`. Trigger for tasks like adding instructions, changing account structs, modifying PDAs or seeds, wiring CPIs between programs, adjusting the zero-copy state layouts, tuning compute usage, fixing Anchor lifetime errors, regenerating instruction discriminators, or reasoning about Sealevel write-lock contention and sharding. Also trigger for work on the `compute-debug` feature, `zero_copy` Pod layouts, or the dual-token (GRID + GRX) logic. Do not trigger for the `gridtokenx-blockchain-core` Rust client library — that has its own skill.

Guidance for structuring and extending the GridTokenX Notification Service — the trait-based dependency injection pattern, sync-core/async-edges design, Tera template rendering system, multi-channel providers (Email, SMS, Push, Webhook, WebSocket), Kafka event ingestion, RabbitMQ DLX retry flow, and the decoupled WebSocket registry. Use this skill whenever the user asks about how to organize or extend notification handling code; where to add new providers, channels, or event types; how the template system works; where business logic should live vs infrastructure; how retry and idempotency work; or how to maintain the strict dependency layers while adding new delivery mechanisms. Trigger on questions about the noti-service architecture, adding notification features, template rendering, provider implementations, or event-driven notification flows.