Skip to content

Ar9av/PaperOrchestra / skills/agent-research-aggregator

agent-research-aggregator

Verified

Pre-pipeline aggregator that scans AI agent cache directories (.claude, .cursor, .antigravity, .openclaw) or any user-specified directory for experimentation logs, extracts insights and numeric results, and formats them as PaperOrchestra-ready inputs (idea.md + experimental_log.md). TRIGGER when the user says "aggregate my agent logs for paper writing", "extract experiments from my coding agent history", "prepare PaperOrchestra inputs from my cache", "turn my agent logs into a paper", mentions a folder or directory they want to use as the basis for a paper, or wants to run PaperOrchestra but only has scattered agent experiment histories rather than structured inputs. Run this BEFORE paper-orchestra. Also called automatically by paper-orchestra when workspace/inputs/idea.md or workspace/inputs/experimental_log.md are missing.

references/log-formats.md

View on GitHub
# Agent Log Formats

Reference for `discover_logs.py`. Describes what each agent type stores and
which files are most likely to contain experiment data.

---

## Claude Code (`.claude/`)

Claude Code stores all persistent state under `.claude/` at the project root
(or `~/.claude/` for global state).

### Memory files — HIGH VALUE

```
.claude/projects/<workspace-hash>/memory/
    *.md          # Structured memory entries (frontmatter: name, description, type)
~/.claude/projects/<workspace-hash>/memory/
    *.md          # Same, global location
```

Memory files use this frontmatter schema:
```yaml
---
name: <title>
description: <one-line hook>
type: user | feedback | project | reference
---
```

Types to prioritize:
- `type: project` — contains experiment goals, decisions, blockers
- `type: feedback` — contains "what worked / what didn't" patterns
- `type: user` — background context (role, domain knowledge)
- `type: reference` — external links + dataset/codebase pointers

### CLAUDE.md — HIGH VALUE

```
CLAUDE.md                   # Project-level instructions
.claude/CLAUDE.md           # Alternative location
```

Often contains: project description, experimental context, constraints,
design decisions that inform the research framing.

### Task outputs — MEDIUM VALUE

Claude Code task outputs (from the `TaskOutput` tool) may appear as:
```
.claude/task-outputs/
    *.md
    *.txt
```

These contain agent responses to long-running tasks — may include benchmark
runs, code generation results, test outputs.

### Todos — LOW VALUE (structure only)

```
.claude/todos/
    *.json        # {id, content, status, priority}
```

Useful for understanding what experiments were planned vs. completed.

---

## Cursor (`.cursor/`)

Cursor stores workspace AI data under `.cursor/` at the project root.

### Chat history — HIGH VALUE

```
.cursor/chat/
    chatHistory.json        # Array of {role, content, timestamp} objects
    *.chat                  # Per-session chat files (same format)
```

Also check SQLite databases:
```
~/.cursor/User/globalStorage/
    *.db                    # SQLite; table `ItemTable` has key-value chat data
```

SQLite query: `SELECT value FROM ItemTable WHERE key LIKE '%chat%'`

### Rules — MEDIUM VALUE

```
.cursor/rules/
    *.md                    # Cursor rules (may describe project + constraints)
.cursorrules                # Root-level rules file
```

### Notes / scratchpad — MEDIUM VALUE

```
.cursor/notes/
    *.md
```

---

## Antigravity (`.antigravity/`)

Antigravity is a multi-worker coding agent. Stores per-task logs and
worker outputs.

### Worker logs — HIGH VALUE

```
.antigravity/workers/
    <worker-id>/
        log.jsonl           # Newline-delimited JSON events
        output.md           # Final worker output
        task.json           # Task specification
```

Each `log.jsonl` line:
```json
{"ts": "ISO-8601", "type": "tool_result|message|error", "content": "..."}
```

### Task registry — MEDIUM VALUE

```
.antigravity/tasks/
    <task-id>.json          # {id, description, status, created_at, outputs[]}
.antigravity/task-registry.json   # Index of all tasks
```

### Workspace snapshots — LOW VALUE (size risk)

