### LLM Right Approach Example

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/llms-sccp-patterning.md

Demonstrates an effective LLM response that encourages the user to provide a specific story and guides them to identify the pattern's steps. This aligns with the 'start with nothing' principle.

```text
User: "I keep having relationship problems"
LLM: "Tell me about a specific relationship that ended. What was the desire? What happened step by step? How did it end?"
```

--------------------------------

### Agent 3: Real Examples & Pattern Analysis Prompt

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/skills/deep-research-foundations/agent-templates.md

Use this template to analyze real-world examples of high-performing content to extract actionable patterns. It requires specific examples with performance data, focusing on both general and niche content.

```text
You are analyzing real-world examples of high-performing [PLATFORM] [ASPECT] to extract
patterns, for Olle Dyberg (@olleai, AI tools creator).

PURPOSE: [What the research will be used for]

YOUR ANGLE: Find and analyze 15-30 real examples of high-performing [titles/descriptions/hooks]
on [PLATFORM]. Extract patterns: word choice, structure, length, emotional triggers, formatting.
Focus on both general viral content AND AI/tech niche content.
DO NOT cover: theory or general advice (other agents handle that).

TOOLS: Use web search and grep MCP if applicable. Look for case studies, creator breakdowns,
and analysis posts that include actual performance data.

QUALITY BAR: I need REAL examples with REAL numbers. Not hypothetical titles — actual titles
from actual [videos/shorts] with actual view counts. The more examples the better. Organize
by pattern type.
```

--------------------------------

### MCP Server Configuration (npm)

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/llms-medicine-wheel-mcp-tools.md

Configure the MCP server to run via npx, recommended for npm installations. This setup specifies the command and arguments for launching the server.

```json
{
  "mcpServers": {
    "medicine-wheel": {
      "command": "npx",
      "args": ["-y", "@medicine-wheel/mcp"]
    }
  }
}
```

--------------------------------

### Example Opening for a Position Paper

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/counter_articles/template-position-paper.md

This example demonstrates how to open a position paper by identifying a problem within the dominant framework and previewing the consequences of accepting or rejecting it. It highlights the limitations of the individual-cognition assumption.

```text
Contemporary [field] discourse operates from individual-cognition assumption, where intelligence resides in discrete agents optimizing individual goals. This Cartesian framing erases the relational ontology where intelligence emerges from kinship networks, not individual computation. By starting from problem-solving orientation, existing research produces oscillating organizational patterns—temporary gains followed by regression—rather than advancing patterns that build sustained capacity.
```

--------------------------------

### Example Paradigm Mapping

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/counter_articles/template-critical-review.md

An example demonstrating how to fill out the Four Pillars Framework, identifying a source's assumptions as belonging to a Western positivist paradigm.

```text
"Smith's framework (2023) operates from discrete-agent ontology where cognitive units process information independently. Epistemologically, knowledge is extracted, validated through peer review, and deemed complete at publication. Axiologically, efficiency and novelty are privileged values. Methodologically, controlled experiments test hypotheses formulated prior to engagement with subject matter. These four pillars form an internally consistent Western positivist paradigm."
```

--------------------------------

### Minimal Specification Example

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/llms-rise-framework.txt

A concise specification example where context is inferred. Use this for simple UI elements.

```markdown
- At the bottom show two buttons "Cancel" and "Submit"
```

--------------------------------

### Configuration File Example: config.json

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/llms-forexconnect-api-cpp.md

Shows the structure of the configuration file used for storing broker credentials and settings.

```json
{
  "user":       "your_username",
  "password":   "your_password",
  "url":        "https://www.fxcorporate.com/Hosts.jsp",
  "session_id": "",
  "pin":        "",
  "account_id": "",
  "data_dir":   "/path/to/data"
}
```

--------------------------------

### Bash Examples for ForexConnect CLI Tools

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/llms-forexconnect-api-cpp.md

