/wiki-aggregate

name: wiki-aggregate
description: Use when you have N≥3 raw research artifacts (notes, podcast summaries, deep-research dumps, daily intel, paper analyses) on one topic and want to lift them into a single structured pack with cross-source claims and provenance — instead of one-shot summarization that loses 90% of intermediate evidence. Treats the N sources as an environment a lite aggregator agent navigates with `inspect` / `search` / `synthesize` tools, rather than concatenating into one prompt.

Wiki Aggregate — N raw sources → 1 structured pack

A protocol for **agentic aggregation** of long-horizon research material. Inverts the standard "concat all → ask LLM to summarize" pipeline: instead, an aggregator agent navigates the N source files with three tools, building a notes scratchpad with full `path:line` provenance, and finally writes a structured pack (brief / findings / sources / aggregation log).

**Core principle**: don't read everything upfront. Don't merge final answers. Treat the N sources as a queryable environment.

Why this exists

Three traditional ways to aggregate N parallel research outputs all fail on long-horizon, open-ended tasks:

  ❌ concat all sources into one prompt
       → 200K+ token explosion, attention collapse on long context

  ❌ summarize each, then merge summaries
       → ~90% of intermediate evidence (the "I noticed X but..." asides) is lost

  ❌ LLM-as-judge picks the single best source
       → discards the other N-1 sources' independent findings

These failure modes show up clearly on open-ended research tasks where there's no ground-truth `verifier`. The alternative: treat the N sources as an `environment`, send a `lite agent` in to `inspect / search / synthesize` on demand. Cost ≈ a single rollout, recall is materially higher, and cross-source contradictions get surfaced explicitly.

This skill is the protocol. No Python, no MCP — pure markdown protocol that any harness with `Read` + `Grep` can execute.

When to Use

• You have 3-30 raw notes / transcripts / research dumps on one topic, scattered across files
• The current pack on this topic feels thin or you suspect raw evidence wasn't fully lifted
• You want claims with `path:line` provenance, not vibes
• You want cross-source contradictions surfaced, not buried

When NOT to Use

• N < 3 sources — protocol overhead exceeds value, just write a summary by hand
• N > 30 — budget will be exhausted; narrow the scope or batch by sub-topic
• Sources are not yet collected — this is a synthesis tool, not a research tool. Run your collectors first.
• You only need a one-shot Q&A — use a reactive `wiki-ask`-style skill instead

The Aggregation Loop

                    Trajectories-as-environment
            ╔════════════════════════════════════════╗
            ║                                        ║
            ║   src_1   src_2   src_3  ...   src_N   ║
            ║   [..]    [..]    [..]         [..]    ║
            ║   [..]    [..]    [..]         [..]    ║
            ║                                        ║
            ╚═══════════════════╤════════════════════╝
                                │
                                │  not concatenated.
                                │  not summarized.
                                │  navigated.
                                │
                                ▼
            ┌────────────────────────────────────────┐
            │       AGGREGATOR (lite agent)          │
            │  ┌──────────────────────────────────┐  │
            │  │  inspect_file / inspect_section  │  │
            │  │  search_sources                  │  │
            │  │  cross_pack_check                │  │
            │  └──────────────────────────────────┘  │
            │                                        │
            │  scratch state:                        │
            │   notes   = []   # {claim, evidence,   │
            │                  #  source, line_ref}  │
            │   budget  = 25   # tool calls          │
            │   subtopics = derived from skim pass   │
            │                                        │
            │  loop until: subtopic coverage met,    │
            │              OR budget = 0,            │
            │              OR 2 zero-info calls      │
            └───────────────────┬────────────────────┘
                                │
                                ▼
                ┌─────────────────────────────┐
                │   pack/                     │
                │     brief.md                │
                │     findings.md   ← claims  │
                │     sources.tsv   ← S-IDs   │
                │     _aggregation_log.md     │
                └─────────────────────────────┘

Process

Phase 1: Scope

1. Resolve the source glob. Count N. 2. **Hard stop if N < 3** — abort and tell the user to either collect more or summarize manually. 3. **Warn if N > 30** — suggest narrowing by sub-topic or batching across runs. 4. If updating an existing pack, locate it and read its current `brief.md` + `findings.md` so you know what already exists.

Phase 2: Cheap-Pass (Skim)

For each source, do **one** cheap read:

• File ≤ 200 LOC: read the whole file.
• File > 200 LOC: read first 80 lines (frontmatter + intro + section headers).

Build an in-memory source map:

S1  | path/to/source_1.md  | what it covers (1-2 lines) | rough_topics
S2  | path/to/source_2.md  | ...                        | ...

This pass costs ~N reads, each bounded. **Do not skip** — the source map is what makes Phase 3 efficient.

Phase 3: Aggregator Loop (budget = 25 by default)

**Tool inventory** (use whatever your harness provides — `Read`, `Grep` are sufficient):

| Verb | Implementation | When to use | |---|---|---| | `inspect_file(path)` | `Read` whole file | Source < 200 LOC and you need full content | | `inspect_section(path, line_range)` | `Read` with `offset` + `limi