```
.antigravity/snapshots/
    <snapshot-id>/          # Git-bundle or diff snapshots between runs
```

Skip these unless `--include-snapshots` is passed (not default).

---

## OpenClaw (`.openclaw/`)

OpenClaw follows a similar structure to Claude Code but uses different
file names.

### Session logs — HIGH VALUE

```
.openclaw/sessions/
    <session-id>/
        conversation.md     # Full conversation in markdown
        artifacts/
            *.py, *.json    # Generated code + data files
```

### Memory — HIGH VALUE

```
.openclaw/memory/
    *.md                    # Structured notes (same frontmatter as Claude Code)
```

### Run outputs — MEDIUM VALUE

```
.openclaw/runs/
    <run-id>/
        stdout.log
        stderr.log
        exit_code.txt
        metrics.json        # Agent-emitted key-value metrics
```

---

## General project files (scanned regardless of agent)

These are scanned in the project root and common subdirectory names regardless
of which agent produced them:

| Pattern | Priority | Rationale |
|---|---|---|
| `results*.{json,csv,tsv}` | HIGH | Likely benchmark output |
| `experiments*.{json,yaml}` | HIGH | Experiment configs + results |
| `*.ipynb` | HIGH | Jupyter notebooks with outputs |
| `run_*.log`, `train_*.log` | HIGH | Training/eval logs |
| `metrics.json`, `eval.json` | HIGH | Structured metric files |
| `ablation*.{md,json}` | HIGH | Ablation study data |
| `README.md` (root only) | MEDIUM | Often summarizes experiments |
| `notes*.md`, `NOTES.md` | MEDIUM | Researcher notes |
| `config*.{yaml,json,toml}` | MEDIUM | Hyperparameter configs |
| `*.log` (root level) | LOW | Generic logs; scan headers only |

**Skip always:**
- `node_modules/`, `.git/`, `__pycache__/`, `*.pyc`
- Files > 200 KB (note path in report but don't read)
- Binary files (check magic bytes: `\x00` in first 512 bytes)
- Credential-like files: `*.pem`, `*.key`, `.env`, `credentials*`

---

## Extraction priority ranking

When logs exceed the batch size budget, process in this order:

1. Memory files (`.claude/memory/`, `.openclaw/memory/`)
2. Chat history / conversation logs with tool outputs
3. `metrics.json`, `eval.json`, structured result files
4. Jupyter notebooks (`.ipynb`)
5. Training logs (`run_*.log`, `train_*.log`)
6. CLAUDE.md / `.cursorrules` / project notes
7. Task specifications and todos
8. Generic README / notes files
writing-skillsobra/superpowersUse when creating new skills, editing existing skills, or verifying skills work before deploymentStars: 322kUpdated Claude CodeCodexVerifiedInstall
xlsxanthropics/skillsUse this skill any time a spreadsheet file is the primary input or output. This means any task where the user wants to: open, read, edit, or fix an existing .xlsx, .xlsm, .xltx, .csv, or .tsv file (e.g., adding columns, computing formulas, formatting, charting, cleaning messy data); create a new spreadsheet from scratch or from other data sources; or convert between tabular file formats. Trigger especially when the user references a spreadsheet file by name or path — even casually (like "the xlsx in my downloads") — and wants something done to it or produced from it. Also trigger for cleaning or restructuring messy tabular data files (malformed rows, misplaced headers, junk data) into proper spreadsheets. The deliverable must be a spreadsheet file. Do NOT trigger when the primary deliverable is a Word document, HTML report, standalone Python script, database pipeline, or Google Sheets API integration, even if tabular data is involved.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
shipping-and-launchaddyosmani/agent-skillsPrepares production launches. Use when preparing to deploy to production, or when asking what needs to be in place before shipping. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy.Stars: 119kUpdated Claude CodeCodexVerifiedInstall
childhoodthedotmack/claude-memBabysit a shipped release after merge, publication, or deployment. Verify published packages, production behavior, installed plugins, and late CI or user reports until the observation window is clean; use babysit for PR readiness before release.Stars: 118kUpdated Claude CodeCodexVerifiedInstall