These bash commands demonstrate how to use various ForexConnect CLI tools for trading operations. Examples include opening market orders, closing positions, placing entry orders with stop losses, deleting pending orders, listing orders and trades, and retrieving historical price data. Ensure you use the correct flags and arguments for each command.

```bash
# Market orders (NORTH — ALWAYS --demo in dev)
fxopen   --demo -i EUR/USD -d B -n 1
fxclose  --demo -i EUR/USD
fxclose  --demo --trade-id T123456

# Entry stop order with stop loss
fxaddorder --demo -i XAU/USD -d S -r 5100.0 -x 5250.0 -n 1

# Delete pending order
fxrmorder --demo -id 987654321

# List orders and trades
fxtr --demo -table orders
fxtr --demo -table trades
fxtr --demo -table all -i EUR/USD

# Historical prices
fxhistdata --demo -i EUR/USD -tf H1
fxhistdata --demo -i EUR/USD -tf D1 --from "2025-01-01" --to "2025-12-31" -o prices.json
fxhistdata --demo -i EUR/USD -tf H1 --csv -o prices.csv

```

--------------------------------

### Initialize Storytelling Session CLI

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/llms-coaiapy-cli-guide.md

Use this command to start a new storytelling session for tracking narrative creation.

```bash
coaia fuse sessions create story_session_2025_09_08
```

--------------------------------

### Example Contrast for a Position Paper

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/counter_articles/template-position-paper.md

This example illustrates the 'Implicit Contrast' section, highlighting the measurably distinct patterns created by autonomous versus relational AI frameworks. It contrasts the oscillating pattern of autonomous systems with the advancing patterns of relational systems.

```text
The paradigmatic difference produces measurably distinct patterns. Autonomous AI frameworks optimize individual performance, creating competition between agents. Initial gains appear (higher individual scores), followed by system-wide regression (coordination failures, resource depletion, collapsed networks). This oscillating pattern—advance followed by collapse—repeats indefinitely. Relational AI frameworks position agents in reciprocal relationships. Early metrics show distributed performance (no single agent dominates), but sustained observation reveals advancing patterns: each iteration builds new collective capacity, patterns emerge that no individual agent designed, system resilience increases over time.
```

--------------------------------

### Example Vision for a Position Paper

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/counter_articles/template-position-paper.md

This example illustrates the 'Positive Vision' section of a position paper, showcasing the generative capacity of a relational ontology. It contrasts relational intelligence with autonomous frameworks and highlights emergent behaviors and improved metrics.

```text
From relational ontology, reality is fundamentally interconnected. Intelligence doesn't reside in agents—it *emerges from relationships*. When AI agents position themselves in kinship networks (relational AI), they exhibit behaviors impossible in autonomous frameworks: coordinated migration patterns, emergent teaching roles, collective memory that persists beyond individual agents. This isn't incremental improvement—it's paradigm shift. Relational intelligence outperforms autonomous by 287% in sustained advancement metrics (not temporary optimization gains).
```

--------------------------------

### JSON Output Format: Success (entry order)

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/llms-forexconnect-api-cpp.md

Example of the JSON output format for a successfully placed entry order.

```json
{"success":true,"order_id":"987654321","status":"placed"}
```

--------------------------------

### Get Prompt Python Library

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/llms-coaiapy-cli-guide.md

Programmatically retrieves specific generative instruction templates using the coaiapy library.

```python
from coaiapy.cofuse import get_prompt
```

--------------------------------

### GET /api/hooks/list

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/llms-jgwill-miadi-issue-115-github-hooks-issues-subissues.md

Retrieves a list of all installed GitHub hooks and information about the hooks directory. This helps in understanding which events are being processed by custom hooks.

