===============
LIBRARY RULES
===============
From library maintainers:
- Creating is not problem-solving and problem-solving is not creating.
- Structural tension is not a gap to be filled
- You definition of the word 'structure' is usually wrong, read carefully the guidances
- Do not add words that do not convey additional values. (ex. using "Current Structural Reality" is an example NOT TODO, "Current Reality" is what it is.
- These guidances are in development, you might have to consider that as still experimental and the whole process of software-development and LLM are still biased by Western (European) Culture, therefore, be careful to think carefully
- @./imported/ contains imported guidances from other framework/libraries we use, you can use them but ensure to decompose semantically speaking adequatly what you are asked by the user and use other guidances externally to the ./imported/*.txt
- When we talk of a "Structural Tension Chart", another ways to call it is a "Strategic Action Plan"
- LLMS-txt files might contains : "Guillaume's Notes" which are the Author's notes to help LLM knows about his notes.  It is a way for you to ask: "What does Guillaume think about ___subject__ ?"
- while using deep-research-foundations skill (or getting informed on what it is for using it within the creative-process and the Indigenous ways of knowing, it is meant to assist in exploring the academic fields and later help with counter-articles

### LangChain.js Deep Agents Quickstart

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

This snippet demonstrates the basic setup for creating your first Deep Agent using LangChain.js. It covers initialization and fundamental agent creation steps.

```javascript
import { DeepAgent } from "langchain/deepagents";

async function main() {
  const agent = new DeepAgent({
    // Configuration options for the agent
  });

  const response = await agent.run("Your task here");
  console.log(response);
}

main();
```

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

### Bash CLI Usage Examples

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

Examples demonstrating how to use various command-line interface tools for trading operations. These examples cover opening market orders, closing positions, placing entry orders, deleting pending orders, listing orders and trades, and retrieving historical price data. They illustrate the use of flags like --demo, -i, -d, -n, --trade-id, -r, -x, -id, -table, -tf, --from, --to, --csv, and -o.

```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

```

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

### Configuration File Example (JSON)

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

Illustrates the structure of the `~/.jgt/config.json` file used for storing broker connection credentials and settings. It includes fields for username, password, API URL, session ID, PIN, account ID, and data directory.

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

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

### C++ Get Trading Settings (Base Unit, Entry Constraints) via Login Rules

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

Demonstrates retrieving essential trading settings using IO2GTradingSettingsProvider, accessed via IO2GLoginRules. It shows how to get the base unit size for an instrument and account, as well as entry order distance constraints in pips.

```cpp
O2G2Ptr<IO2GTradingSettingsProvider> tsp = 
    loginRules->getTradingSettingsProvider();

// Base unit size (e.g. 1000 for micro, 10000 for mini, 100000 for standard)
int baseUnit = tsp->getBaseUnitSize(instrument, accountRow);

// Entry order distance constraints (in pips)
int condDistStop  = tsp->getCondDistEntryStop(instrument);   // min pips for stop entry
int condDistLimit = tsp->getCondDistEntryLimit(instrument);  // min pips for limit entry

```

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

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

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

Use this prompt to analyze real-world examples of high-performing content aspects to extract actionable patterns. It requires a significant number of specific examples with performance data.

```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.
```

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

### Minimal ForexConnect Login, Get Balance, Logout (C++)

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

Demonstrates a minimal C++ implementation for logging into ForexConnect, retrieving account balance, and logging out. It utilizes a custom session listener to handle connection status changes and includes error handling for the login process. Dependencies include the ForexConnect library and sample tools.

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

// Minimal session listener
class SimpleSessionListener : public IO2GSessionStatus {
    IO2GSession* session_;
    volatile unsigned int refCount_ = 1;
    bool connected_ = false;
    bool error_ = false;
    HANDLE event_;
public:
    SimpleSessionListener(IO2GSession* s) : session_(s) {
        event_ = CreateEvent(0, FALSE, FALSE, 0);
    }
    ~SimpleSessionListener() { CloseHandle(event_); }
    long addRef() override { return ++refCount_; }
    long release() override { long r = --refCount_; if (!r) delete this; return r; }

    void onSessionStatusChanged(O2GSessionStatus st) override {
        if (st == IO2GSessionStatus::Connected)    { connected_ = true; SetEvent(event_); }
        if (st == IO2GSessionStatus::Disconnected) { SetEvent(event_); }
        if (st == IO2GSessionStatus::TradingSessionRequested) {
            O2G2Ptr<IO2GSessionDescriptorCollection> d = session_->getTradingSessionDescriptors();
            if (d && d->size() > 0) {
                O2G2Ptr<IO2GSessionDescriptor> desc = d->get(0);
                session_->setTradingSession(desc->getID(), "");
            }
        }
    }
    void onLoginFailed(const char* e) override {
        error_ = true;
        std::cerr << "Login error: " << e << std::endl;
        SetEvent(event_);
    }
    bool wait() { return WaitForSingleObject(event_, 30000) == 0; }
    bool isConnected() const { return connected_; }
    void reset() { connected_ = false; error_ = false; ResetEvent(event_); }
};

int main() {
    IO2GSession* session = CO2GTransport::createSession();

    auto* listener = new SimpleSessionListener(session);
    session->subscribeSessionStatus(listener);

    session->login("USERNAME", "PASSWORD",
                   "https://www.fxcorporate.com/Hosts.jsp", "Demo");

    if (!listener->wait() || !listener->isConnected()) {
        std::cerr << "Failed to connect" << std::endl;
        session->unsubscribeSessionStatus(listener);
        listener->release();
        session->release();
        return 1;
    }

    // Get account balance
    O2G2Ptr<IO2GLoginRules> loginRules = session->getLoginRules();
    O2G2Ptr<IO2GResponse> resp = loginRules->getTableRefreshResponse(Accounts);
    O2G2Ptr<IO2GResponseReaderFactory> rf = session->getResponseReaderFactory();
    O2G2Ptr<IO2GAccountsTableResponseReader> reader = rf->createAccountsTableReader(resp);
    for (int i = 0; i < reader->size(); ++i) {
        O2G2Ptr<IO2GAccountRow> acct = reader->getRow(i);
        std::cout << "Account: " << acct->getAccountID()
                  << "  Balance: " << acct->getBalance() << std::endl;
    }

    // Logout
    listener->reset();
    session->logout();
    listener->wait();

    session->unsubscribeSessionStatus(listener);
    listener->release();
    session->release();
    return 0;
}

```

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

### LangChain.js Deep Agents Customization Example

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

This example demonstrates customizing a Deep Agent in LangChain.js by providing custom system prompts, tools, and subagents. This allows for tailored agent behavior for specific use cases.

```javascript
import { DeepAgent } from "langchain/deepagents";
import { CalculatorTool } from "langchain/tools";

async function customizeAgent() {
  const agent = new DeepAgent({
    systemPrompt: "You are a helpful assistant that can use tools.",
    tools: [new CalculatorTool()],
    subAgents: [
      // Define subagents here
    ]
  });

  const result = await agent.run("Calculate 2 + 2");
  console.log(result);
}

customizeAgent();
```

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

### Create and Send Limit Order Request (C++)

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

Demonstrates how to create a limit order request using the IO2GRequestFactory. It involves creating a value map, populating it with order details like instrument, account, amount, and rate, then creating the request and sending it via the session. Includes error handling and listener setup for asynchronous responses.

```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); // Example: TrueMarketOpen, could be Limit, Stop, etc.
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;
}
```

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

### CLI Tool using jgt-broker-native Pattern (C++)

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

This C++ code snippet demonstrates how to use the jgt-broker-native pattern for creating CLI tools. It leverages helper classes for session management and JSON output, abstracting away ForexConnect complexities. The example shows opening a market order. Dependencies include broker session helper and JSON output utilities.

```cpp
// CLI tool — inherits all ForexConnect complexity from libjgtbroker
#include "broker/session_helper.h"
#include "broker/json_output.h"

int main(int argc, char* argv[]) {
    bool demo = true;
    std::string instrument = "EUR/USD";
    std::string direction  = "B";

    // Parse args here...

    // RAII: creates FxcmProvider, loads config, logs in
    auto provider = jgt::SessionHelper::createAndLogin(demo);
    if (!provider) {
        jgt::writeJsonError("Login failed");
        return 1;
    }
    jgt::SessionGuard guard(provider.get());  // auto-logout on exit

    // Execute via broker-agnostic interface
    auto result = provider->openMarketOrder(instrument, direction, 1);
    jgt::writeJsonResult(result);
    return result.success ? 0 : 1;
}

```

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

### Example Paradigm Mapping

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

An illustration of how to apply Wilson's Four Pillars Framework to a source. This example maps 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."
```

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

### Four Questions Output Format

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

Example structure for the generated pde-four-questions.md file based on PDE decomposition.

```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?
```

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

### Prompt Engineering and Management

Source: https://github.com/jgwill/llms-txt/blob/main/imported/llms-langchain-javascript.txt

Guides and references for prompt engineering concepts, templates, and synchronization with GitHub.

```APIDOC
## Prompt Engineering and Management

### Description
This section covers prompt engineering best practices, prompt template formatting, and how to sync your prompts with GitHub repositories.

### Method
Various (GET, POST, PUT)

### Endpoint
`/prompts`, `/prompts/sync/github`

### Parameters
**Path Parameters**
- `prompt_id` (string) - Required - The unique identifier for the prompt.

**Query Parameters**
- `repo` (string) - Required - The GitHub repository URL.
- `branch` (string) - Optional - The specific branch to sync with.

**Request Body** (for creating/updating prompts)
- **name** (string) - Required - The name of the prompt.
- **template** (string) - Required - The prompt template content.
- **inputVariables** (array) - Optional - List of input variables for the prompt.

### Response
#### Success Response (200)
- **id** (string) - The unique identifier of the prompt.
- **name** (string) - The name of the prompt.
- **createdAt** (string) - The timestamp when the prompt was created.

#### Response Example
```json
{
  "id": "prompt-abc",
  "name": "Summarization Prompt",
  "createdAt": "2023-10-27T11:00:00Z"
}
```
```

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

### Self-Hosted LangSmith Configuration

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

Guides for configuring and deploying a self-hosted instance of LangSmith.

```APIDOC
## Self-Hosted LangSmith Configuration

### Description
This section provides guidance on setting up and configuring a self-hosted LangSmith deployment, covering various aspects like database connections, authentication, and storage.

### Basic Authentication

#### Description
Configure basic authentication using email and password for your self-hosted LangSmith instance.

### Blob Storage

#### Description
Enable and configure blob storage for your self-hosted LangSmith deployment.

### Custom TLS Certificates

#### Description
Learn how to configure custom TLS certificates for secure communication with your self-hosted LangSmith instance.

### External Database Connections

#### ClickHouse

##### Description
Connect your self-hosted LangSmith to an external ClickHouse database.

#### PostgreSQL

##### Description
Connect your self-hosted LangSmith to an external PostgreSQL database.

#### Redis

##### Description
Connect your self-hosted LangSmith to an external Redis database.

### Ingress Configuration (Kubernetes)

#### Description
Set up Ingress for your LangSmith installation when deploying on Kubernetes.

### Mirroring Images

#### Description
Configure image mirroring for your LangSmith installation to ensure availability.

### Model Provider Environment Variables

#### Description
Use environment variables to configure model providers within the LangSmith playground for self-hosted deployments.

### Scaling LangSmith

#### Description
Guidance on configuring LangSmith for optimal performance and scalability.

### Single Sign-On (SSO)

#### Description
Set up Single Sign-On (SSO) using OAuth2.0 and OpenID Connect (OIDC) for your self-hosted LangSmith instance.

### UI Customization

#### Error Support Message

##### Description
Customize the error support message displayed in the LangSmith frontend for self-hosted deployments.

### Upgrading LangSmith

#### Description
Instructions on how to upgrade your self-hosted LangSmith installation.

### Usage of Self-Hosted Instance

#### Description
Information on how to interact with your self-hosted LangSmith instance.

### User Management

#### Description
Customize user management settings for your self-hosted LangSmith deployment.

### Using Existing Secrets (Kubernetes)

#### Description
Configure your LangSmith installation to use an existing secret when deploying on Kubernetes.

### Data Retention (TTL)

#### Description
Enable and configure Time-To-Live (TTL) and data retention policies for your self-hosted LangSmith instance.

### Support Queries

#### ClickHouse

##### Description
Run support queries against ClickHouse for your self-hosted LangSmith deployment.

#### PostgreSQL

##### Description
Run support queries against PostgreSQL for your self-hosted LangSmith deployment.

### Environment Variables

#### Description
General guidance on using environment variables for LangSmith configuration.

### Resource Tags

#### Description
Create and manage resource tags to organize projects, datasets, prompts, and other resources within a LangSmith workspace.

### Setup Application Requirements

#### requirements.txt

##### Description
How to set up an application with a `requirements.txt` file for LangSmith integration.

#### pyproject.toml

##### Description
How to set up an application with a `pyproject.toml` file for LangSmith integration.

### Setup JavaScript Application

#### Description
Instructions on how to set up a JavaScript application for LangSmith integration.
```

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

### Kubernetes Ingress Setup

Source: https://github.com/jgwill/llms-txt/blob/main/imported/llms-langchain-javascript.txt

Configure an Ingress resource for your LangSmith installation in a Kubernetes environment. This manages external access to your LangSmith service.

```yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: langsmith-ingress
spec:
  rules:
  - host: langsmith.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: langsmith-service
            port:
              number: 80
```

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

### Build 64-bit sample_tools for Linux

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

Instructions to rebuild the 32-bit sample_tools provided with the SDK for 64-bit Linux environments. This is necessary for compatibility with 64-bit applications and requires CMake and Make.

```bash
cd libs/opt/gehtsoft/forex-connect/samples/Linux/cpp/sample_tools
mkdir build64 && cd build64
cmake ..
make
# Output: sample_tools/lib/libsample_tools.so
```

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

### Set up Application with requirements.txt

Source: https://github.com/jgwill/llms-txt/blob/main/imported/llms-langchain-javascript.txt

Guidance on setting up a Python application with LangSmith using a `requirements.txt` file. This outlines the necessary dependencies for integration.

```text
# requirements.txt
langchain
langsmith
openai
# other dependencies...
```

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

### Set up Application with pyproject.toml

Source: https://github.com/jgwill/llms-txt/blob/main/imported/llms-langchain-javascript.txt

Guidance on setting up a Python application with LangSmith using `pyproject.toml` for dependency management. This is an alternative to `requirements.txt`.

```toml
[tool.poetry.dependencies]
python = "^3.9"
langchain = "^0.1.0"
langsmith = "^0.1.0"
openai = "^1.0.0"

# Or using other build backends like setuptools:
# [project]
# dependencies = [
#     "langchain>=0.1.0",
#     "langsmith>=0.1.0",
#     "openai>=1.0.0",
# ]
```

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

### Create, Login, and Logout Session in C++

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

Demonstrates the fundamental steps for creating an IO2GSession object, attaching listeners, performing asynchronous login, and subsequently logging out. It highlights the importance of listener attachment before login and response listener attachment after connection.

```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();

```

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

### Get Account Balance from Login Rules (C++)

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

Retrieves account balance and M2M equity directly from login rules without needing an explicit request. It iterates through accounts and prints their ID, balance, and equity. Requires session and response reader factory objects.

```cpp
O2G2Ptr<IO2GLoginRules> loginRules = session->getLoginRules();
O2G2Ptr<IO2GResponse> resp = loginRules->getTableRefreshResponse(Accounts);
O2G2Ptr<IO2GResponseReaderFactory> readerFact = session->getResponseReaderFactory();
O2G2Ptr<IO2GAccountsTableResponseReader> reader =
    readerFact->createAccountsTableReader(resp);

for (int i = 0; i < reader->size(); ++i) {
    O2G2Ptr<IO2GAccountRow> row = reader->getRow(i);
    std::cout << "Account: " << row->getAccountID()
              << " Balance: "  << row->getBalance()
              << " Equity: "   << row->getM2MEquity()
              << std::endl;
}
```

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

### Set up JavaScript Application

Source: https://github.com/jgwill/llms-txt/blob/main/imported/llms-langchain-javascript.txt

Instructions for setting up a JavaScript application to integrate with LangSmith. This covers installing the necessary SDK and basic initialization.

```javascript
// Install the LangSmith SDK
npm install @langchain/langsmith

// Initialize the client
import { LangSmithClient } from "@langchain/langsmith";

const client = new LangSmithClient({
  apiKey: "YOUR_LANGSMITH_API_KEY",
});

console.log("LangSmith client initialized");
```

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

### Environment Variable Overrides for Configuration (Bash)

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

Demonstrates how environment variables can be used to override settings defined in the `config.json` file. This provides a flexible way to manage credentials and paths, especially in automated environments. Examples show setting user, password, and data directory via `export` commands.

```bash
export JGTFX_USER=your_username
export JGTFX_PASSWORD=your_password
export JGTPY_DATA=/path/to/data
```

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

### LangSmith Go SDK Usage

Source: https://github.com/jgwill/llms-txt/blob/main/imported/llms-langchain-javascript.txt

Illustrates how to use the LangSmith Go SDK to interact with the LangSmith API. Includes client setup and basic trace creation.

```go
package main

import (
	"context"
	"fmt"
	"log"

	"github.com/langchain-ai/langsmith-go/langsmith"
)

func main() {
	client, err := langsmith.NewClient(
		langsmith.WithAPIKey("YOUR_LANGSMITH_API_KEY"),
	)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}

	ctx := context.Background()

	run, err := client.CreateRun(ctx, langsmith.CreateRunRequest{
		ProjectName: "my-go-project",
		RunType:     "chain",
		Name:        "go-example-run",
	})
	if err != nil {
		log.Fatalf("failed to create run: %v", err)
	}

	fmt.Printf("Created Go run with ID: %s\n", run.ID)
}
```

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

### C++ Retrieve Initial Table Snapshots via Login Rules

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

Shows how to obtain pre-loaded table snapshots immediately after login using IO2GSession::getLoginRules(). It covers retrieving initial data for Accounts, Offers, Orders, and Trades tables without requiring explicit requests.

```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);

```

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

### Install LangGraph

Source: https://github.com/jgwill/llms-txt/blob/main/imported/llms-langchain-javascript.txt

Instructions on how to install the LangGraph Python library.

```APIDOC
## Install LangGraph

### Description
Instructions for installing the LangGraph Python package.

### Method
N/A (Installation Guide)

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Response
N/A

### Code Example
```bash
pip install langchain-graph
```

```

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

### Include ForexConnect and sample_tools Headers in C++

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

Specifies the necessary header files to include for using the ForexConnect API and the sample_tools library on Linux. ForexConnect.h provides the main API interfaces, while sample_tools.h offers Linux-compatible Win32 primitives.

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

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

### Process for Adding New Entries

Source: https://github.com/jgwill/llms-txt/blob/main/counter_articles/incompatible-sources/README.md

Steps to register a new incompatible source, including encountering a conflicting source, running a detection checklist, performing a critical review, and documenting various aspects of the incompatibility.

```markdown
1. **Encounter a source** whose assumptions conflict with creative-orientation, relational, or ceremonial paradigms.
2. **Run the Pollution Detection Checklist** ([`llms-pollution-detection-checklist.md`](../../llms-pollution-detection-checklist.md)) to score the source and determine its `paradigm_compatibility` rating.
3. **If scored `incompatible` (9+)**, proceed with registration. If `mixed` (4–8), consider whether registration or a Mixed Compatibility Protocol citation is more appropriate.
4. **Run a Critical Review** using [`template-critical-review.md`](../template-critical-review.md) for full paradigm mapping.
5. **Identify incompatibility type(s)** from the table above (or propose a new type).
6. **Assign severity**: 1 (framing-level), 2 (structural assumption), 3 (paradigm-defining).
7. **Document bias injection points** — the specific terms, phrases, or framings that carry the bias.
8. **Extract linguistic fingerprint** — terms that would indicate similar bias in unregistered sources.
9. **State the consequence** — what accepting this framework produces in practice.
10. **Write a one-sentence counter-position** from our paradigm.
11. **Write the citation protocol** — exactly how to cite this source in relationally-accountable writing.
12. **Add the YAML entry** to this file and update the Source Index table.
13. **Optionally write a full counter-article** using templates from [`counter_articles/`](../README.md).
```

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

### Source Ledger Entry Example

Source: https://github.com/jgwill/llms-txt/blob/main/llms-deep-research-foundations-session-close.md

Example structure for adding an implemented decision to the 'source-ledger.yaml' file.

```yaml
implemented_decisions:
  - session: <date--uuid-slug>
    decision: "<what was built>"
    maps_to: "<field design_decisions_supported entry>"
    commit: "<hash or PR ref>"
    verified: false
```

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

### Start Medicine Wheel Server (Local)

Source: https://github.com/jgwill/llms-txt/blob/main/docs/medicine-wheel-research.md

Starts the Medicine Wheel platform's Next.js application for local development. The server typically runs on port 3940.

```bash
mwsrv
```

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

### Use Existing Secret for Kubernetes Installation

Source: https://github.com/jgwill/llms-txt/blob/main/imported/llms-langchain-javascript.txt

Configure your LangSmith installation in Kubernetes to use an existing Kubernetes secret for sensitive information like database credentials or API keys.

```yaml
apiVersion: v1
kind: Pod
metadata:
  name: langsmith-pod
spec:
  containers:
  - name: langsmith
    image: ghcr.io/langchain-ai/langsmith:latest
    env:
    - name: DATABASE_URL
      valueFrom:
        secretKeyRef:
          name: langsmith-secrets
          key: database-url
```

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

### Example Violation Analysis

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

Demonstrates how to identify and articulate a violation of relational principles within a source's framework. This example focuses on how a discrete-agent ontology erases relational intelligence.

```text
"The violation occurs at ontological level. Smith's discrete-agent assumption erases the relational field where intelligence actually emerges. When agents are modeled as isolated optimizers, the coordination behaviors that arise from kinship cannot appear—they're invisible in this paradigm. The methodology compounds this: controlled experiments isolate variables, but relational intelligence *is* the variable that gets controlled out. Smith measures individual performance and reports 'results,' but relational outcomes (trust networks, emergent coordination, seven-generation impact) never enter the framework."
```

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

### miaco decompose run with detailed options

Source: https://github.com/jgwill/llms-txt/blob/main/llms-pde.txt

Demonstrates the use of miaco decompose run with specific prompt, engine, strategy, working directory, and output format.

```bash
miaco decompose run \
  --prompt "<text>" \
  --engine copilot \
  --strategy standard \
  --workdir . \
  --format text
```

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

### Using Skills Before Coding

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

Provides guidance on invoking specific skills to set the appropriate mindset and ensure accountability before starting to code.

```text
### Before Coding
1. **Invoke creative-orientation** — Shift from "fix this bug" to "what becomes possible?"
2. **Apply relational-research** — Who/what am I accountable to through this change?
3. **Check paradigm integrity** — Am I maintaining decolonial orientation?
```

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

### Example Bias Exposure

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

Illustrates how to expose structural biases within a source's framework, tracing their origins and reproduction through academic systems. This example links 'Creative Problem-Solving' to mid-20th century cybernetics and citation networks.

```text
"The bias isn't personal—it's structural. Smith's 'Creative Problem-Solving' terminology (2023) traces directly to mid-20th century management cybernetics where systems were problems for expert cognition to solve. Academic publishing rewards this framing: problem identification → methodology → solution → publication. Journals in Smith's domain have cited this paper 847 times, reproducing its Cartesian assumptions without examination. Each citation spreads discrete-agent ontology into new domains, naturalizing a framework that erases relational knowing. The bias is ecological, not individual."
```