Skip to main content
skill CX Codex official · Anthropic

tres-recon-gaps — Claude Code skill: what it does, how to install

tres-recon-gaps pulls reconciliation gaps out of TRES Finance through the MCP connector, lays them out in an HTML dashboard, and closes the ones you pick.

MIT ★ 4,931 updated 2026-10-24

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add anthropics/claude-plugins-community
/plugin install tres-finance-plugin@claude-community
Open on GitHub

What tres-recon-gaps does

The skill runs on top of the TRES Finance MCP connector. It first pins down the date (endDate, YYYY-MM-DD) and, if you named assets, keeps only those rows. Then comes the reconciliation GraphQL query, 200 records per call. A gap is calculatedBalance − historicalBalance, so a positive number means the ledger holds more than the chain does.

A second call to assetBalance brings back the historical balance and a fiat price. The fiat gap is the token gap multiplied by unitPrice. What you get is a standalone .html dashboard: summary cards, search, direction and platform filters, collapsible groups per asset. Each row has two buttons, “Plug” and “Auto-fill”. A click copies a prepared prompt, you paste it into the chat, and Claude runs createPlug or createReconciliationGapFillRule. The page makes no HTTP requests of its own.

It fires only when you ask to see or close gaps. Plain balance questions and transaction history leave it quiet. Nothing gets queried without the TRES Finance MCP connector, since the skill's compatibility line requires it.

What it helps with

  • list reconciliation gaps for a chosen date
  • keep only the gaps for one asset
  • price every gap in fiat
  • close a single gap with a createPlug transaction
  • set up an auto-fill rule across a date range

Example prompts for the agent

  • Show me the reconciliation gaps for today
  • Keep only the ETH and USDC gaps
  • Build the gap dashboard and give me prompts to close each one

How to install tres-recon-gaps

1Plugin marketplace

/plugin marketplace add anthropics/claude-plugins-community
/plugin install tres-finance-plugin@claude-community

This installs the whole tres-finance-plugin plugin with all its skills

2Skills CLI (Vercel)

npx skills add anthropics/claude-plugins-community --skill tres-recon-gaps -a claude-code

3Manually: put the files in place

~/.claude/skills/tres-recon-gaps/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/tres-recon-gaps/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about tres-recon-gaps

How do I install tres-recon-gaps in Claude Code?

Add the marketplace with /plugin marketplace add anthropics/claude-plugins-community, then install the plugin: /plugin install tres-finance-plugin@claude-community.

What does tres-recon-gaps do?

It fetches reconciliation gaps from TRES Finance, adds fiat and on-chain balances, and renders an HTML dashboard. From there you copy a prompt and the gap gets closed in the chat.

What has to be set up before the skill works?

A connected TRES Finance MCP connector. The dashboard only displays data; createPlug and createReconciliationGapFillRule run in Claude once you paste the copied prompt.

Source text

SKILL.md · MIT
---
name: tres-recon-gaps
description: >
  Query, display, and resolve reconciliation gaps from the TRES Finance MCP connector.
  Trigger this skill ONLY when the user explicitly requests to view or close reconciliation
  gaps — for example: "show me the reconciliation gaps", "close the recon gaps", "view gaps
  for today", "plug the reconciliation gaps for ETH", "fix the gaps for USDC and BTC".
  Do NOT trigger for general balance queries, transaction history, or ledger browsing.
  Covers the full workflow: confirming the target date, optionally filtering by asset,
  fetching gap data, enriching with fiat and on-chain balances, rendering an HTML dashboard
  where each gap row has copy-prompt buttons (Plug / Auto-fill) — clicking copies a
  ready-to-paste Claude prompt for that gap. The user pastes it in the chat and Claude
  executes the action. Ends with a data collect once the user is done.
compatibility: "Requires TRES Finance MCP connector"
---

# TRES Reconciliation Gaps Skill

End-to-end workflow for surfacing, analyzing, and resolving reconciliation gaps in TRES Finance.

---

## Pre-flight: confirm date and asset scope

**Before fetching any data**, confirm two things with the user:

### 1. Target date

The reconciliation queries are scoped to a specific date (the `endDate` parameter).

- If the user **explicitly stated a date** — use it.
- If the user **did not mention a date** — assume today's date and inform them:
  > "I'll fetch reconciliation gaps for today (YYYY-MM-DD). Let me know if you want a different date."

Use ISO format `YYYY-MM-DD` throughout.

### 2. Asset filter (optional)

- If the user **named specific assets** (e.g. "for ETH and USDC", "just BTC") — note them. After fetching, filter the results to only those `asset.symbol` values before displaying.
- If the user **did not specify assets** — fetch and display all gaps.

---

## Step 1 — Fetch reconciliation gaps

Use the `reconciliation` query. Always pass the confirmed `endDate`. Fetch up to 200 at a time.

```graphql
query GetReconciliationGaps($limit: Int, $offset: Int, $endDate: Date) {
  reconciliation(limit: $limit, offset: $offset, endDate: $endDate) {
    totalCount
    results {
      id
      amount
      calculatedBalance
      state
      status
      gap
      belongsTo {
        id
        name
        identifier
      }
      asset {
        key
        identifier
        symbol
        platform
      }
      pendingTransactionsCount
      pendingTransactionsTotalAmount
    }
  }
}
```

