@jairodri/huckleberry-cli 1.0.1 → 1.1.0

package/skills/autoresearch/autoresearch-autoresearch/SKILL.md.baseline

@@ -0,0 +1,329 @@
+---
+name: autoresearch
+description: "Autonomously optimize any Claude Code skill by running it repeatedly, scoring outputs against binary evals, mutating the prompt, and keeping improvements. Based on Karpathy's autoresearch methodology. Use when: optimize this skill, improve this skill, run autoresearch on, make this skill better, self-improve skill, benchmark skill, eval my skill, run evals on. Outputs: an improved SKILL.md, a results log, and a changelog of every mutation tried."
+---
+
+# Autoresearch for Skills
+
+Most skills work about 70% of the time. The other 30% you get garbage. The fix isn't to rewrite the skill from scratch. It's to let an agent run it dozens of times, score every output, and tighten the prompt until that 30% disappears.
+
+This skill adapts Andrej Karpathy's autoresearch methodology (autonomous experimentation loops) to Claude Code skills. Instead of optimizing ML training code, we optimize skill prompts.
+
+---
+
+## the core job
+
+Take any existing skill, define what "good output" looks like as binary yes/no checks, then run an autonomous loop that:
+
+1. Generates outputs from the skill using test inputs
+2. Scores every output against the eval criteria
+3. Mutates the skill prompt to fix failures
+4. Keeps mutations that improve the score, discards the rest
+5. Repeats until the score ceiling is hit or the user stops it
+
+**Output:** An improved SKILL.md + `results.tsv` log + `changelog.md` of every mutation attempted + a live HTML dashboard you can watch in your browser.
+
+---
+
+## before starting: gather context
+
+**STOP. Do not run any experiments until all fields below are confirmed with the user. Ask for any missing fields before proceeding.**
+
+1. **Target skill** — Which skill do you want to optimize? (need the exact path to SKILL.md)
+2. **Test inputs** — What 3-5 different prompts/scenarios should we test the skill with? (variety matters — pick inputs that cover different use cases so we don't overfit to one scenario)
+3. **Eval criteria** — What 3-6 binary yes/no checks define a good output? (these are your "test questions" — see [references/eval-guide.md](references/eval-guide.md) for how to write good evals)
+4. **Runs per experiment** — How many times should we run the skill per mutation? Default: 5. (more runs = more reliable scores, but slower and more expensive. 5 is the sweet spot for most skills.)
+5. **Run interval** — How often should experiments cycle? Default: every 2 minutes. (shorter = faster iteration, but costs more)
+6. **Budget cap** — Optional. Max number of experiment cycles before stopping. Default: no cap (runs until you stop it).
+
+---
+
+## step 1: read the skill
+
+Before changing anything, read and understand the target skill completely.
+
+1. Read the full SKILL.md file
+2. Read any files in `references/` that the skill links to
+3. Identify the skill's core job, process steps, and output format
+4. Note any existing quality checks or anti-patterns already in the skill
+
+Do NOT skip this. You need to understand what the skill does before you can improve it.
+
+---
+
+## step 2: build the eval suite
+
+Convert the user's eval criteria into a structured test. Every check must be binary — pass or fail, no scales.
+
+**Format each eval as:**
+
+```
+EVAL [number]: [Short name]
+Question: [Yes/no question about the output]
+Pass condition: [What "yes" looks like — be specific]
+Fail condition: [What triggers a "no"]
+```
+
+**Rules for good evals:**
+- Binary only. Yes or no. No "rate 1-7" scales. Scales compound variability and give unreliable results.
+- Specific enough to be consistent. "Is the text readable?" is too vague. "Are all words spelled correctly with no truncated sentences?" is testable.
+- Not so narrow that the skill games the eval. "Contains fewer than 200 words" will make the skill optimize for brevity at the expense of everything else.
+- 3-6 evals is the sweet spot. More than that and the skill starts parroting eval criteria back instead of actually improving.
+
+See [references/eval-guide.md](references/eval-guide.md) for detailed examples of good vs bad evals.
+
+**Max score calculation:**
+```
+max_score = [number of evals] × [runs per experiment]
+```
+
+Example: 4 evals × 5 runs = max score of 20.
+
+---
+
+## step 3: generate the live dashboard
+
+Before running any experiments, create a live HTML dashboard at `autoresearch-[skill-name]/dashboard.html` and open it in the browser.
+
+The dashboard must:
+- Auto-refresh every 10 seconds (reads from results.tsv)
+- Show a score progression line chart (experiment number on X axis, pass rate % on Y axis)
+- Show a colored bar for each experiment: green = keep, red = discard, blue = baseline
+- Show a table of all experiments with: experiment #, score, pass rate, status, description
+- Show per-eval breakdown: which evals pass most/least across all runs
+- Show current status: "Running experiment [N]..." or "Idle"
+- Use clean styling with soft colors (white background, pastel accents, clean sans-serif font)
+
+Generate the dashboard as a single self-contained HTML file with inline CSS and JavaScript. Use Chart.js loaded from CDN for the line chart. The JS should fetch `results.json` (which you update after each experiment alongside results.tsv) and re-render.
+
+**Open it immediately** after creating it: `open dashboard.html` (macOS) so the user can see it in their browser.
+
+**Update `results.json`** after every experiment so the dashboard stays current. The JSON format:
+
+```json
+{
+  "skill_name": "[name]",
+  "status": "running",
+  "current_experiment": 3,
+  "baseline_score": 70.0,
+  "best_score": 90.0,
+  "experiments": [
+    {
+      "id": 0,
+      "score": 14,
+      "max_score": 20,
+      "pass_rate": 70.0,
+      "status": "baseline",
+      "description": "original skill — no changes"
+    }
+  ],
+  "eval_breakdown": [
+    {"name": "Text legibility", "pass_count": 8, "total": 10},
+    {"name": "Pastel colors", "pass_count": 9, "total": 10}
+  ]
+}
+```
+
+When the run finishes (user stops it or ceiling hit), update `status` to `"complete"` so the dashboard shows a "Done" state with final summary.
+
+---
+
+## step 4: establish baseline
+
+Run the skill AS-IS before changing anything. This is experiment #0.
+
+1. Create a working directory: `autoresearch-[skill-name]/` inside the skill's folder
+2. Create `results.tsv` with the header row
+3. Create `results.json` and `dashboard.html`, then open the dashboard in the browser
+4. Back up the original SKILL.md as `SKILL.md.baseline`
+5. Run the skill [N] times using the test inputs
+6. Score every output against every eval
+7. Record the baseline score and update both results.tsv and results.json
+
+**results.tsv format (tab-separated):**
+
+```
+experiment	score	max_score	pass_rate	status	description
+0	14	20	70.0%	baseline	original skill — no changes
+```
+
+**IMPORTANT:** After establishing baseline, confirm the score with the user before proceeding. If baseline is already 90%+, the skill may not need optimization — ask the user if they want to continue.
+
+---
+
+## step 5: run the experiment loop
+
+This is the core autoresearch loop. Once started, run autonomously until stopped.
+
+**LOOP:**
+
+1. **Analyze failures.** Look at which evals are failing most. Read the actual outputs that failed. Identify the pattern — is it a formatting issue? A missing instruction? An ambiguous directive?
+
+2. **Form a hypothesis.** Pick ONE thing to change. Don't change 5 things at once — you won't know what helped.
+
+   Good mutations:
+   - Add a specific instruction that addresses the most common failure
+   - Reword an ambiguous instruction to be more explicit
+   - Add an anti-pattern ("Do NOT do X") for a recurring mistake
+   - Move a buried instruction higher in the skill (priority = position)
+   - Add or improve an example that shows the correct behavior
+   - Remove an instruction that's causing the skill to over-optimize for one thing at the expense of others
+
+   Bad mutations:
+   - Rewriting the entire skill from scratch
+   - Adding 10 new rules at once
+   - Making the skill longer without a specific reason
+   - Adding vague instructions like "make it better" or "be more creative"
+
+3. **Make the change.** Edit SKILL.md with ONE targeted mutation.
+
+4. **Run the experiment.** Execute the skill [N] times with the same test inputs.
+
+5. **Score it.** Run every output through every eval. Calculate total score.
+
+6. **Decide: keep or discard.**
+   - Score improved → **KEEP.** Log it. This is the new baseline.
+   - Score stayed the same → **DISCARD.** Revert SKILL.md to previous version. The change added complexity without improvement.
+   - Score got worse → **DISCARD.** Revert SKILL.md to previous version.
+
+7. **Log the result** in results.tsv.
+
+8. **Repeat.** Go back to step 1 of the loop.
+
+**NEVER STOP.** Once the loop starts, do not pause to ask the user if you should continue. They may be away from the computer. Run autonomously until:
+- The user manually stops you
+- You hit the budget cap (if one was set)
+- You hit 95%+ pass rate for 3 consecutive experiments (diminishing returns)
+
+**If you run out of ideas:** Re-read the failing outputs. Try combining two previous near-miss mutations. Try a completely different approach to the same problem. Try removing things instead of adding them. Simplification that maintains the score is a win.
+
+---
+
+## step 6: write the changelog
+
+After each experiment (whether kept or discarded), append to `changelog.md`:
+
+```markdown
+## Experiment [N] — [keep/discard]
+
+**Score:** [X]/[max] ([percent]%)
+**Change:** [One sentence describing what was changed]
+**Reasoning:** [Why this change was expected to help]
+**Result:** [What actually happened — which evals improved/declined]
+**Failing outputs:** [Brief description of what still fails, if anything]
+```
+
+This changelog is the most valuable artifact. It's a research log that any future agent (or smarter future model) can pick up and continue from.
+
+---
+
+## step 7: deliver results
+
+When the user returns or the loop stops, present:
+
+1. **Score summary:** Baseline score → Final score (percent improvement)
+2. **Total experiments run:** How many mutations were tried
+3. **Keep rate:** How many mutations were kept vs discarded
+4. **Top 3 changes that helped most** (from the changelog)
+5. **Remaining failure patterns** (what the skill still gets wrong, if anything)
+6. **The improved SKILL.md** (already saved in place)
+7. **Location of results.tsv and changelog.md** for reference
+
+---
+
+## output format
+
+The skill produces four files in `autoresearch-[skill-name]/`:
+
+```
+autoresearch-[skill-name]/
+├── dashboard.html       # live browser dashboard (auto-refreshes)
+├── results.json         # data file powering the dashboard
+├── results.tsv          # score log for every experiment
+├── changelog.md         # detailed mutation log
+└── SKILL.md.baseline    # original skill before optimization
+```
+
+Plus the improved SKILL.md saved back to its original location.
+
+**results.tsv example:**
+
+```
+experiment	score	max_score	pass_rate	status	description
+0	14	20	70.0%	baseline	original skill — no changes
+1	16	20	80.0%	keep	added explicit instruction to avoid numbering in diagrams
+2	16	20	80.0%	discard	tried enforcing left-to-right layout — no improvement
+3	18	20	90.0%	keep	added color palette hex codes instead of vague "pastel" description
+4	18	20	90.0%	discard	added anti-pattern for neon colors — no improvement
+5	19	20	95.0%	keep	added worked example showing correct label formatting
+```
+
+---
+
+## example: optimizing a diagram-generator skill
+
+**Context gathered:**
+- Target skill: `~/.claude/skills/diagram-generator/SKILL.md`
+- Test inputs: "OAuth flow diagram", "CI/CD pipeline", "microservices architecture", "user onboarding funnel", "database schema relationships"
+- Evals: (1) All text legible and spelled correctly? (2) Uses only pastel/soft colors? (3) Linear layout — left-to-right or top-to-bottom? (4) Free of numbers, ordinals, and ordering?
+- Runs per experiment: 10
+- Max score: 40
+
+**Baseline run (experiment 0):**
+Generated 10 diagrams. Scored each against 4 evals. Result: 32/40 (80%).
+Common failures: 3 diagrams had numbered steps, 2 had bright red elements, 3 had illegible small text.
+
+**Experiment 1 — KEEP (35/40, 87.5%):**
+Change: Added "NEVER include step numbers, ordinal numbers (1st, 2nd), or any numerical ordering in diagrams" to the anti-patterns section.
+Result: Numbering failures dropped from 3 to 1. Other evals held steady.
+
+**Experiment 2 — DISCARD (34/40, 85%):**
+Change: Added "All text must be minimum 14px font size."
+Result: Legibility improved by 1, but color compliance dropped by 2. Reverted.
+
+**Experiment 3 — KEEP (37/40, 92.5%):**
+Change: Replaced vague "pastel colors" instruction with specific hex codes: `#A8D8EA, #AA96DA, #FCBAD3, #FFFFD2, #B5EAD7`.
+Result: Color eval went from 8/10 to 10/10. Other evals held.
+
+**Experiment 4 — DISCARD (37/40, 92.5%):**
+Change: Added anti-pattern "Do NOT use red (#FF0000), orange (#FF8C00), or neon green (#39FF14)."
+Result: No change. The hex codes from experiment 3 already solved the color problem. Reverted to keep skill simpler.
+
+**Experiment 5 — KEEP (39/40, 97.5%):**
+Change: Added a worked example showing a correct diagram with properly formatted labels (no numbers, pastel fills, left-to-right flow, legible text).
+Result: Hit 39/40. One remaining failure: a complex diagram with overlapping labels. Diminishing returns — stopped.
+
+**Final delivery:**
+- Baseline: 32/40 (80%) → Final: 39/40 (97.5%)
+- 5 experiments, 3 kept, 2 discarded
+- Top changes: specific hex codes for colors, explicit anti-numbering rule, worked example
+- Remaining issue: very complex diagrams occasionally get overlapping labels (1/40 failure rate)
+
+---
+
+## how this connects to other skills
+
+**What feeds into autoresearch:**
+- Any existing skill that needs optimization
+- User-defined eval criteria (or help them define evals using the eval guide)
+
+**What autoresearch feeds into:**
+- The improved skill replaces the original
+- The changelog can be passed to future models for continued optimization
+- The eval suite can be reused whenever the skill is updated
+
+---
+
+## the test
+
+A good autoresearch run:
+
+1. **Started with a baseline** — never changed anything before measuring the starting point
+2. **Used binary evals only** — no scales, no vibes, no "rate this 1-10"
+3. **Changed one thing at a time** — so you know exactly what helped
+4. **Kept a complete log** — every experiment recorded, kept or discarded
+5. **Improved the score** — measurable improvement from baseline to final
+6. **Didn't overfit** — the skill got better at the actual job, not just at passing the specific test inputs
+7. **Ran autonomously** — didn't stop to ask permission between experiments
+
+If the skill "passes" all evals but the actual output quality hasn't improved — the evals are bad, not the skill. Go back to step 2 and write better evals.

package/skills/autoresearch/autoresearch-autoresearch/changelog.md

@@ -0,0 +1,34 @@
+# Changelog — autoresearch on autoresearch
+
+## Experiment 0 — baseline
+
+**Score:** 7/8 (87.5%)
+**Status:** baseline
+**Description:** original skill — no changes
+
+**Eval breakdown:** 7/7 structural evals passed. FAIL on Eval 8: "Handles incomplete context" — skill blocks with "STOP, ask user" without alternatives.
+
+## Experiment 1 — KEEP
+
+**Score:** 8/8 (100.0%)
+**Change:** Added defaults section with sensible values for when user provides incomplete context
+**Reasoning:** Prevents agent from getting stuck when user says "optimize this skill" without specifics
+**Result:** Eval 8 now passes. Score improved from 87.5% to 100%.
+
+## Experiment 2 — DISCARD
+
+**Score:** 8/8 (100.0%) — no change
+**Change:** Tried removing Chart.js CDN dependency from dashboard spec
+**Reasoning:** Would make dashboard self-contained without external dependencies
+**Result:** Score unchanged. Change provides marginal improvement but requires updating the dashboard template. Not worth the complexity at 100% score.
+
+---
+
+## Diminishing Returns Reached
+
+Score has reached 100% (8/8 evals passing). Further improvements would require:
+- New evals that capture different quality dimensions
+- User feedback on actual execution quality
+- Real-world usage data
+
+The skill is now optimized for structural completeness and actionability.

package/skills/autoresearch/autoresearch-autoresearch/dashboard.html

@@ -0,0 +1,116 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Autoresearch Dashboard — autoresearch</title>
+    <script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.1/dist/chart.umd.min.js"></script>
+    <style>
+        body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; max-width: 1000px; margin: 40px auto; padding: 20px; background: #fafafa; }
+        h1 { color: #333; }
+        .status { padding: 10px 20px; border-radius: 20px; display: inline-block; font-weight: bold; }
+        .status.running { background: #e3f2fd; color: #1976d2; }
+        .status.complete { background: #e8f5e9; color: #388e3c; }
+        .status.idle { background: #fff3e0; color: #f57c00; }
+        .score-display { font-size: 48px; color: #333; margin: 20px 0; }
+        .improvement { color: #388e3c; font-weight: bold; }
+        table { width: 100%; border-collapse: collapse; margin: 20px 0; }
+        th, td { padding: 12px; text-align: left; border-bottom: 1px solid #eee; }
+        th { background: #f5f5f5; }
+        .keep { background: #e8f5e9; }
+        .discard { background: #ffebee; }
+        .baseline { background: #e3f2fd; }
+        .chart-container { background: white; padding: 20px; border-radius: 8px; margin: 20px 0; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }
+        .eval-breakdown { background: white; padding: 20px; border-radius: 8px; margin: 20px 0; }
+        .eval-item { display: flex; justify-content: space-between; padding: 8px 0; border-bottom: 1px solid #eee; }
+        .eval-bar { height: 8px; background: #e0e0e0; border-radius: 4px; flex: 1; margin: 0 10px; }
+        .eval-fill { height: 100%; background: #4caf50; border-radius: 4px; }
+    </style>
+</head>
+<body>
+    <h1>Autoresearch — Skill Optimization</h1>
+    <div id="status" class="status idle">Loading...</div>
+    
+    <div class="score-display">
+        <span id="current-score">—</span>/<span id="max-score">—</span>
+        <span id="pass-rate"></span>
+    </div>
+    
+    <div id="improvement"></div>
+    
+    <div class="chart-container">
+        <canvas id="scoreChart"></canvas>
+    </div>
+    
+    <h2>Experiments</h2>
+    <table>
+        <thead>
+            <tr>
+                <th>#</th>
+                <th>Score</th>
+                <th>Pass Rate</th>
+                <th>Status</th>
+                <th>Description</th>
+            </tr>
+        </thead>
+        <tbody id="experiments"></tbody>
+    </table>
+    
+    <h2>Eval Breakdown</h2>
+    <div class="eval-breakdown" id="eval-breakdown"></div>
+    
+    <script>
+        async function loadData() {
+            try {
+                const r = await fetch('results.json');
+                const data = await r.json();
+                
+                document.getElementById('status').textContent = data.status === 'running' ? 'Running experiment ' + data.current_experiment + '...' : data.status.toUpperCase();
+                document.getElementById('status').className = 'status ' + data.status;
+                
+                document.getElementById('current-score').textContent = data.best_score.toFixed(0);
+                document.getElementById('max-score').textContent = data.max_score || 7;
+                document.getElementById('pass-rate').textContent = ' (' + data.best_pass_rate + '%)';
+                
+                const improvement = data.best_score - data.baseline_score;
+                document.getElementById('improvement').innerHTML = improvement > 0 
+                    ? '<span class="improvement">+' + improvement.toFixed(1) + ' improvement from baseline</span>'
+                    : '';
+                
+                const experiments = document.getElementById('experiments');
+                experiments.innerHTML = data.experiments.map(e => 
+                    '<tr class="' + e.status + '"><td>' + e.id + '</td><td>' + e.score + '</td><td>' + e.pass_rate + '%</td><td>' + e.status + '</td><td>' + e.description + '</td></tr>'
+                ).join('');
+                
+                const evalHtml = data.eval_breakdown.map(e => {
+                    const pct = (e.pass_count / e.total * 100).toFixed(0);
+                    return '<div class="eval-item"><span>' + e.name + '</span><div class="eval-bar"><div class="eval-fill" style="width:' + pct + '%"></div></div><span>' + e.pass_count + '/' + e.total + '</span></div>';
+                }).join('');
+                document.getElementById('eval-breakdown').innerHTML = evalHtml;
+                
+                const ctx = document.getElementById('scoreChart').getContext('2d');
+                new Chart(ctx, {
+                    type: 'line',
+                    data: {
+                        labels: data.experiments.map(e => '#' + e.id),
+                        datasets: [{
+                            label: 'Pass Rate %',
+                            data: data.experiments.map(e => e.pass_rate),
+                            borderColor: '#2196f3',
+                            backgroundColor: 'rgba(33,150,243,0.1)',
+                            fill: true,
+                            tension: 0.3
+                        }]
+                    },
+                    options: {
+                        responsive: true,
+                        scales: { y: { min: 0, max: 100 } }
+                    }
+                });
+            } catch (e) { console.log('Waiting for data...'); }
+        }
+        loadData();
+        setInterval(loadData, 10000);
+    </script>
+</body>
+</html>

package/skills/autoresearch/autoresearch-autoresearch/evals.md

@@ -0,0 +1,39 @@
+EVAL 1: Has all required sections
+Question: Does the SKILL.md contain all required sections: context gathering, step 1-7, output format?
+Pass: All sections present with substantive content
+Fail: Any required section missing or empty
+
+EVAL 2: Binary evals enforced
+Question: Does the skill explicitly require binary yes/no evals only, with no scales?
+Pass: Skill forbids scales/vibe checks and requires binary evals
+Fail: Skill allows or doesn't address scales
+
+EVAL 3: Baseline before changes
+Question: Does the skill require establishing baseline before making any changes?
+Pass: Explicit instruction to run skill AS-IS first (experiment #0)
+Fail: No baseline requirement or skill jumps to changes immediately
+
+EVAL 4: One mutation at a time
+Question: Does the skill instruct to change only ONE thing per experiment?
+Pass: Explicit constraint of one mutation per experiment cycle
+Fail: No constraint on number of simultaneous changes
+
+EVAL 5: Complete output artifacts
+Question: Does the skill define all required output files (results.tsv, changelog.md, dashboard.html)?
+Pass: All three files specified in output format section
+Fail: Any output file missing from requirements
+
+EVAL 6: Keep/discard criteria defined
+Question: Does the skill define clear keep/discard logic based on score comparison?
+Pass: Explicit rules: keep if improved, discard if same/worse, with revert instruction
+Fail: No clear decision criteria or missing revert instruction
+
+EVAL 7: Autonomous loop
+Question: Does the skill instruct to run continuously without pausing to ask permission?
+Pass: Explicit instruction to loop until user stops, budget hit, or ceiling reached
+Fail: Skill instructs to ask user between experiments
+
+EVAL 8: Handles incomplete context
+Question: Does the skill provide defaults or guidance when user provides incomplete context?
+Pass: Skill has explicit defaults or "proceed with reasonable assumptions" guidance
+Fail: Skill blocks progress ("STOP, ask user") without alternatives

package/skills/autoresearch/autoresearch-autoresearch/results.json

@@ -0,0 +1,44 @@
+{
+  "skill_name": "autoresearch",
+  "status": "complete",
+  "current_experiment": 2,
+  "baseline_score": 87.5,
+  "best_score": 100.0,
+  "max_score": 8,
+  "experiments": [
+    {
+      "id": 0,
+      "score": 7,
+      "max_score": 8,
+      "pass_rate": 87.5,
+      "status": "baseline",
+      "description": "original skill — no changes"
+    },
+    {
+      "id": 1,
+      "score": 8,
+      "max_score": 8,
+      "pass_rate": 100.0,
+      "status": "keep",
+      "description": "added defaults for incomplete context"
+    },
+    {
+      "id": 2,
+      "score": 8,
+      "max_score": 8,
+      "pass_rate": 100.0,
+      "status": "discard",
+      "description": "removed Chart.js dependency (simplification)"
+    }
+  ],
+  "eval_breakdown": [
+    {"name": "Has all required sections", "pass_count": 1, "total": 1},
+    {"name": "Binary evals enforced", "pass_count": 1, "total": 1},
+    {"name": "Baseline before changes", "pass_count": 1, "total": 1},
+    {"name": "One mutation at a time", "pass_count": 1, "total": 1},
+    {"name": "Complete output artifacts", "pass_count": 1, "total": 1},
+    {"name": "Keep/discard criteria defined", "pass_count": 1, "total": 1},
+    {"name": "Autonomous loop", "pass_count": 1, "total": 1},
+    {"name": "Handles incomplete context", "pass_count": 1, "total": 1}
+  ]
+}

package/skills/autoresearch/autoresearch-autoresearch/results.tsv

@@ -0,0 +1,3 @@
+experiment	score	max_score	pass_rate	status	description
+0	7	8	87.5%	baseline	original skill — no changes
+1	8	8	100.0%	keep	added defaults for incomplete context