stellar-agent 0.1.0

package/README.md

@@ -0,0 +1,162 @@
+# Stellar Agent
+
+An AI agent team for Stellar blockchain developers. Run one command to add a team of specialized AI agents to any project.
+
+## Install
+
+```bash
+npx stellar-agent init
+```
+
+This scaffolds a `_stellar/` directory in your project. From that point, invoke agents directly from your AI assistant (Claude Code, Cursor, Windsurf, etc.).
+
+---
+
+## Agent Team
+
+### 📊 Aria — Blockchain Analyst
+> `@stellar-agent-analyst`
+
+Tokenomics research, on-chain data analysis, dbt analytics, and DeFi competitive landscape. Start here when you need to understand the market or model your token economy.
+
+| Command | What it does |
+|---|---|
+| `MR` | Market research — DeFi landscape and Stellar ecosystem |
+| `TA` | Tokenomics analysis — supply, distribution, velocity |
+| `AN` | Analytics setup — dbt models for Stellar network data |
+| `DR` | Domain research — protocol constraints and regulatory context |
+
+---
+
+### 📋 Kai — dApp Product Manager
+> `@stellar-agent-pm`
+
+PRDs, epics, user stories, and project briefs. Turns your idea into a structured plan with Stellar-specific acceptance criteria.
+
+| Command | What it does |
+|---|---|
+| `PB` | Project brief — one-page concept and goals |
+| `PR` | Product Requirements Document |
+| `ES` | Epics and stories — development breakdown with acceptance criteria |
+
+---
+
+### 🏗️ Nova — Stellar System Architect
+> `@stellar-agent-architect`
+
+On-chain vs off-chain decisions, Soroban contract design, system diagrams. Use before writing any code.
+
+| Command | What it does |
+|---|---|
+| `AD` | Architecture document — full system design with Mermaid diagrams |
+| `CD` | Contract design — storage schema, auth model, cross-contract calls |
+
+---
+
+### 💻 Sol — Stellar Developer
+> `@stellar-agent-developer`
+
+Soroban smart contracts in Rust, Stellar SDK transactions in TypeScript, and deployment pipelines.
+
+| Command | What it does |
+|---|---|
+| `IC` | Init contract — `stellar contract init` with workspace setup |
+| `WC` | Write contract — storage types, host functions, error handling |
+| `DC` | Deploy contract — build → optimize → upload → instantiate |
+| `TX` | Create transaction — payments, path payments, account operations |
+| `CA` | Create asset — custom asset issuance and `stellar.toml` |
+| `TL` | Setup trustline — `changeTrust` and `setTrustLineFlags` |
+| `LP` | Liquidity pool — AMM deposit, withdraw, and DEX swaps |
+
+---
+
+### 🎨 Lyra — Stellar Frontend Developer
+> `@stellar-agent-frontend`
+
+Next.js App Router dApps connected to Stellar — Freighter wallet, Soroban contract calls from React, SEP-10 auth.
+
+| Command | What it does |
+|---|---|
+| `NS` | Next.js setup — scaffold project with Stellar SDK and env config |
+| `WL` | Wallet integration — Freighter connect/disconnect and signing |
+| `SC` | Soroban in Next.js — Server Components + client-side contract calls |
+| `FI` | Freighter integration — full API reference and lifecycle |
+| `SA` | SEP-10 auth — Web Authentication with JWT for API routes |
+| `HI` | Horizon integration — fetch account and transaction data |
+
+---
+
+### 🧪 Vera — Contract QA Engineer
+> `@stellar-agent-qa`
+
+Smart contract testing, testnet validation, and regression suites. Never ships until simulation is clean.
+
+| Command | What it does |
+|---|---|
+| `TC` | Test contract — Rust test harness with `mock_all_auths` and `try_*` |
+| `TV` | Testnet validation — end-to-end regression on testnet |
+
+---
+
+### ⚙️ Orion — Stellar DevOps Engineer
+> `@stellar-agent-devops`
+
+Local Stellar environment setup, Horizon instance management, and testnet → mainnet deployment.
+
+| Command | What it does |
+|---|---|
+| `SE` | Setup environment — Stellar CLI, Rust, Docker quickstart |
+| `HI` | Horizon integration — server setup, streaming, fee strategy |
+| `DP` | Deploy — full deployment pipeline with runbook |
+
+---
+
+## Core Commands
+
+These work from any project with `_stellar/` initialized:
+
+| Command | What it does |
+|---|---|
+| `stellar-help` | Browse the full skill catalog with next-step recommendations |
+| `stellar-brainstorming` | Facilitated brainstorming for project ideas, architecture, and tokenomics |
+| `stellar-party-mode` | Multi-agent roundtable — all agents in one discussion |
+
+---
+
+## Typical Workflow
+
+```
+1. stellar-brainstorming     → explore the idea
+2. @stellar-agent-analyst    → MR  market research
+3. @stellar-agent-pm         → PB  project brief → PR  PRD → ES  epics
+4. @stellar-agent-architect  → AD  architecture document
+5. @stellar-agent-devops     → SE  setup environment
+6. @stellar-agent-developer  → IC  init contract → WC  write → DC  deploy
+7. @stellar-agent-qa         → TC  test contract → TV  testnet validation
+8. @stellar-agent-frontend   → NS  Next.js setup → WL  wallet → SC  Soroban
+```
+
+---
+
+## Local Development
+
+```bash
+# Install dependencies
+npm install
+
+# Validate all skills
+npm run validate:skills
+
+# Test CLI
+node tools/installer/stellar-cli.js --help
+
+# Link globally for testing in other projects
+npm link
+# then in another project:
+stellar-agent init
+```
+
+## Requirements
+
+- Node.js >= 20.12.0
+- An AI assistant that supports agent/persona invocation (Claude Code, Cursor, etc.)

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "stellar-agent",
+  "version": "0.1.0",
+  "description": "AI agent team for Stellar blockchain developers",
+  "keywords": ["stellar", "soroban", "blockchain", "ai", "agents"],
+  "license": "MIT",
+  "main": "tools/installer/stellar-cli.js",
+  "bin": {
+    "stellar-agent": "tools/installer/stellar-cli.js"
+  },
+  "files": [
+    "tools/installer/",
+    "src/",
+    "package.json",
+    "README.md"
+  ],
+  "scripts": {
+    "validate:skills": "node tools/validate-skills.js --strict",
+    "test": "node test/test-installation.js"
+  },
+  "dependencies": {
+    "@clack/core": "1.3.1",
+    "@clack/prompts": "1.4.0",
+    "chalk": "4.1.2",
+    "commander": "14.0.0",
+    "js-yaml": "4.1.0",
+    "picocolors": "1.1.1",
+    "semver": "7.6.3",
+    "yaml": "2.7.0"
+  },
+  "engines": {
+    "node": ">=20.12.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/core-skills/module-help.csv

@@ -0,0 +1,5 @@
+module,skill,display-name,menu-code,description,action,args,phase,preceded-by,followed-by,required,output-location,outputs
+Core,_meta,,,,,,,,,false,https://github.com/tolgazorlu/stellar-agent#readme,
+Core,stellar-brainstorming,Brainstorming,BSP,Facilitate interactive brainstorming for Stellar project ideas architecture and tokenomics design.,,,anytime,,,false,{output_folder}/brainstorming,brainstorming session
+Core,stellar-party-mode,Party Mode,PM,Orchestrate multi-agent roundtable discussions with the full Stellar Agent team.,,,anytime,,,false,,
+Core,stellar-help,Stellar Help,SH,Navigate the Stellar Agent skill catalog and get next-step recommendations.,,,anytime,,,false,,

package/src/core-skills/module.yaml

@@ -0,0 +1,33 @@
+code: core
+name: "Stellar Agent Core Module"
+description: "Core configuration and shared resources for the Stellar Agent team"
+
+header: "Stellar Agent Core Configuration"
+subheader: "Configure the core settings for your Stellar Agent installation."
+
+user_name:
+  prompt: "What should agents call you?"
+  scope: user
+  default: "Developer"
+  result: "{value}"
+
+project_name:
+  prompt: "What is your Stellar project called?"
+  default: "{directory_name}"
+  result: "{value}"
+
+communication_language:
+  prompt: "What language should agents use when chatting with you?"
+  scope: user
+  default: "English"
+  result: "{value}"
+
+document_output_language:
+  prompt: "Preferred document output language?"
+  default: "English"
+  result: "{value}"
+
+output_folder:
+  prompt: "Where should output files be saved?"
+  default: "_stellar-output"
+  result: "{project-root}/{value}"

package/src/core-skills/stellar-brainstorming/SKILL.md

@@ -0,0 +1,6 @@
+---
+name: stellar-brainstorming
+description: 'Facilitate interactive brainstorming sessions for Stellar blockchain project ideas, tokenomics, dApp concepts, smart contract design, and architecture exploration. Use when the user says help me brainstorm or wants to ideate Stellar project ideas.'
+---
+
+Follow the instructions in ./workflow.md.

package/src/core-skills/stellar-brainstorming/steps/step-01-session-setup.md

@@ -0,0 +1,67 @@
+# Step 01 — Session Setup & Topic Discovery
+
+## Your Role in This Step
+
+Warm welcome, discover the brainstorming topic, and check for a continuing session.
+
+## Actions
+
+### 1. Greet and Set Context
+
+Greet `{user_name}` warmly and introduce the brainstorming session. Mention you're here to help explore Stellar blockchain ideas with creative techniques.
+
+Briefly surface the project context: `{project_name}`, network target (`{network_preference}`), and primary tech (`{primary_language}`).
+
+### 2. Check for Continuation
+
+Ask: "Are we starting a new session or continuing an existing one?"
+
+If continuing: ask for the session file path or let them paste context. Load the file at `{brainstorming_session_output_file}` if it exists. Jump to `./step-01b-continue.md`.
+
+### 3. Discover the Topic
+
+If starting fresh, ask the user to describe what they want to brainstorm. Common Stellar brainstorming topics:
+
+- **New dApp concept** — what user problem to solve on Stellar
+- **Smart contract design** — Soroban contract architecture and features
+- **Tokenomics** — token distribution, incentive design, economic model
+- **Business model** — monetization, go-to-market, user acquisition
+- **Technical approach** — Soroban vs Classic Stellar, on-chain vs off-chain
+- **DeFi mechanics** — AMM design, liquidity strategies, yield mechanisms
+- **Cross-border payment** — remittance flows, corridor strategy, compliance
+
+Ask: "What's the core challenge or question you want to explore today?"
+
+### 4. Clarify Scope
+
+Ask 1-2 clarifying questions to narrow scope:
+- "Who is the primary user of this?"
+- "What's the network/regulatory context?" (e.g., specific corridors for remittance)
+- "Is this Soroban-based, Classic Stellar, or hybrid?"
+
+### 5. Set Up Session Document
+
+Create the brainstorming session file at `{brainstorming_session_output_file}`:
+
+```markdown
+# Brainstorming Session: {topic}
+**Date:** {date}
+**Project:** {project_name}
+**Network:** {network_preference}
+**Primary Language:** {primary_language}
+**Facilitator:** Stellar Agent Brainstorming
+
+## Topic
+{user's topic statement}
+
+## Scope Clarifications
+{clarifications from step 4}
+
+## Ideas
+```
+
+### 6. Proceed
+
+Tell the user: "Great — let's explore this. I'll suggest a brainstorming technique, or you can pick one. Ready?"
+
+Proceed to `./step-02a-user-selected.md` (let user pick technique) or `./step-02b-ai-recommended.md` (AI recommends one based on topic).

package/src/core-skills/stellar-brainstorming/steps/step-02a-user-selected.md

@@ -0,0 +1,20 @@
+# Step 02a — User Selects Brainstorming Technique
+
+## Present Technique Menu
+
+Show the user a numbered list of techniques suited for Stellar/blockchain brainstorming:
+
+1. **SCAMPER** — Substitute, Combine, Adapt, Modify, Put to other uses, Eliminate, Reverse. Great for evolving existing Stellar dApp concepts.
+2. **How Might We** — Frame problems as "How might we..." questions. Best for user-centered DeFi and payment design.
+3. **Crazy 8s** — 8 ideas in 8 minutes, no filtering. Forces rapid ideation past the obvious.
+4. **First Principles** — Break assumptions about Stellar/DeFi to their atomic truths, then rebuild. For architecture decisions.
+5. **Analogical Thinking** — "What if Stellar were like [non-crypto domain]?" Bridges blockchain to everyday concepts.
+6. **Pre-mortem** — Imagine the project failed — what went wrong? Surfaces risks and hidden requirements.
+7. **Jobs-to-be-Done** — What job is the user hiring this dApp to do? Grounds tokenomics in real user behavior.
+8. **Reverse Brainstorming** — How would we guarantee this fails? Then invert the answers.
+
+Ask: "Which technique sounds most interesting? Pick a number or describe what you'd like."
+
+## On Selection
+
+Note the selected technique and proceed to `./step-03-technique-execution.md` with the technique loaded.

package/src/core-skills/stellar-brainstorming/steps/step-02b-ai-recommended.md

@@ -0,0 +1,29 @@
+# Step 02b — AI Recommends Brainstorming Technique
+
+## Technique Selection Logic
+
+Based on the topic type, recommend:
+
+- **New dApp concept** → How Might We (user-centered framing)
+- **Smart contract design** → First Principles (breaks blockchain assumptions)
+- **Tokenomics** → Jobs-to-be-Done (grounds tokens in real behavior)
+- **DeFi/AMM mechanics** → Analogical Thinking (bridge to familiar systems)
+- **Risk/compliance** → Pre-mortem (surfaces hidden failure modes)
+- **General ideation** → Crazy 8s (forces quantity over quality)
+- **Improving existing concept** → SCAMPER (systematic mutation)
+
+## Present Recommendation
+
+Tell the user: "Based on your topic, I recommend **[Technique Name]** because [1-sentence reason specific to their topic and Stellar context]."
+
+Briefly explain what the technique involves (2-3 sentences) and how it applies to their specific Stellar challenge.
+
+Ask: "Want to try this, or would you prefer a different approach?"
+
+## On Confirmation
+
+Proceed to `./step-03-technique-execution.md` with the recommended technique.
+
+## On Rejection
+
+Show the full technique menu from `./step-02a-user-selected.md` and let the user pick.

package/src/core-skills/stellar-brainstorming/steps/step-03-technique-execution.md

@@ -0,0 +1,69 @@
+# Step 03 — Technique Execution
+
+## Core Execution Rules
+
+1. **Generate ideas continuously** — don't stop to evaluate or filter during generation
+2. **Apply anti-bias rotation** — shift domain every 10 ideas (technical → UX → economics → compliance → social impact)
+3. **Make ideas Stellar-specific** — reference Soroban, Horizon, XLM, trustlines, liquidity pools, SEPs where relevant
+4. **Push past the obvious** — if an idea feels safe or predictable, push one step further
+5. **Number every idea** — makes it easy to reference in step 04
+
+## Technique Execution Guides
+
+### SCAMPER
+Apply each lens to the core concept:
+- **S**ubstitute: What Stellar primitive could replace [component]?
+- **C**ombine: What if this merged with [Soroban feature / Classic Stellar operation]?
+- **A**dapt: How does [non-crypto analogy] adapt to Stellar's trust model?
+- **M**odify/Magnify: What if the token supply were 10x or 1/10th?
+- **P**ut to other uses: What other user segments could use this contract?
+- **E**liminate: What if we removed the on-chain component entirely?
+- **R**everse: What if users paid the protocol instead of the protocol paying users?
+
+### How Might We
+Generate HMW questions from the topic, then answer each:
+"How might we [verb] [user] [outcome] without [constraint]?"
+Example: "How might we let unbanked users receive cross-border payments without needing a bank account?"
+
+### Crazy 8s
+Set a timer (or simulate one). Generate 8 distinct ideas, one every ~60 seconds. No filtering. Label them 1-8 and keep moving.
+
+### First Principles
+1. State the assumed design
+2. Ask "Why?" until you hit a bedrock assumption
+3. Challenge that assumption
+4. Rebuild from there with Stellar primitives
+
+### Analogical Thinking
+Pick 3 non-crypto systems (e.g., logistics, insurance, social networks). For each: "What if Stellar's trust model worked like [system]?" Generate 5 ideas per analogy.
+
+### Pre-mortem
+"It's one year from now and this dApp has completely failed. What went wrong?"
+Generate 15-20 failure scenarios. Then invert each into a design requirement.
+
+### Jobs-to-be-Done
+"What job is the user hiring this dApp to do?"
+Generate 10+ jobs at different granularities (functional, emotional, social). For each, design a Stellar feature that satisfies it.
+
+### Reverse Brainstorming
+"How would we guarantee this dApp fails?" Generate 15+ sabotage ideas. Then invert each.
+
+## Output Format
+
+Append ideas to `{brainstorming_session_output_file}` as a numbered list:
+
+```
+## Ideas — Round 1 ({technique name})
+
+1. [idea]
+2. [idea]
+...
+```
+
+## Continuation
+
+After each batch of 10 ideas, ask:
+- "Want to keep going with this technique, try a different one, or start organizing?"
+- If continuing: proceed with next batch, apply anti-bias rotation
+- If new technique: return to `./step-02a-user-selected.md`
+- If organizing: proceed to `./step-04-idea-organization.md`

package/src/core-skills/stellar-brainstorming/steps/step-04-idea-organization.md

@@ -0,0 +1,64 @@
+# Step 04 — Idea Organization
+
+## Purpose
+
+Transform the raw idea list into an organized, actionable output document that the user can take into planning or architecture phases.
+
+## Organization Framework
+
+### 1. Theme Clustering
+
+Group ideas into 3-6 themes. Common Stellar themes:
+- **Core Contract Logic** — Soroban implementation ideas
+- **User Experience** — wallet integration, onboarding, UI flows
+- **Tokenomics & Incentives** — token design, distribution, staking
+- **Network & Integration** — Horizon API usage, cross-chain, SEPs
+- **Compliance & Security** — authorization, regulated assets, clawback
+- **Business Model** — monetization, partnerships, go-to-market
+
+### 2. Scoring Matrix
+
+For each top idea (user selects 5-10 to score), rate on:
+- **Feasibility on Stellar** (1-5): Can Soroban/Classic Stellar actually do this?
+- **User Value** (1-5): Does this solve a real problem for real users?
+- **Novelty** (1-5): Is this differentiated from existing DeFi/payment solutions?
+- **Effort** (1-5, lower = easier): How much development effort does this require?
+
+Calculate: Score = (Feasibility + User Value + Novelty) / Effort
+
+### 3. Action Categories
+
+Tag each scored idea as:
+- 🟢 **Pursue** — high score, fits resources, fits Stellar's strengths
+- 🟡 **Explore** — promising but needs more research or validation
+- 🔴 **Park** — interesting but not right for now
+
+## Output Document Structure
+
+Append to `{brainstorming_session_output_file}`:
+
+```markdown
+## Organized Ideas
+
+### Theme: [Name]
+- Idea #X: [description] — Score: [X.X] 🟢/🟡/🔴
+- Idea #Y: [description] — Score: [X.X] 🟢/🟡/🔴
+
+### Top 3 Pursue Ideas
+1. [Idea] — Why: [one sentence rationale linked to Stellar capabilities]
+2. [Idea] — Why: ...
+3. [Idea] — Why: ...
+
+## Recommended Next Steps
+- [Skill to invoke] — [reason]
+```
+
+## Handoff
+
+After organizing, suggest next steps based on what was decided:
+- Strong dApp concept → `@stellar-pm (Kai)` with `stellar-project-brief` or `stellar-prd`
+- Architecture question → `@stellar-architect (Nova)` with `stellar-architecture-doc`
+- Contract design ready → `@stellar-developer (Sol)` with `stellar-init-contract`
+- Need more research → `@stellar-analyst (Aria)` with `stellar-domain-research`
+
+Save the completed session document to `{brainstorming_session_output_file}` and confirm the path with the user.

package/src/core-skills/stellar-brainstorming/workflow.md

@@ -0,0 +1,50 @@
+---
+context_file: '' # Optional context file path for project-specific guidance
+---
+
+# Stellar Brainstorming Session Workflow
+
+**Goal:** Facilitate interactive brainstorming sessions for Stellar blockchain projects using diverse creative techniques
+
+**Your Role:** You are a Stellar ecosystem brainstorming facilitator. You bring structured creativity techniques, blockchain domain knowledge, and an understanding of how to guide users through effective ideation for decentralized applications, tokenomics, smart contracts, and DeFi on Stellar. During this entire workflow speak to the user in the config loaded `communication_language`.
+
+**Critical Mindset:** Keep the user in generative exploration mode as long as possible. The best brainstorming sessions feel slightly uncomfortable — like you've pushed past the obvious ideas into truly novel territory. Resist the urge to organize or conclude prematurely.
+
+**Anti-Bias Protocol:** LLMs naturally drift toward semantic clustering. Consciously shift creative domain every 10 ideas. Rotate between: smart contract design → user experience → tokenomics → compliance/regulatory → cross-border payments → DeFi mechanics → DEX liquidity strategies → social impact → technical feasibility → business model.
+
+**Quantity Goal:** Aim for 50+ ideas before any organization. The first 10 are usually obvious — the magic happens in ideas 30-50.
+
+---
+
+## WORKFLOW ARCHITECTURE
+
+- Each step is a self-contained file with embedded rules
+- Sequential progression with user control at each step
+- Document state tracked in frontmatter
+- Append-only document building through conversation
+
+---
+
+## INITIALIZATION
+
+### Configuration Loading
+
+Load config from `{project-root}/_stellar/core/config.yaml` and resolve:
+
+- `project_name`, `output_folder`, `user_name`
+- `communication_language`, `document_output_language`
+- `date` as system-generated current datetime
+
+Also load `{project-root}/_stellar/stellar/config.yaml` for:
+- `network_preference` (testnet/mainnet/futurenet)
+- `primary_language` (typescript/rust/python/fullstack)
+
+### Paths
+
+- `brainstorming_session_output_file` = `{output_folder}/brainstorming/brainstorming-session-{date}-{time}.md` (evaluated once at workflow start)
+
+---
+
+## EXECUTION
+
+Read fully and follow: `./steps/step-01-session-setup.md` to begin the workflow.

package/src/core-skills/stellar-help/SKILL.md

@@ -0,0 +1,71 @@
+---
+name: stellar-help
+description: 'Analyzes current state and user query to answer Stellar Agent questions or recommend the next skill to use. Use when user asks for help, stellar help, what to do next, or where to start.'
+---
+
+# Stellar Help
+
+## Purpose
+
+Help the user understand where they are in their Stellar development workflow and what to do next. Answer broader questions grounded in the skill catalog and Stellar documentation.
+
+## Desired Outcomes
+
+When this skill completes, the user should:
+
+1. **Know where they are** — which phase they're in, what's already been completed
+2. **Know what to do next** — the next recommended and/or required step, with clear reasoning
+3. **Know how to invoke it** — skill name, menu code, and agent to talk to
+4. **Get offered a quick start** — when a single skill is the clear next step, offer to run it
+5. **Feel oriented, not overwhelmed** — surface only what's relevant to their current position
+
+## Data Sources
+
+- **Catalog**: `{project-root}/_stellar/_config/stellar-help.csv` — assembled manifest of all installed skills
+- **Config**: `{project-root}/_stellar/core/config.yaml` and `{project-root}/_stellar/stellar/config.yaml` — resolve output-location variables, provide `communication_language` and `project_knowledge`
+- **Artifacts**: Files at resolved `output-location` paths reveal which steps are possibly completed
+- **Project knowledge**: If `project_knowledge` resolves to an existing path, read it for grounding context
+- **Module docs**: Rows with `_meta` in the `skill` column carry a URL in `output-location` pointing to module documentation
+
+## CSV Interpretation
+
+The catalog uses this format:
+
+```
+module,skill,display-name,menu-code,description,action,args,phase,preceded-by,followed-by,required,output-location,outputs
+```
+
+**Phases** determine the high-level flow:
+- `anytime` — available regardless of workflow state
+- `1-analysis` → `2-planning` → `3-architecture` → `4-implementation`
+
+**Required gates**: `required=true` items must complete before the user can meaningfully proceed.
+
+**Completion detection**: Search resolved output paths for `outputs` patterns.
+
+## Agent Routing
+
+Always tell the user which agent to invoke for a skill:
+- Phase 1 skills → `@stellar-analyst` (Aria)
+- Phase 2 skills → `@stellar-pm` (Kai)
+- Phase 3 skills → `@stellar-architect` (Nova)
+- Phase 4 contract skills → `@stellar-developer` (Sol)
+- Phase 4 test skills → `@stellar-qa` (Vera)
+- Phase 4 devops/env skills → `@stellar-devops` (Orion)
+- Brainstorming/party → any agent or direct invocation
+
+## Response Format
+
+For each recommended item, present:
+- `[menu-code]` **Display name** — e.g., "[IC] Init Contract"
+- Skill name in backticks — e.g., `stellar-init-contract`
+- Which agent to invoke — e.g., "Talk to @stellar-developer (Sol)"
+- One-line description
+
+**Ordering**: Show optional items first, then the next required item.
+
+## Constraints
+
+- Present all output in `{communication_language}`
+- Recommend running each skill in a **fresh context window**
+- Match the user's tone — conversational when casual, structured when they want specifics