Variables: `{"limit": 200, "offset": 0, "endDate": "<confirmed-date>"}`

> Note: `gap` = `calculatedBalance − historicalBalance`. Positive means the ledger has *more* than on-chain; negative means the ledger has *less*.

If the user requested specific assets, filter the results now: keep only rows where `asset.symbol` matches the requested symbols (case-insensitive).

---

## Step 2 — Enrich with fiat values and on-chain balances

Take all IDs from the (filtered) Step 1 results and query `assetBalance`:

```graphql
query GetAssetBalancesWithFiat($ids: [String], $limit: Int, $currency: String) {
  assetBalance(id_In: $ids, limit: $limit, currency: $currency, excludeUnderDelegation: true) {
    totalCount
    results {
      id
      calculatedBalance
      historicalBalance
      reconciliation
      fiatValue {
        value
        unitPrice
        fiatCurrency
      }
      belongsTo {
        id
        name
        identifier
      }
      asset {
        key
        symbol
        platform
        identifier
      }
    }
  }
}
```

Variables: `{"currency": "usd", "ids": ["<id1>", "<id2>", ...], "limit": 200}`

**Important**: `id_In` expects `[String]`, not `[ID]`.

Compute for each row:
```
fiatGap = reconciliation (token gap) × fiatValue.unitPrice
```

---

## Step 3 — Display: always render the HTML dashboard

**Always** generate a standalone `.html` file as the primary output — do not fall back to an inline widget.

Read `references/html-template-notes.md` for the full visual spec (fonts, colors, layout, column widths, modal behavior, API call mechanism).

Key requirements for the generated file:
- Dark financial dashboard aesthetic (spec in reference file)
- Sticky header showing the **target date** and a refresh timestamp badge
- 5 summary metric cards: net fiat gap, positive gap count, negative gap count, asset group count, pending tx count
- If an **asset filter** was applied, show a visible filter badge in the toolbar (e.g. `Filtered: ETH, USDC`)
- Search + direction filter + platform filter toolbar
- Asset-grouped collapsible sections, sorted by absolute net fiat gap descending
- Full column set per row — last column has two copy-prompt buttons: **↳ Plug** (blue) and **⟳ Auto-fill** (purple)
- Clicking either button copies a ready-to-paste prompt to clipboard and shows a toast: "Prompt copied — paste it in the Claude chat to resolve this gap."
- **No HTTP requests** — the HTML is a pure display interface; all mutations happen in Claude after the user pastes the prompt

After generating the file, present it to the user with `present_files`.

---

## Step 4 — Actions (plug-once and auto-fill)

The user triggers actions by copying a prompt from the HTML dashboard and pasting it into the Claude chat. When Claude receives one of these prompts, execute the corresponding mutation immediately — no further confirmation needed (the user already chose the action in the dashboard).

### One-time plug (`createPlug`)

```graphql
mutation CreatePlug(
  $hash: String!
  $platform: Platform!
  $timestamp: DateTime!
  $belongsToId: ID!
  $assetId: ID!
  $assetIdentifier: String!
  $amount: Float!
  $direction: Direction!
  $thirdPartyIdentifier: String!
) {
  createPlug(
    hash: $hash
    platform: $platform
    timestamp: $timestamp
    belongsToId: $belongsToId
    assetId: $assetId
    assetIdentifier: $assetIdentifier
    amount: $amount
    direction: $direction
    thirdPartyIdentifier: $thirdPartyIdentifier
  ) {
    transaction { id identifier platform timestamp }
  }
}
```

**Variable mapping:**
| Field | Value |
|---|---|
| `hash` | `plug_<assetId>_<walletId>_<timestamp_ms>` |
| `platform` | `asset.platform` |
| `timestamp` | `new Date().toISOString()` |
| `belongsToId` | `belongsTo.id` |
| `assetId` | `asset.key` |
| `assetIdentifier` | `asset.identifier` (use `"native"` for native assets like ETH/AVAX) |
| `amount` | `Math.abs(gap)` |
| `direction` | `gap > 0 ? "INFLOW" : "OUTFLOW"` |
| `thirdPartyIdentifier` | `belongsTo.identifier` (wallet address) |

### Auto gap-fill rule (`createReconciliationGapFillRule`)

```graphql
mutation CreateGapFillRule(
  $name: String!
  $assetId: String!
  $internalAccountId: Int!
  $interval: Interval!
  $startDate: Date!
  $endDate: Date!
) {
  createReconciliationGapFillRule(
    name: $name
    assetId: $assetId
    internalAccountId: $internalAccountId
    interval: $interval
    startDate: $startDate
    endDate: $endDate
  ) {
    success
    message
    ruleId
  }
}
```

**Variable mapping:**
| Field | Value |
|---|---|
| `name` | User-editable rule name (pre-filled: `Auto gap-fill · <asset> · <wallet>`) |
| `assetId` | `asset.key` |
| `internalAccountId` | `parseInt(belongsTo.id)` — must be `Int!` |
| `interval` | `DAILY` / `WEEKLY` / `MONTHLY` |
| `startDate` | ISO date string, e.g. `"2026-04-07"` |
| `endDate` | ISO date string (default: 2 years from today) |