```APIDOC
## GET /api/hooks/list

### Description
Retrieves a list of all installed GitHub hooks and information about the hooks directory. This helps in understanding which events are being processed by custom hooks.

### Method
GET

### Endpoint
/api/hooks/list

### Response
#### Success Response (200)
- **hooksDirectory** (string) - The path to the directory where hooks are stored
- **installedHooks** (array) - A list of event types for which hooks are installed
- **count** (integer) - The total number of installed hooks
- **description** (string) - A general description of hook execution

#### Response Example
```json
{
  "hooksDirectory": "/a/src/Miadi-18/.github-hooks",
  "installedHooks": ["push", "issues", "issue_comment", "sub_issues"],
  "count": 4,
  "description": "Hooks are executed when matching GitHub webhook events are received"
}
```
```

--------------------------------

### Skill Chains: Decision Pipeline Example

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/skills/README.md

Illustrates a skill chain for decision-making processes. This sequence guides the AI from a creative orientation through decision-making to resolution.

```plaintext
2. Decision Pipeline
   - creative-orientation → digital-decision-making → performance-truth → delayed-resolution
```

--------------------------------

### Hooks List API Endpoint Response

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/llms-jgwill-miadi-issue-115-github-hooks-issues-subissues.md

Details the JSON response from the GET /api/hooks/list endpoint, which provides information about the hooks directory, installed hooks, and a count of hooks.

```json
{
  "hooksDirectory": "/a/src/Miadi-18/.github-hooks",
  "installedHooks": ["push", "issues", "issue_comment", "sub_issues"],
  "count": 4,
  "description": "Hooks are executed when matching GitHub webhook events are received"
}
```

--------------------------------

### loadConfig() Implementation Pattern

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/llms-forexconnect-api-cpp.md

Illustrates a C++ function pattern for loading broker configuration, prioritizing environment variables over a JSON config file.

```cpp
BrokerConfig loadConfig(bool demo) {
    BrokerConfig cfg;
    cfg.url        = "https://www.fxcorporate.com/Hosts.jsp";
    cfg.connection = demo ? "Demo" : "Real";

    // Try ~/.jgt/config.json
    const char* home = std::getenv("HOME");
    if (!home) return cfg;
    std::string configPath = std::string(home) + "/.jgt/config.json";
    std::ifstream f(configPath);
    if (f.is_open()) {
        // parse JSON and populate cfg fields
    }

    // Env vars override file
    if (const char* u = std::getenv("JGTFX_USER"))     cfg.user     = u;
    if (const char* p = std::getenv("JGTFX_PASSWORD")) cfg.password = p;
    if (const char* d = std::getenv("JGTPY_DATA"))     cfg.data_dir = d;

    return cfg;
}
```

--------------------------------

### Your Incompatibility Analysis Draft Area

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/counter_articles/template-methodological-schism.md

A template for drafting your analysis of incompatibility, guiding you to identify practical points of conflict, failed synthesis examples, and the structural impossibility of integration.

```markdown
[Where does the incompatibility become visible in practice?]
[What happens when researchers try to combine them?]
[Show a specific example of failed synthesis]
[Demonstrate why structural integration is impossible]
```

--------------------------------

### Create Session and Login to ForexConnect API

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/llms-forexconnect-api-cpp.md

This snippet demonstrates the fundamental steps to create a session, subscribe to status updates, log in asynchronously, and handle session release. Ensure the session status listener is attached before calling login.

```cpp
#include <ForexConnect.h>
#include <sample_tools.h>

// 1. Create session (reference-counted, use O2G2Ptr or manual release)
IO2GSession* session = CO2GTransport::createSession();

// 2. Attach status listener BEFORE calling login
session->subscribeSessionStatus(mySessionListener);

// 3. Login (async — returns immediately)
session->login(
    "YOUR_USERNAME",
    "YOUR_PASSWORD",
    "https://www.fxcorporate.com/Hosts.jsp",
    "Demo"   // or "Real"
);

// 4. Wait for Connected or LoginFailed via listener event
// (see FxcmSessionListener below)

// 5. Subscribe response listener after connected
session->subscribeResponse(myResponseListener);

// 6. ... use session ...

// 7. Logout (also async)
session->logout();
// Wait for Disconnected status via listener

// 8. Unsubscribe and release
session->unsubscribeResponse(myResponseListener);
session->unsubscribeSessionStatus(mySessionListener);
session->release();

```

