agentleFS
zotoiozotoio/CRUX-Compress/.cursor/skills/crux-skill-memory-meditation-ensemble/SKILL.md

crux-skill-memory-meditation-ensemble

Skill8 starsChanged 2 months agoMITView on GitHub

Ensemble Aggregation function for meditation: reads N model consolidations, writes `cross-model-synthesis.md`, performs K10 root cross-model reflection (step 3c), manages K10 layered cadence steps 3b–3f (per-tree `finalisation-enhancements.yml` reads + root combined YAML write with `cross_model_candidates` + `union_candidates`), returns single combined `needs_user_input`, dispatches resume-handler by `source` provenance, and hands off to the report skill for ensemble HTML+PDF generation. Use when the `crux-cursor-meditation-guide` agent is spawned with `ensembleAggregation: true`.

The file

Show its rules and text

We split this skill into the rules it gives an agent

13 rules. About 0 are common, 5 are distinctive, and 8 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈5

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 8

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    All N per-model meditation trees have completed (calling agent confirms before spawning the aggregator)

    line 25
  2. Very specific:

    Write the synthesis document to the ensemble root directory.

    line 68
  3. Distinctive:

    NOTE: NO per-tree askQuestion fires — per-tree YAMLs are write-only at the per-tree level (OQ #10 resolved as "both layered" with single …

    line 189
  4. Very specific:

    Write {ensembleWorkingDir}/finalisation-enhancements.yml (no {model-subdir} segment):

    line 203
  5. Very specific:

    After writing the root YAML, write-back surfaced_to_root annotations to every per-tree YAML: for each per-tree candidate, set …

    line 251
  6. Very specific:

    Model-label resolution fallback: if cruxMemories.meditate.modelPool no longer contains the {model-subdir} slug at continuation time (model …

    line 279
  7. Very specific:

    accepted: true, treatment: "queue" (expensive): write follow-up-{type}-{ts}.yml next to the appropriate location: per-tree consolidation …

    line 287
  8. Very specific:

    Follow the same mandatory report contract as single-model reports (per the crux-skill-memory-meditation-report skill) with the …

    line 294
  9. Very specific:

    All standard content minimums (4+ chart types, 3+ infographics, interactive calculators, filterable tables, light/dark mode, PDF …

    line 300
  10. Distinctive:

    Model comparison hero: instead of a single stat-card row, show N model cards side-by-side, each with that model's headline finding and a …

    line 312
  11. Distinctive:

    Per-model drill-down links: every section includes links to the corresponding section in each model's individual HTML report

    line 316
  12. Distinctive:

    When an accepted enhancement was sourced from a per-tree candidate vs a cross-model candidate, the report-skill respawn targets a different …

    line 328
  13. Very specific:

    Cost-ack re-presentation at ensemble for spawn_now: when the user opts an expensive item into spawn_now at the ensemble root gate, the …

    line 333

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

CRUX Skill: Memory Meditation — Ensemble Aggregation

Implements the Ensemble Aggregation function: cross-model synthesis after N independent meditation trees have completed, K10 layered cadence (steps 3b–3f), ensemble report extras, and K10 Ensemble Respawn Targeting. This skill is never loaded by per-model tree agents — only by the aggregator spawn.

When to Use

Load this skill only when:

  • The crux-cursor-meditation-guide agent is spawned with ensembleAggregation: true
  • You are the cross-model aggregator spawned by the calling agent's Ensemble Protocol (step 8 of the /crux-meditate command)

This skill is modelStrategy.mode == "ensemble_max" only. The other two pool-using strategies — random and per_branch — are single-tree variants that do NOT spawn an aggregator and do NOT produce a cross-model-synthesis.md or ensemble report pair. They run the standard single-tree workflow with model dispatch driven by the modelStrategy: payload (see the /crux-meditate command's Model Strategy payload section).

Never load this skill in:

  • Per-model tree Research or Quick mode workflows (per-model trees use the crux-skill-memory-meditation-research or crux-skill-memory-meditation-quick skill)
  • Single-tree random runs (no aggregation needed — one model, one report)
  • Single-tree per_branch runs (no aggregation needed — one tree with per-branch model attribution recorded in facets.md and the standard single-tree report)

Prerequisites

  1. All N per-model meditation trees have completed (calling agent confirms before spawning the aggregator)
  2. comprehensiveness: payload is present in the spawn prompt — abort with: "comprehensiveness: payload required; missing from spawn prompt — caller misconfigured" if missing
  3. theming: payload is present — abort with a clear error if missing

Input Parameters (Ensemble Aggregation invocation)

ensembleAggregation: true
ensembleWorkingDir: "<absolute path to the ensemble root directory>"
modelSubdirs: 
  - slug: "gpt-5.6-sol-max"
    label: "GPT 5.6 Sol"
    subdirPath: "<absolute path to model-gpt-5.6-sol/>"
  # ... one entry per model
confirmedFacets: 
  - index: 1
    title: "{facet-1-title}"
    subfocus: "{facet-1-subfocus}"
    slug: "{facet-1-slug}"
  # ... 3 facets (shared, user-confirmed)
theming: { ... }                  # shared Theme Preflight payload — REQUIRED
comprehensiveness: { ... }        # shared comprehensiveness payload — REQUIRED; abort if missing
meditateMode: "research" | "quick"
topicSlug: "{topic-slug}"         # for report filenames

Ensemble Aggregation Workflow

Step 1 — Read All Model Consolidations

For each model subdirectory in modelSubdirs, read consolidation.md. Also read each model's facets.md (with Branch & Leaf Index) to understand the tree structure. Optionally read individual branch files (branch-*-depth-*-sub-*-*.md) for detail when consolidations alone are insufficient to assess convergence/divergence.

Step 2 — Cross-Model Analysis

For each confirmed facet, compare each model's findings:

  • Convergence detection: Identify conclusions that all N models independently reached. Score convergence strength by counting how many models agree and how closely their phrasing and evidence align.
  • Divergence detection: Identify conclusions where models disagree. For each divergence, extract each model's position, reasoning, and supporting evidence. Assess which position is better-supported based on citation strength and internal consistency.
  • Unique insight detection: Identify findings that only one model surfaced. Assess credibility by checking whether the finding is well-cited and internally consistent, or whether it might be a hallucination (single-source, weakly cited, inconsistent with convergent findings).
  • Evidence quality comparison: For shared claims, compare citation breadth and depth across models. Note which model found the most/strongest citations, and which relied on different source types (memory corpus, code analysis, web sources).
  • Reasoning style comparison: Analyse structural differences in how each model organized its exploration — subfocus derivation patterns, depth allocation, narrative vs. enumeration style, consolidation quality.

Step 3 — Write cross-model-synthesis.md

Write the synthesis document to the ensemble root directory. Every finding carries [model: {label}] attribution markers. Convergent findings use [models: all]. The ## Citations section is a unified, deduplicated list across all models with per-citation model attribution.

Required schema:

---
ensemble_mode: true
meditate_mode: "research" | "quick"
model_count: {N}
models:
  - slug: "gpt-5.6-sol-max"
    label: "GPT 5.6 Sol"
    subdir: "model-gpt-5.6-sol"
  - slug: "claude-opus-5-thinking-high"
    label: "Opus 5"
    subdir: "model-opus-5"
  - slug: "gemini-3.1-pro"
    label: "Gemini Pro 3.1"
    subdir: "model-gemini-pro-3.1"
aggregator_model: "{model slug or 'caller'}"
timestamp_utc: "{yyyymmddHHMMSS}"
---

## Executive Summary
{One-paragraph verdict synthesizing the strongest findings across all models.
 Lead with the substantive conclusion, not a description of the ensemble process.}

## Convergence — High-Confidence Findings
{Findings that all N models independently arrived at. Each finding includes:
 - The shared conclusion
 - How each model framed or supported it (with [model: label] attribution)
 - Combined citation strength (union of citations from all models)
 These are the most trustworthy outputs of the meditation.}

## Divergence — Areas of Disagreement
{Findings where models reached different conclusions about the same facet.
 Each divergence includes:
 - The question or claim at issue
 - Each model's position with its reasoning and evidence ([model: label])
 - The aggregator's assessment of which position is better-supported and why
 - A confidence indicator (strong disagreement vs. nuanced difference)
 These are the most valuable outputs — they reveal where the topic is genuinely
 contested or where model-specific knowledge gaps exist.}

## Unique Insights — Single-Model Discoveries
{Findings surfaced by only one model that the others missed entirely.
 Each insight includes:
 - The finding and its evidence ([model: label])
 - Why the other models likely missed it (knowledge gap, different framing,
   different depth allocation)
 - The aggregator's assessment of whether the insight is credible and valuable
 These represent potential blind spots — valuable if real, risky if hallucinated.}

## Evidence Quality Comparison
{Per-facet assessment of citation strength across models:
 - Which model found the most/strongest citations for shared claims
 - Which model relied most on memory corpus vs. code analysis vs. web sources
 - Citation coverage gaps per model}

## Reasoning Style Comparison
{Meta-observation of how each model structured its analysis:
 - Depth vs. breadth trade-offs per model
 - Which model produced the most novel subfocus derivations at depth-2/3
 - Stylistic patterns (e.g. one model favours enumeration, another favours
   narrative synthesis)
 - Which model's consolidation was most/least aligned with the Subject-Matter
   Focus rule}

## Recommended Synthesis
{The aggregator's best-judgment unified analysis that:
 - Anchors on convergent findings as the foundation
 - Incorporates the best-supported position from each divergence
 - Integrates credible unique insights with appropriate hedging
 - Calls out remaining open questions where even the ensemble cannot resolve
   the disagreement}

## Per-Model Report Index
{Links to each model's individual report and consolidation for drill-down:
 - [GPT 5.6 Sol Report (HTML)](model-gpt-5.6-sol/report-{topic-slug}-{ts}.html)
 - [GPT 5.6 Sol Report (PDF)](model-gpt-5.6-sol/report-{topic-slug}-{ts}.pdf)
 - [GPT 5.6 Sol Consolidation](model-gpt-5.6-sol/consolidation.md)
 - ... (one group per model)}

## Citations
{Unified, deduplicated citation list across all models. Each entry includes
 [model: label] markers indicating which model(s) cited it. Backlinks to
 the sections that used each citation.}

Step 3b — K10 Ensemble Layered Cadence: Read Per-Tree finalisation-enhancements.yml Files

Each per-tree depth-0 manager wrote {model-subdir}/finalisation-enhancements.yml with source_tree: "{model-subdir}" and surfaced_to_root: null placeholder fields. Read all per-tree YAMLs.

K10 per-tree YAML schema (each per-tree depth-0 manager writes this during step 8, before returning to the aggregator):

---
generated_utc: "{utc-timestamp}"
topic_slug: "{topic-slug}"
mode: "research"      # or "quick"
ensemble: true
source_tree: "{model-subdir}"   # e.g. "gpt-5.6-sol-max", "claude-opus-5", etc.
rubric: { impact_score_max: 10, insight_value_score_max: 10, minimum_impact_threshold: 6, weights: { impact: 1.0, insight_value: 1.0 }, formula: "product" }
degradation_reason: null | "..."
---
candidates:
  - id: "{type}-{ts}"
    type: "{one-of-11-types}"
    cost_class: "cheap"   # or "expensive"
    title: "{title}"
    description: "{description}"
    impact_score: {N}
    insight_value_score: {N}
    composite_score: {N}
    source_tree: "{model-subdir}"   # required; enables root-level provenance labelling
    surfaced_to_root: null          # placeholder; aggregator fills true | false after union
    source_signals: [...]
    payload: { ... }
    accepted: null
    treatment: null
    decided_at_utc: null

NOTE: NO per-tree askQuestion fires — per-tree YAMLs are write-only at the per-tree level (OQ #10 resolved as "both layered" with single combined root gate).

Step 3c — K10 Root Cross-Model Reflection (in the SAME LLM pass as cross-model-synthesis.md)

After writing cross-model-synthesis.md, run a SECOND reflection pass over: (a) all per-tree consolidation.md files (already in context from step 1); (b) all per-tree finalisation-enhancements.yml files (from step 3b); (c) cross-model-synthesis.md itself (just written). Produce up to 5 cross-model candidates emergent from looking across all trees together. Rank high for:

  1. Cross-tree convergence: ≥2 trees independently surfaced the same enhancement type (convergence signal). Apply insight_value_score ≥ 7 calibration when convergence is explicit.
  2. Cross-model-only patterns: visible only across models (e.g. a divergence between two trees suggests an extracted_spec one tree didn't see).
  3. Cross-model-synthesis-side opportunities: cross_branch_synthesis_section is naturally cross-tree and often a high-value candidate.

Each cross-model candidate carries source: "cross_model". Use the same impact × insight-value rubric (1–10 per axis) with the insight_value_score ≥ 7 calibration boost for convergent findings.

Step 3d — K10 Root Combined YAML Write

Write {ensembleWorkingDir}/finalisation-enhancements.yml (no {model-subdir} segment):

---
generated_utc: "{utc-timestamp}"
topic_slug: "{topic-slug}"
mode: "research"      # or "quick"
ensemble: true
ensemble_pool_size: {N}   # modelPool size
rubric: { impact_score_max: 10, insight_value_score_max: 10, minimum_impact_threshold: 6, weights: { impact: 1.0, insight_value: 1.0 }, formula: "product" }
degradation_reason: null
---
cross_model_candidates:
  # up to 5 ranked candidates from the aggregator's cross-model reflection
  - id: "{type}-{ts}"
    type: "{one-of-11-types}"
    cost_class: "cheap"
    title: "{title}"
    description: "{description}"
    impact_score: {N}
    insight_value_score: {N}
    composite_score: {N}
    source: "cross_model"
    source_signals: ["[cross-model-synthesis: ...]"]
    convergence_signal: true | false   # true when ≥2 trees independently surfaced this
    payload: { ... }
    accepted: null
    treatment: null
    decided_at_utc: null
union_candidates:
  # denormalised top-N (capped at 5) by composite_score across (per_tree × N) + (cross_model × 5)
  # each entry is one of the per-tree or cross-model candidates; includes source provenance
  - id: "{id}"
    type: "{type}"
    cost_class: "cheap" | "expensive"
    title: "{title}"
    description: "{description}"
    impact_score: {N}
    insight_value_score: {N}
    composite_score: {N}
    source: "cross_model"   # or "tree:{model-subdir}" e.g. "tree:gpt-5.6-sol-max"
    source_signals: [...]
    payload: { ... }
    accepted: null
    treatment: null
    decided_at_utc: null
    surfaced_to_root: true   # always true for entries in union_candidates

After writing the root YAML, write-back surfaced_to_root annotations to every per-tree YAML: for each per-tree candidate, set surfaced_to_root: true if the candidate's id appears in union_candidates; set surfaced_to_root: false otherwise. This is the ONLY mutation the aggregator makes to per-tree YAMLs.

Step 3e — Return K10 needs_user_input Block to the Calling Agent (single combined root gate)

This is the single combined root gate — recommended posture per architecture design (alternative per-tree gates are rejected because they serialise trees, multiply user prompts, and prevent cross-model insight from being visible at decision time). Do NOT call AskQuestion — this is the calling agent's responsibility.

needs_user_input:
  reason: "finalisation-enhancements-gate"
  pattern: "B"
  context: |
    Post-consolidation reflection (per-tree + cross-model) surfaced {N} candidate
    finalisation enhancements across all {M} trees. Multi-select 0–5. Each option
    label includes provenance: {title} [{cost_class}] ({source-label}) — composite={N}.
    Source labels: "cross-model" or "from tree: {model-label}".
    Cross-model candidates tend to surface patterns no single model tree saw alone.
  decision_required: true
  files_written:
    - "finalisation-enhancements.yml"
    - "{model-subdir-1}/finalisation-enhancements.yml"
    - "{model-subdir-2}/finalisation-enhancements.yml"
    # ... one per tree
  resume_handler_contract:
    expected_input:
      finalisation_enhancements_path: "{ensembleWorkingDir}/finalisation-enhancements.yml"
      # calling agent has updated the root YAML in place with accepted/treatment/decided_at_utc

Model-label resolution fallback: if cruxMemories.meditate.modelPool no longer contains the {model-subdir} slug at continuation time (model retired), label falls back to "Unknown model ({model-subdir})".

Step 3f — K10 Ensemble Resume-Handler for Accepted Enhancements

Called after the calling agent resolves the gate and passes back finalisation_enhancements_path. Re-read the updated root finalisation-enhancements.yml. For each accepted union_candidates entry:

  • accepted: true, treatment: "respawn" (cheap), source: "cross_model": bundle into the ensemble synthesis report's first adversarial-review iteration respawn payload (accepted_finalisation_enhancements: list in the cross-model adversarial reviewer invocation).
  • accepted: true, treatment: "respawn" (cheap), source: "tree:{model-subdir}": bundle into the per-tree {model-subdir} report's first adversarial-review iteration respawn payload.
  • accepted: true, treatment: "queue" (expensive): write follow-up-{type}-{ts}.yml next to the appropriate location: per-tree consolidation directory for tree-sourced; ensemble root for cross-model-sourced. Do NOT spawn agents.
  • accepted: true, treatment: "spawn_now" (expensive): defer spawning until AFTER the corresponding adversarial-review cycle completes. Track in pending_spawn_now: [...] per target (per-tree vs ensemble).

Non-infinite-loop guarantee (ensemble layered cadence): per-tree reflections happen exactly once per tree (bounded by modelPool size = constant); root cross-model reflection happens exactly once; single combined root gate fires once per invocation. Per-tree adversarial review cycles each have their own ≤3 cap (unchanged); cross-model adversarial review has its own ≤3 cap. Total: at most N + 1 reflection writes + 1 user gate + (N + 1) × 2 useful respawns × 1 report-skill run each = O(N) total bounded work. Cannot infinite-loop.

Step 4 — Generate the Ensemble Report (HTML + PDF)

Follow the same mandatory report contract as single-model reports (per the crux-skill-memory-meditation-report skill) with the ensemble-specific additions below. Key differences from single-model reports:

  • The hero/executive summary leads with the cross-model verdict (what's convergent, what's contested)
  • Per-facet sections show model comparisons side-by-side rather than a single narrative
  • The agreement heatmap (facet × model matrix) is the signature visualization
  • Per-model drill-down links connect to each model's individual HTML report
  • The model attribution Sankey, citation Venn, and confidence radar are ensemble-specific recommended visualizations
  • All standard content minimums (4+ chart types, 3+ infographics, interactive calculators, filterable tables, light/dark mode, PDF degradation) still apply; the minima are level-driven per comprehensiveness.minima.*

Filenames: ensemble-report-{topic-slug}-{ts}.html / .pdf in the ensemble root, with paired timestamps.

Step 5 — Return to Calling Agent

Return the ensemble working directory path, the cross-model-synthesis.md path, the ensemble report HTML+PDF pair paths, the ordered list of per-model subdirectory paths (each containing its own consolidation.md, facets.md, report-{topic-slug}-{ts}.html / .pdf pair, and {model-subdir}/finalisation-enhancements.yml), and (when any expensive spawn_now items were accepted) a pending_spawn_now: [...] list structured as [{source: "cross_model"|"tree:{model-subdir}", type: "...", follow_up_file: "..."}] so the calling agent can spawn at the right moment. Include the same follow-up reminder: further content edits, visual refinements, theme adjustments, contrast tweaks, or regenerated report variants can be requested in a new agent session pointed at the ensemble meditation folder.

Ensemble-Specific Structural Elements (Report Additions)

The ensemble report layers these elements on top of the standard mandatory minimums from the crux-skill-memory-meditation-report skill:

  • Model comparison hero: instead of a single stat-card row, show N model cards side-by-side, each with that model's headline finding and a convergence/divergence indicator
  • Per-facet comparison cards: for each confirmed facet, show each model's key conclusion in parallel columns/cards with [model: label] attribution and a visual convergence indicator (green = all agree, amber = partial agreement, red = disagreement)
  • Agreement heatmap (required): a facet × model matrix (Chart.js or D3) where cell color encodes the degree of agreement between each model pair for each facet. This is the ensemble report's signature visualization.
  • Divergence deep-dives: each major divergence gets its own section with the competing positions presented side-by-side, evidence compared, and the aggregator's assessment
  • Per-model drill-down links: every section includes links to the corresponding section in each model's individual HTML report

Ensemble-specific visualizations (in addition to the standard minimums):

  • Agreement heatmap (required): facet × model matrix
  • Model attribution Sankey (recommended): flow diagram showing how findings from each model fed into the convergence/divergence/unique categories
  • Citation Venn diagram (recommended): overlap visualization showing which citations were shared vs. model-unique
  • Confidence radar: per-facet confidence scores from each model, overlaid on a single radar chart

Model attribution citation format: All findings in the ensemble report carry [model: {label}] citation markers (e.g. [model: GPT 5.6 Sol], [model: Opus 5]). These appear alongside standard citation markers ([memory: ...], [file: ...], etc.) and are listed in the ## Citations section with backlinks. When a finding is convergent (all models agree), use [models: all] as a shorthand.

K10 Ensemble Respawn Targeting

When an accepted enhancement was sourced from a per-tree candidate vs a cross-model candidate, the report-skill respawn targets a different report:

  • Per-tree-sourced accept (source: "tree:{model-subdir}" in the root union_candidates list): the respawn payload for the per-tree report ({model-subdir}/report-{topic-slug}-{ts}.html/.pdf pair) gains the entry under accepted_finalisation_enhancements. The per-tree report skill respawns and the regenerated per-tree report incorporates the accepted enhancement. The cross-model synthesis report is NOT respawned for per-tree-sourced accepts.
  • Cross-model accept (source: "cross_model"): the respawn payload for the cross-model synthesis report (ensemble-report-{topic-slug}-ensemble-{ts}.html/.pdf) gains the entry. The cross-model synthesis report skill respawns and the regenerated synthesis report incorporates the accepted enhancement. Per-tree reports are NOT respawned for cross-model accepts.

Cost-ack re-presentation at ensemble for spawn_now: when the user opts an expensive item into spawn_now at the ensemble root gate, the cost-ack re-presentation prose names which subsystems gain agents at which level:

Per-type subsystem agent contribution (ensemble):
  - Per-tree-sourced expensive items spawn within the relevant per-tree
    model subdirectory (depth-0 manager per tree re-spawns the relevant subtrees).
  - Cross-model-sourced expensive items spawn at the ensemble root (aggregator
    runs the expensive spawn after the adversarial cycle completes across all
    per-tree and root synthesis reports).
[Locked: richness = {level}]
[Locked: depth = {D}]

Dim 13 layered audit at ensemble: the reviewer audits each accepted enhancement against the correct report — per-tree-sourced enhancements audited against the per-tree report; cross-model-sourced enhancements audited against the cross-model synthesis report. A missing accepted enhancement in the wrong report is NOT a Dim 13 finding; it is only a finding when the targeting rule above says it should be in that specific report.

Cross-Skill References

  • crux-skill-memory-meditation-report — mandatory report contract for ensemble HTML+PDF generation and per-tree respawns
  • crux-skill-memory-meditation-coordination — ensemble working-directory layout + per-tree finalisation-enhancements.yml filename row + root finalisation-enhancements.yml filename row
  • crux-skill-memory-meditation-research — per-tree depth-0 manager writes {model-subdir}/finalisation-enhancements.yml before returning to aggregator; this skill reads those files in step 3b
  • crux-skill-memory-meditation-quick — same per-tree write in Quick-mode ensemble trees

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.