---

## Step 5 — Run data collect after plugs are done

Once the user indicates they are **finished adding plugs** (e.g. "done", "that's all", "looks good"), run a data collect to sync the updated state.

Use the `triggerDataCollect` mutation (or equivalent — introspect with `get_schema_summary` if needed):

```graphql
mutation TriggerDataCollect {
  triggerDataCollect {
    success
    message
  }
}
```

After it completes, inform the user:
> "Data collect triggered — TRES will now sync the latest on-chain balances. The reconciliation gaps should update shortly."

---

## Grouping and sorting logic

**Default grouping: by asset symbol**
- Group all rows sharing the same `asset.symbol` into one group
- Net fiat gap shown per group header
- Sort groups by absolute net fiat gap descending
- Sort rows within each group by absolute fiat gap descending

**Alternative: group by wallet** (if user requests it)
- Group by `belongsTo.identifier`
- Same sorting logic

Always order by **fiat gap**, not token gap.

---

## Number formatting conventions

```js
// Fiat values
≥ $1M  → "$X.XXXM"
≥ $1K  → "$X.XXK"
< $1K  → "$X.XX"

// Token quantities
≥ 1B   → "X.XXXB"
≥ 1M   → "X.XXXM"
≥ 1K   → "X.XXXK"
< 1K   → up to 6 significant figures, trim trailing zeros

// Signs
Positive gaps: "+" prefix
Negative gaps: "−" (minus sign, not hyphen)
No sign:       absolute values (on-chain bal, calculated bal)
```

---

## Common edge cases

| Situation | Handling |
|---|---|
| `unitPrice = 0` | Show "—" for fiat gap; token gap still displays |
| `historicalBalance` is negative | Display as-is; flag visually if extreme |
| `pendingTransactionsCount > 0` | Show amber warning badge — pending txs may reduce the gap once confirmed |
| Very large token gaps with tiny fiat value | Still show; sort by fiat means they appear near bottom |
| `gap` field timeouts on large datasets | Use `assetBalance.reconciliation` field instead (same value, more reliable) |
| Asset filter yields zero rows | Inform the user: "No gaps found for [assets] on [date]" |

---

## Key schema facts (verified)

- `reconciliation` query — has `endDate` parameter; returns `gap` and basic balance fields
- `assetBalance` query — returns `historicalBalance`, `reconciliation` (= gap), and `fiatValue { value, unitPrice }`; **prefer for enriched data**
- `assetBalance(id_In: [String])` — note `[String]` not `[ID]`
- `createPlug` — `belongsToId` is `ID!`, `assetId` is `ID!` (pass the asset key string)
- `createReconciliationGapFillRule` — `internalAccountId` is `Int!`; `assetId` is `String!`; `interval` is `Interval!` enum
- Platform enum values: `ETHEREUM`, `BASE`, `ARBITRUM`, `OPTIMISM`, `POLYGON`, `AVAX`, `AVALANCHE_P_CHAIN`, `MANTRA`, etc.

© Nadav Gilliam · MIT · anthropics/claude-plugins-community

Similar skills

All skills for Finance and business →

From the same set37

The whole set →
tres-asc845-swap-reprice-skill The tres-asc845-swap-reprice-skill skill adjusts swap inflows under ASC 845 so their value matches the outflows and the clearing account nets to zero. Use it to investigate a month-end residual. CX Codex +1 ★ 4,931repo stars tres-onboarding tres-onboarding runs a full TRES Finance onboarding for a new entity or account in eight steps, from wallet upload to rollup rules. CX Codex +1 ★ 4,931repo stars tres-import-contacts tres-import-contacts imports blockchain contacts and labels into TRES Finance from CSV or XLSX spreadsheets. Helpful when pushing bulk address mappings back into the platform. CX Codex +1 ★ 4,931repo stars tres-report-advisor tres-report-advisor is a Claude Code skill that matches TRES Finance reports to a question or task. It activates for report selection, data lookups, comparisons, and goals such as month-end close. CX Codex +1 ★ 4,931repo stars tres-request-skill-update tres-request-skill-update collects structured bug reports, feature ideas, and feedback for the TRES plugin and saves them via TRES MCP. CX Codex +1 ★ 4,931repo stars tres-rollup-review tres-rollup-review is a Claude Code skill that checks the exact sub-transaction impact of TRES Finance rollup rules, flagging empty matches, overlaps, and setup errors before creation. CX Codex +1 ★ 4,931repo stars tres-tx-story tres-tx-story — a Claude Code skill that takes a transaction hash, fetches data from the TRES Finance MCP server, and renders an SVG flow diagram of every asset movement. Fires when a user pastes an 0x hash and asks what happened. CX Codex +1 ★ 4,931repo stars html-plan html-plan builds an interactive HTML implementation plan with claims, code exhibits, and explicit decisions before touching code. CX Codex +1 ★ 4,931repo stars

Project sponsors

Companies that keep this analytics open