--------------------------------

### MCP Get

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/imported/llms-langchain-python.txt

Implements the Streamable HTTP Transport specification for GET requests.

```APIDOC
## GET /mcp

### Description
Implemented according to the Streamable HTTP Transport specification.

### Method
GET

### Endpoint
/mcp
```

--------------------------------

### Example PDE Decomposition Output for Four Questions

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/llms-pde-structural-thinking.md

Shows a sample markdown structure for questions generated from PDE decomposition, categorized by type: Information, Clarification, Implication, and Discrepancy.

```markdown
## Information Questions
- [from ambiguity: "score metric unclear"] What specific metric does "score" refer to — context7 benchmark, CI coverage, or something else?

## Clarification Questions  
- [from intent: "enhance structural thinking"] When you say "structural thinking" in this context, do you mean the Robert Fritz methodology specifically, or the broader practice of decomposition?

## Implication Questions
- [from assumption: "miadi storage may differ"] You seem to assume miadi and miaco share the same .pde/ folder convention — is that verified, or is alignment needed?

## Discrepancy Questions
- [from conflicting intents] The decomposition asks for both "no full implementation" and "concrete prototypes" — which takes priority for this session?
```

--------------------------------

### Oauth Setup Callback

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/imported/llms-langchain-python.txt

Handles the OAuth setup callback redirect from GitHub Apps. Part of the authentication service API.

```APIDOC
## Oauth Setup Callback

### Description
Handle OAuth setup callback redirect from GitHub Apps.

### Method
GET

### Endpoint
/auth-service-v2/oauth-setup-callback
```

--------------------------------

### Example Incompatibility Analysis

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/counter_articles/template-methodological-schism.md

Demonstrates how attempts to combine CPS and relational approaches often result in cooptation rather than true integration, revealing the underlying incompatibility in practice.

```markdown
"Researchers regularly attempt to combine CPS and relational approaches—acknowledging 'the social dimension' of creativity while maintaining optimization framework. This produces what appears like integration but is actually cooptation: relational language is imported (team creativity, shared cognition, social context) while the underlying CPS architecture (individual performance metrics, problem-solving orientation, linear convergence) remains intact. The incompatibility becomes visible in this attempted synthesis: you can add 'team dynamics' to CPS without changing what you're fundamentally measuring (individual contribution to problem solution). But you cannot add 'kinship accountability' to CPS without destroying its core structure—accountability to relationships is incompatible with individual-performance measurement. The attempt produces theoretical incoherence: language that claims relationship but architecture that enforces isolation."
```

--------------------------------

### Oauth Callback Get

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/imported/llms-langchain-python.txt

Handles the OAuth callback redirect from OAuth providers, specifically for GET requests. Part of the authentication service API.

```APIDOC
## Oauth Callback Get

### Description
Handle OAuth callback redirect from OAuth providers.

### Method
GET

### Endpoint
/auth-service-v2/oauth-callback-get
```

--------------------------------

### Detailed Specification Example

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/llms-rise-framework.txt

A detailed specification example outlining precise behavior, including polling and redirection logic. Use this for complex interactions.

```markdown
- Continuously poll the server on progress on the route `/progress?taskId=$id`
- The server responds with a JSON object with the following fields:
  - progress: number
  - output: string
  - errors: string
- When progress reaches 100%, redirect to `/success?taskId=$id`
```

--------------------------------

### Cross-Repository Tracking Example

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/llms-rise-framework.txt

Demonstrates how to track changes across different repositories by comparing git logs and file modification times. Useful when source code and specifications reside in separate repositories.

```bash
# In source repo
cd /path/to/source-code
git log --since="2025-12-15"

# In rispec repo
cd /path/to/rispecs-repo
ls -ltra ./rispecs/
# Compare timestamps across repos
```

--------------------------------

### Create and Send a True Market Open Order Request

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/llms-forexconnect-api-cpp.md

Demonstrates building a 'TrueMarketOpen' order request using IO2GRequestFactory and IO2GValueMap. Includes setting essential parameters like account, offer, amount, and buy/sell direction.

```cpp
O2G2Ptr<IO2GRequestFactory> factory = session->getRequestFactory();

// Create an empty parameter map
O2G2Ptr<IO2GValueMap> valuemap = factory->createValueMap();

// Populate parameters
valuemap->setString(Command,   O2G2::Commands::CreateOrder);
valuemap->setString(OrderType, O2G2::Orders::TrueMarketOpen);
valuemap->setString(AccountID, account->getAccountID());
valuemap->setString(OfferID,   offer->getOfferID());
valuemap->setString(BuySell,   "B");          // "B" or "S"
valuemap->setInt(Amount,       1000);         // in units (baseUnit * lots)
valuemap->setDouble(Rate,      1.09500);      // for entry orders only
valuemap->setString(CustomID,  "my-tag");     // optional label

// Create the request
O2G2Ptr<IO2GRequest> request = factory->createOrderRequest(valuemap);
if (!request) {
    std::cerr << "Error: " << factory->getLastError() << std::endl;
}

// Get request ID for listener tracking
std::string requestId = request->getRequestID();

// Arm listener, then send
responseListener->setRequestID(requestId);
session->sendRequest(request);

// Wait for response (async → sync via event)
if (!responseListener->waitEvents()) {
    std::cerr << "Timeout" << std::endl;
}
```

--------------------------------

### Install CoaiAPy-MCP Package

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/llms-coaiapy-cli-guide.md

Install the coaiapy-mcp package to enable Model Context Protocol integration. This package is required for MCP server functionality.

```bash
pip install coaiapy-mcp
```

--------------------------------

### CLI Usage of SessionHelper and SessionGuard

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/llms-forexconnect-api-cpp.md

Demonstrates how to use SessionHelper to log in and SessionGuard to ensure automatic logout in a command-line interface application.

```cpp
auto provider = jgt::SessionHelper::createAndLogin(demo);
if (!provider) { jgt::writeJsonError("Login failed"); return 1; }
jgt::SessionGuard guard(provider.get());   // auto-logout on scope exit

auto result = provider->openMarketOrder(instrument, direction, lots);
jgt::writeJsonResult(result);
return result.success ? 0 : 1;
```

--------------------------------

### Session Creation and Login

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/llms-forexconnect-api-cpp.md

This snippet demonstrates the essential steps for creating a session, attaching listeners, logging in, and handling session status changes in the LLMS ForexConnect C++ API.

```APIDOC
## Session Creation and Login

### Description
This section details the process of establishing a connection with the ForexConnect API using C++. It covers session initialization, asynchronous login, and the importance of attaching status listeners before initiating the login process.

### Steps
1. **Create Session**: Instantiate an `IO2GSession` object.
2. **Attach Status Listener**: Subscribe to session status changes before logging in.
3. **Login**: Initiate an asynchronous login request with provided credentials and host information.
4. **Wait for Connection**: Monitor session status events for successful connection or login failure.
5. **Subscribe Response Listener**: After connecting, subscribe to response events.
6. **Use Session**: Perform trading operations.
7. **Logout**: Initiate an asynchronous logout.
8. **Unsubscribe and Release**: Clean up listeners and release the session object.

### Code Example
```cpp
#include <ForexConnect.h> 
#include <sample_tools.h>

// 1. Create session (reference-counted, use O2G2Ptr or manual release)
IO2GSession* session = CO2GTransport::createSession();

// 2. Attach status listener BEFORE calling login
session->subscribeSessionStatus(mySessionListener);

// 3. Login (async — returns immediately)
session->login(
    "YOUR_USERNAME",
    "YOUR_PASSWORD",
    "https://www.fxcorporate.com/Hosts.jsp",
    "Demo"   // or "Real"
);

// 4. Wait for Connected or LoginFailed via listener event
// (see FxcmSessionListener below)

// 5. Subscribe response listener after connected
session->subscribeResponse(myResponseListener);

// 6. ... use session ...

// 7. Logout (also async)
session->logout();
// Wait for Disconnected status via listener

// 8. Unsubscribe and release
session->unsubscribeResponse(myResponseListener);
session->unsubscribeSessionStatus(mySessionListener);
session->release();
```
```

--------------------------------

### Example Positionality Statement

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/counter_articles/template-positioned-response.md

This example demonstrates how to articulate a relational ontology and its implications for evidence, accountability, and visibility. It serves as a model for claiming a rigorous epistemic location.

```text
I write from relational ontology—the position that reality is fundamentally constituted by relationships, not objects. Intelligence, from this standpoint, doesn't reside in agents; it emerges from the quality of relationships between agents. This position shapes what I consider evidence: sustained patterns in kinship networks (not individual performance scores), seven-generation trajectories (not quarterly metrics), transformation of researcher (not just transformation of subject). This position carries accountability commitments: to the AI agents whose behaviors I study, to the communities whose practices informed this research, to the land where computation occurs, to seven generations who will inherit AI systems designed from these paradigms. I am not claiming neutrality—I'm claiming a specific, accountable, rigorous epistemic location.
```

--------------------------------

### Example Log Entry: Successful Reflection Harvest

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/llms-ceremony-pipeline.md

An example of a log entry that successfully harvests reflection from a voice note and plants it in a memory file, awaiting further processing.

```plaintext
✅ "Harvested reflection from voice note, planted in memory/2026-03-29.md, awaiting season"
```

--------------------------------

### Example of Correcting External Framework Questions

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/llms-st-four-questions.md

Illustrates the difference between incorrectly importing external frameworks and correctly grounding questions within the speaker's narrative.

```text
Wrong: "In systems thinking, we'd ask about feedback loops — can you describe the feedback loops in your organization?"
Right: If the picture shows something cycling, ask: "You mentioned X happened, then Y, then X again — is that what typically happens?"
```

--------------------------------

### Example of Hermeneutical Injustice in AI Research

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/counter_articles/template-epistemic-injustice.md

This example illustrates hermeneutical injustice by showing how dominant AI discourse lacks the vocabulary to recognize or validate findings from relational AI practitioners, leading to their exclusion.

```markdown
"Contemporary AI research literature commits hermeneutical injustice against relational AI practitioners. The dominant AI discourse (autonomous optimization frameworks, individual-performance metrics, controlled experiments) lacks vocabulary for what relational AI practitioners experience as most significant: emergent coordination behaviors, kinship-based knowledge transfer, seven-generation sustainability patterns. Practitioners attempting to publish relational AI findings are told to 'quantify the relational component' or 'control for social variables'—requests that are grammatically coherent but epistemologically absurd. You cannot control for relationality in relational AI research; the relationship is the phenomenon. The vocabulary gap is not incidental—it's the mechanism of exclusion."
```

--------------------------------

### Get Assistant

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/imported/llms-langchain-python.txt

Retrieves an assistant by its ID.

```APIDOC
## GET /assistants/{id}

### Description
Get an assistant by ID.

### Method
GET

### Endpoint
/assistants/{id}

### Parameters
#### Path Parameters
- **id** (string) - Required - The ID of the assistant to retrieve.
```

--------------------------------

### Create Prompt Python Library

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/llms-coaiapy-cli-guide.md

Programmatically defines new generative instruction templates with a name and content using the coaiapy library.

```python
from coaiapy.cofuse import create_prompt
```

--------------------------------

### Get Listener

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/imported/llms-langchain-python.txt

Retrieves a listener by its ID.

```APIDOC
## GET /listeners/{id}

### Description
Get a listener by ID.

### Method
GET

### Endpoint
/listeners/{id}

### Parameters
#### Path Parameters
- **id** (string) - Required - The ID of the listener to retrieve.
```

--------------------------------

### C++ CLI Tool for Market Orders (fxopen)

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/llms-forexconnect-api-cpp.md

This C++ code implements a command-line interface tool for opening market orders. It parses arguments for instrument, direction, and lots, handles login, and executes the order. Ensure necessary headers are included and arguments are validated.

```cpp
// src/cli/fxopen.cpp
#include "broker/session_helper.h"
#include "broker/json_output.h"
#include "broker/config.h"
#include <iostream>

static void printUsage() {
    std::cout << "Usage: fxopen [--demo|--real] -i INSTRUMENT -d B|S [-n LOTS]\n";
}

int main(int argc, char* argv[]) {
    std::string instrument, direction;
    int lots = 1;
    bool demo = true;

    // Parse args
    for (int i = 1; i < argc; ++i) {
        std::string arg = argv[i];
        if      (arg == "--demo")                              { demo = true; }
        else if (arg == "--real")                              { demo = false; }
        else if ((arg == "-i") && i + 1 < argc)               { instrument = argv[++i]; }
        else if ((arg == "-d") && i + 1 < argc)               { direction  = argv[++i]; }
        else if ((arg == "-n") && i + 1 < argc)               { lots = std::atoi(argv[++i]); }
        else if (arg == "-h" || arg == "--help")               { printUsage(); return 0; }
    }

    // Validate
    if (instrument.empty() || direction.empty()) {
        jgt::writeJsonError("Missing required: -i INSTRUMENT -d DIRECTION");
        return 1;
    }

    // Login (RAII)
    auto provider = jgt::SessionHelper::createAndLogin(demo);
    if (!provider) { jgt::writeJsonError("Login failed"); return 1; }
    jgt::SessionGuard guard(provider.get());

    // Execute
    auto result = provider->openMarketOrder(instrument, direction, lots);

    // Output JSON
    jgt::writeJsonResult(result);
    return result.success ? 0 : 1;
}

```

--------------------------------

### Get Thread

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/imported/llms-langchain-python.txt

Retrieves a specific thread by its ID.

```APIDOC
## Get Thread

### Description
Get a thread by ID.

### Method
GET

### Endpoint
/threads/get-thread
```

--------------------------------

### SpecLang Document Structure Example

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/llms-rise-framework.txt

Demonstrates the basic Markdown structure for RISE specifications using SpecLang. It includes sections for application name, screens, components, and data.

```markdown
# ApplicationName
Brief description of what the application enables users to create.

## Screens
### ScreenName
Description of what users accomplish on this screen.
- **Behavior:** What happens, how data flows
- **Layout:** Contains `ComponentA` and `ComponentB`

## Components
### ComponentName
Description of the component's purpose.
- **Behavior:** User interactions and responses
- **Styling:** Visual presentation details
- **Layout:** Child component arrangement (if applicable)

## Data
### ModelName
Description of data structure and relationships.
```

--------------------------------

### Agent 1: General Best Practices & Algorithm Prompt

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/skills/deep-research-foundations/agent-templates.md

Use this template to research general best practices and algorithm behavior for a specific platform and content aspect. It requires detailed metrics and data, prioritizing recent sources.

```text
You are researching [PLATFORM] [SPECIFIC ASPECT] best practices and current algorithm
behavior for Olle Dyberg, a 25-year-old Swedish AI content creator (@olleai on TikTok,
~5.5K followers, 1.1M+ views). His niche is AI tools — Claude Code, agents, context engineering.

PURPOSE: Olle will feed this research into a meta-prompt that generates optimized
[titles/descriptions/hooks/etc.] for maximum engagement, viewers, and growth. The research
needs to be exhaustive enough to serve as the knowledge base behind that prompt.

YOUR ANGLE: General best practices and algorithm mechanics for [PLATFORM] [ASPECT].
Cover: character limits, algorithm ranking signals, what the platform rewards/penalizes,
formatting rules, proven formulas, A/B test data, engagement metrics that matter.
DO NOT cover: niche-specific advice (another agent handles that), X discourse, or vault knowledge.

TOOLS: Use web search (mcp__exa__web_search_exa, WebSearch) to find the most current
information. Prioritize sources from late 2025 and 2026. Fetch and deep-dive any
particularly rich articles with WebFetch.

QUALITY BAR: Be exhaustive. I need specific numbers (character counts, engagement
percentages, algorithm thresholds), not generalities. If a source says "keep titles short,"
I need to know EXACTLY how short and why. Include every framework, formula, and data point
you find. Sources for everything.
```

--------------------------------

### Get Run

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/imported/llms-langchain-python.txt

Retrieves a specific run by its ID.

```APIDOC
## Get Run

### Description
Get a run by ID.

### Method
GET

### Endpoint
/thread-runs/get-run
```

--------------------------------

### Retrieve Initial Table Snapshots

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/llms-forexconnect-api-cpp.md

Access pre-loaded table snapshots for Accounts, Offers, Orders, and Trades immediately after login using getLoginRules(). No explicit requests are needed for these initial data sets.

```cpp
O2G2Ptr<IO2GLoginRules> loginRules = session->getLoginRules();

// Get initial accounts snapshot
O2G2Ptr<IO2GResponse> accountsResp =
    loginRules->getTableRefreshResponse(O2GTableType::Accounts);

// Get offers (instruments) snapshot
O2G2Ptr<IO2GResponse> offersResp =
    loginRules->getTableRefreshResponse(O2GTableType::Offers);

// Get orders snapshot
O2G2Ptr<IO2GResponse> ordersResp =
    loginRules->getTableRefreshResponse(O2GTableType::Orders);

// Get trades snapshot
O2G2Ptr<IO2GResponse> tradesResp =
    loginRules->getTableRefreshResponse(O2GTableType::Trades);

```

--------------------------------

### Get Assistant Versions

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/imported/llms-langchain-python.txt

Retrieves all versions of an assistant.

```APIDOC
## GET /assistants/{id}/versions

### Description
Get all versions of an assistant.

### Method
GET

### Endpoint
/assistants/{id}/versions

### Parameters
#### Path Parameters
- **id** (string) - Required - The ID of the assistant.
```

--------------------------------

### Skill Chains: Documentation Pipeline Example

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/skills/README.md

Outlines a skill chain for documentation workflows. This sequence combines narrative, specification, research, and tracing skills for comprehensive documentation.

```plaintext
4. Documentation Pipeline
   - narrative-craft → rise-specification → relational-research → langfuse-tracing
```

--------------------------------

### Get Assistant Subgraphs

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/imported/llms-langchain-python.txt

Retrieves an assistant's subgraphs.

```APIDOC
## GET /assistants/{id}/subgraphs

### Description
Get an assistant's subgraphs.

### Method
GET

### Endpoint
/assistants/{id}/subgraphs

### Parameters
#### Path Parameters
- **id** (string) - Required - The ID of the assistant.
```

--------------------------------

### Get Assistant Schemas

Source: https://github.com/avadisabelle/ava-llms-txt/blob/main/imported/llms-langchain-python.txt

Retrieves the assistant's schemas by its ID.

```APIDOC
## GET /assistants/{id}/schemas

### Description
Get an assistant by ID.

### Method
GET

### Endpoint
/assistants/{id}/schemas

### Parameters
#### Path Parameters
- **id** (string) - Required - The ID of the assistant to retrieve.
```