@research-copilot/plugin 1.1.17 → 1.1.18

package/dist/skills/idea-creator/SKILL.md

@@ -0,0 +1,311 @@
+---
+name: "idea-creator"
+description: "Generate and rank research ideas given a broad direction. Use when user says \"\u627eidea\", \"brainstorm ideas\", \"generate research ideas\", \"what can we work on\", or wants to explore a research area for publishable directions."
+---
+
+# Research Idea Creator
+
+Generate publishable research ideas for: $ARGUMENTS
+
+## Overview
+
+Given a broad research direction from the user, systematically generate, validate, and rank concrete research ideas. Standalone, Phase 1's landscape survey is **inline** (WebSearch — it does not invoke `/research-lit`); Phases 4-5 invoke `/novelty-check`, `/run-experiment`, and `/monitor-experiment` for validation and pilots. For the full sub-skill pipeline (`/research-lit` → idea generation → `/novelty-check` → `/research-review`), run `/idea-discovery` (Workflow 1), which orchestrates this skill.
+
+## Constants
+
+- **PILOT_MAX_HOURS = 2** — Skip any pilot estimated to take > 2 hours per GPU. Flag as "needs manual pilot".
+- **PILOT_TIMEOUT_HOURS = 3** — Hard timeout: kill pilots exceeding 3 hours. Collect partial results if available.
+- **MAX_PILOT_IDEAS = 3** — Pilot at most 3 ideas in parallel. Additional ideas are validated on paper only.
+- **MAX_TOTAL_GPU_HOURS = 8** — Total GPU budget for all pilots combined.
+- **REVIEWER_MODEL = `gpt-5.5`** — Model used via a secondary Codex agent for brainstorming and review. Must be an OpenAI model (e.g., `gpt-5.5`, `o3`, `gpt-4o`).
+- **REVIEWER_BACKEND = `codex`** — Default: Codex xhigh reviewer through `spawn_agent` / `send_input`. Use `--reviewer: oracle-pro` only when explicitly requested; if Oracle is unavailable, warn and fall back to Codex xhigh.
+- **OUTPUT_DIR = `idea-stage/`** — All idea-stage outputs go here. Create the directory if it doesn't exist.
+
+> 💡 Override via argument, e.g., `/idea-creator "topic" — pilot budget: 4h per idea, 20h total`.
+
+## Workflow
+
+### Phase 0: Load Research Wiki (if active)
+
+Skip this phase entirely if `research-wiki/` does not exist.
+
+Resolve the wiki helper using the Codex-side canonical chain (see
+`../shared-references/wiki-helper-resolution.md`):
+
+```bash
+ARIS_REPO="${ARIS_REPO:-$(awk -F'\t' '$1=="repo_root"{print $2; exit}' .aris/installed-skills-codex.txt 2>/dev/null)}"
+WIKI_SCRIPT=""
+[ -n "$ARIS_REPO" ] && [ -f "$ARIS_REPO/tools/research_wiki.py" ] && WIKI_SCRIPT="$ARIS_REPO/tools/research_wiki.py"
+[ -z "$WIKI_SCRIPT" ] && [ -f tools/research_wiki.py ] && WIKI_SCRIPT="tools/research_wiki.py"
+[ -z "$WIKI_SCRIPT" ] && [ -f ~/.codex/skills/research-wiki/research_wiki.py ] && WIKI_SCRIPT="$HOME/.codex/skills/research-wiki/research_wiki.py"
+```
+
+If `research-wiki/query_pack.md` exists and is less than 7 days old, read it as initial landscape context:
+
+- treat listed gaps as priority search seeds
+- treat failed ideas as a banlist
+- treat top papers as known prior work
+- still run Phase 1 for papers from the last 3-6 months because the wiki may be stale
+
+If `research-wiki/` exists but `query_pack.md` is stale or missing, rebuild it only when `WIKI_SCRIPT` is available. If the helper is unavailable, continue without rebuilding and report that wiki refresh was skipped.
+
+### Phase 1: Landscape Survey (5-10 min)
+
+Map the research area to understand what exists and where the gaps are.
+
+1. **Scan local paper library first**: Check `papers/` and `literature/` in the project directory for existing PDFs. Read first 3 pages of relevant papers to build a baseline understanding before searching online. This avoids re-discovering what the user already knows.
+
+2. **Search recent literature** using WebSearch:
+   - Top venues in the last 2 years (NeurIPS, ICML, ICLR, ACL, EMNLP, etc.)
+   - Recent arXiv preprints (last 6 months)
+   - Use 5+ different query formulations
+   - Read abstracts and introductions of the top 10-15 papers
+
+2. **Build a landscape map**:
+   - Group papers by sub-direction / approach
+   - Identify what has been tried and what hasn't
+   - Note recurring limitations mentioned in "Future Work" sections
+   - Flag any open problems explicitly stated by multiple papers
+
+3. **Identify structural gaps**:
+   - Methods that work in domain A but haven't been tried in domain B
+   - Contradictory findings between papers (opportunity for resolution)
+   - Assumptions that everyone makes but nobody has tested
+   - Scaling regimes that haven't been explored
+   - Diagnostic questions that nobody has asked
+
+### Phase 2: Idea Generation (brainstorm with external LLM)
+
+Use a secondary Codex agent for divergent thinking:
+
+```
+spawn_agent:
+  model: REVIEWER_MODEL
+  reasoning_effort: xhigh
+  message: |
+    You are a senior ML researcher brainstorming research ideas.
+
+    Research direction: [user's direction]
+
+    Here is the current landscape:
+    [paste landscape map from Phase 1]
+
+    Key gaps identified:
+    [paste gaps from Phase 1]
+
+    Generate 8-12 concrete research ideas. For each idea:
+    1. One-sentence summary
+    2. Core hypothesis (what you expect to find and why)
+    3. Minimum viable experiment (what's the cheapest way to test this?)
+    4. Expected contribution type: empirical finding / new method / theoretical result / diagnostic
+    5. Risk level: LOW (likely works) / MEDIUM (50-50) / HIGH (speculative)
+    6. Estimated effort: days / weeks / months
+
+    Prioritize ideas that are:
+    - Testable with moderate compute (8x RTX 3090 or less)
+    - Likely to produce a clear positive OR negative result (both are publishable)
+    - Not "apply X to Y" unless the application reveals genuinely surprising insights
+    - Differentiated from the 10-15 papers above
+
+    Be creative but grounded. A great idea is one where the answer matters regardless of which way it goes.
+```
+
+Save the agent id for follow-up.
+
+Save a Review Tracing record for this `spawn_agent` call following `../shared-references/review-tracing.md`, including the landscape summary, prompt summary, raw idea list path, reviewer route, and saved agent id.
+
+### Phase 3: Mechanical consolidation + objective feasibility gate
+
+> This phase does NOT judge idea quality, novelty, or impact — those are the
+> job of the Phase-4 cross-model reviewer (a different model family). Dropping
+> ideas here on a same-family novelty or impact call would pre-filter the
+> reviewer's input with same-family judgment — the opposite of why ARIS uses a
+> cross-model reviewer at all. Phase 3 only (a) clusters near-duplicate ideas
+> and (b) drops ideas that are OBJECTIVELY out of budget; everything else
+> passes through ANNOTATED, not eliminated.
+
+1. **Objective feasibility gate (safe to gate here)**: drop an idea ONLY on a
+   mechanical, budget-based fact — estimated compute > 1 week of available GPU
+   time, OR a dataset that is provably unavailable. Do NOT drop on
+   "implementation looks complex" — annotate complexity instead.
+
+2. **Novelty signal — ANNOTATE, do not eliminate**: do 2-3 targeted searches
+   and attach a `prior_work` note (what looks related, with links). This is
+   input for the Phase-4 reviewer, not a filter; full `/novelty-check` runs in
+   Phase 4. Do NOT drop an idea here because it "might already be done."
+
+3. **Impact signal — ANNOTATE, do not eliminate**: attach a one-line `so_what`
+   note (why the result would matter either way). Do NOT drop on a same-family
+   "a reviewer wouldn't care" call — that is exactly what the Phase-4
+   cross-model reviewer is for.
+
+Every feasible, non-duplicate idea — with its `prior_work` and `so_what`
+annotations — proceeds to Phase 4, where the cross-model reviewer does the
+quality/novelty narrowing.
+
+### Phase 4: Deep Validation (for top ideas)
+
+For each surviving idea, run a deeper evaluation:
+
+1. **Novelty check**: Use the `/novelty-check` workflow (multi-source search + GPT-5.5 cross-verification) for each idea
+
+2. **Critical review**: Use GPT-5.5 via `send_input` (same agent):
+   ```text
+   send_input:
+     target: [saved reviewer id from the earlier idea review]
+     message: |
+       Here are our top ideas after filtering:
+       [paste surviving ideas with novelty check results]
+
+       For each, play devil's advocate:
+       - What's the strongest objection a reviewer would raise?
+       - What's the most likely failure mode?
+       - How would you rank these for a top venue submission?
+       - Which 2-3 would you actually work on?
+   ```
+
+3. **Combine rankings**: Merge your assessment with GPT-5.5's ranking. Select top 2-3 ideas for pilot experiments.
+
+### Phase 5: Parallel Pilot Experiments (for top 2-3 ideas)
+
+Before committing to a full research effort, run cheap pilot experiments to get empirical signal. This is the key differentiator from paper-only validation.
+
+1. **Design pilots**: For each top idea, define the minimal experiment that would give a positive or negative signal:
+   - Single seed, small scale (e.g., small dataset subset, fewer epochs)
+   - Target: 30 min - PILOT_MAX_HOURS per pilot on 1 GPU
+   - **Estimate GPU-hours BEFORE launching.** If estimated time > PILOT_MAX_HOURS, reduce scale (fewer epochs, smaller subset) or flag as "needs manual pilot"
+   - Clear success metric defined upfront (e.g., "if metric improves by > 1%, signal is positive")
+
+2. **Deploy in parallel**: Use `/run-experiment` to launch pilots on different GPUs simultaneously:
+   ```
+   GPU 0: Pilot for Idea 1
+   GPU 1: Pilot for Idea 2
+   GPU 2: Pilot for Idea 3
+   ```
+   Use `run_in_background: true` to launch all at once.
+
+3. **Collect results**: Use `/monitor-experiment` to check progress. If any pilot exceeds PILOT_TIMEOUT_HOURS, kill it and collect partial results. Once all pilots complete (or timeout), compare:
+   - Which ideas showed positive signal?
+   - Which showed null/negative results? (eliminate or deprioritize)
+   - Any surprising findings that suggest a pivot?
+   - Total GPU-hours consumed (track against MAX_TOTAL_GPU_HOURS budget)
+
+4. **Re-rank based on empirical evidence**: Update the idea ranking using pilot results. An idea with strong pilot signal jumps ahead of a theoretically appealing but untested idea.
+
+Note: Skip this phase if the ideas are purely theoretical or if no GPU is available. Flag skipped ideas as "needs pilot validation" in the report.
+
+### Phase 6: Output — Ranked Idea Report
+
+Write a structured report to `idea-stage/IDEA_REPORT.md`:
+
+**Lead every recommended idea with its method, in plain language.** Before any hypothesis, novelty score, or claim, state in 2–4 concrete steps what we actually build / train / run — no jargon, no claim-IDs. The reader must understand *what we do* before *what we claim*; claims (hypothesis, validation, expected outcome) come after and read as the method's acceptance criteria.
+
+```markdown
+# Research Idea Report
+
+**Direction**: [user's research direction]
+**Generated**: [date]
+**Ideas evaluated**: X generated → Y survived filtering → Z piloted → W recommended
+
+## Landscape Summary
+[3-5 paragraphs on the current state of the field]
+
+## Recommended Ideas (ranked)
+
+### Idea 1: [title]
+- **Method (what we actually do)**: [2–4 concrete steps in plain language — what we build / train / run. No jargon, no claim-IDs, no hypothesis yet. Lead with this so the reader grasps the approach first.]
+- **Hypothesis**: [one sentence]
+- **Minimum experiment**: [concrete description]
+- **Expected outcome**: [what success/failure looks like]
+- **Novelty**: X/10 — closest work: [paper]
+- **Feasibility**: [compute, data, implementation estimates]
+- **Risk**: LOW/MEDIUM/HIGH
+- **Contribution type**: empirical / method / theory / diagnostic
+- **Pilot result**: [POSITIVE: metric +X% / NEGATIVE: no signal / SKIPPED: needs GPU]
+- **Reviewer's likely objection**: [strongest counterargument]
+- **Why we should do this**: [1-2 sentences]
+
+### Idea 2: [title]
+...
+
+## Eliminated Ideas (for reference)
+| Idea | Reason eliminated |
+|------|-------------------|
+| ... | Already done by [paper] |
+| ... | Requires > 1 week GPU time |
+| ... | Result wouldn't be interesting either way |
+
+## Pilot Experiment Results
+| Idea | GPU | Time | Key Metric | Signal |
+|------|-----|------|------------|--------|
+| Idea 1 | GPU 0 | 45 min | +2.3% CE | POSITIVE |
+| Idea 2 | GPU 1 | 30 min | -0.1% CE | NEGATIVE |
+| Idea 3 | GPU 2 | 1.5 hr | +0.8% CE | WEAK POSITIVE |
+
+## Suggested Execution Order
+1. Start with Idea 1 (positive pilot signal, lowest risk)
+2. Idea 3 as backup (weak signal, may need larger scale to confirm)
+3. Idea 2 eliminated by pilot — negative result documented
+
+## Next Steps
+- [ ] Scale up Idea 1 to full experiment (multi-seed, full dataset)
+- [ ] If confirmed, invoke /auto-review-loop for full iteration
+```
+
+## Phase 7: Write Ideas to Research Wiki (if active)
+
+Skip this phase entirely if `research-wiki/` does not exist.
+
+This is critical for spiral learning: without it, `ideas/` stays empty and re-ideation has no memory.
+
+For each recommended and eliminated idea:
+
+1. Create or update `research-wiki/ideas/<idea_id>.md`.
+2. Include `node_id`, `stage`, `outcome`, `based_on`, `target_gaps`, hypothesis, proposed method, expected outcome, and pilot results when available.
+3. If `WIKI_SCRIPT` is available, add edges from idea to source papers and target gaps, then rebuild `query_pack.md`.
+4. If `WIKI_SCRIPT` is unavailable, write the idea pages and report that graph edges/query-pack rebuild require ARIS `research_wiki.py`.
+
+Required edge semantics when helper support exists:
+
+```text
+idea:<id> --inspired_by--> paper:<slug>
+idea:<id> --addresses_gap--> gap:<id>
+```
+
+Log the update as: `idea-creator wrote N ideas (M recommended, K eliminated)`.
+
+## Output Protocols
+
+> Follow these shared protocols for all output files:
+> - **[Output Versioning Protocol](../../shared-references/output-versioning.md)** — write timestamped file first, then copy to fixed name
+> - **[Output Manifest Protocol](../../shared-references/output-manifest.md)** — log every output to MANIFEST.md
+> - **[Output Language Protocol](../../shared-references/output-language.md)** — respect the project's language setting
+
+## Key Rules
+
+- **Large file handling**: If the Write tool fails due to file size, immediately retry using Bash (`cat << 'EOF' > file`) to write in chunks. Do NOT ask the user for permission — just do it silently.
+
+- The user provides a DIRECTION, not an idea. Your job is to generate the ideas.
+- Quantity first, quality second: brainstorm broadly, then filter ruthlessly.
+- A good negative result is just as publishable as a positive one. Prioritize ideas where the answer matters regardless of direction.
+- Don't fall in love with any idea before validating it. Be willing to kill ideas.
+- Always estimate compute cost. An idea that needs 1000 GPU-hours is not actionable for most researchers.
+- "Apply X to Y" is the lowest form of research idea. Push for deeper questions.
+- Include eliminated ideas in the report — they save future time by documenting dead ends.
+- **If the user's direction is too broad (e.g., "NLP", "computer vision", "reinforcement learning"), STOP and ask them to narrow it.** A good direction is 1-2 sentences specifying the problem, domain, and constraint — e.g., "factorized gap in discrete diffusion LMs" or "sample efficiency of offline RL with image observations". Without sufficient specificity, generated ideas will be too vague to run experiments on.
+
+## Composing with Other Skills
+
+After this skill produces the ranked report:
+```
+/idea-creator "direction"     → ranked ideas
+/novelty-check "top idea"     → deep novelty verification (already done in Phase 4, but user can re-run)
+/research-review "top idea"   → external critical feedback
+implement                     → write code
+/run-experiment               → deploy to GPU
+/auto-review-loop             → iterate until submission-ready
+```
+
+## Review Tracing
+
+After each `spawn_agent` or `send_input` reviewer call, save the trace following `../shared-references/review-tracing.md`. Include the reviewer route, saved agent id, prompt summary, raw output path, selected ideas, and rejected ideas.

package/dist/skills/idea-discovery/SKILL.md

@@ -0,0 +1,340 @@
+---
+name: "idea-discovery"
+description: "Workflow 1: Full idea discovery pipeline to go from a broad research direction to validated, pilot-tested ideas. Use when user says \"找idea全流程\", \"idea discovery pipeline\", \"从零开始找方向\", or wants the complete idea exploration workflow."
+---
+
+# Workflow 1: Idea Discovery Pipeline
+
+Orchestrate a complete idea discovery workflow for: **$ARGUMENTS**
+
+## Overview
+
+This skill chains sub-skills into a single automated pipeline:
+
+```
+/research-lit → /idea-creator → /novelty-check → /research-review → /research-refine-pipeline
+  (survey)      (brainstorm)    (verify novel)    (critical feedback)  (refine method + plan experiments)
+```
+
+Each phase builds on the previous one's output. The final deliverables are a validated `idea-stage/IDEA_REPORT.md` with ranked ideas, plus a refined proposal (`refine-logs/FINAL_PROPOSAL.md`) and experiment plan (`refine-logs/EXPERIMENT_PLAN.md`) for the top idea.
+
+## Constants
+
+- **PILOT_MAX_HOURS = 2** — Skip any pilot experiment estimated to take > 2 hours per GPU. Flag as "needs manual pilot" in the report.
+- **PILOT_TIMEOUT_HOURS = 3** — Hard timeout: kill any running pilot that exceeds 3 hours. Collect partial results if available.
+- **MAX_PILOT_IDEAS = 3** — Run pilots for at most 3 top ideas in parallel. Additional ideas are validated on paper only.
+- **MAX_TOTAL_GPU_HOURS = 8** — Total GPU budget across all pilots. If exceeded, skip remaining pilots and note in report.
+- **AUTO_PROCEED = true** — If user doesn't respond at a checkpoint, automatically proceed with the best option after presenting results. Set to `false` to always wait for explicit user confirmation.
+- **REVIEWER_MODEL = `gpt-5.5`** — Model used via a secondary Codex agent. Must be an OpenAI model (e.g., `gpt-5.5`, `o3`, `gpt-4o`). Passed to sub-skills.
+- **ARXIV_DOWNLOAD = false** — When `true`, `/research-lit` downloads the top relevant arXiv PDFs during Phase 1. When `false` (default), only fetches metadata. Passed through to `/research-lit`.
+- **COMPACT = false** — When `true`, generate compact summary files for short-context sessions and downstream skills. Writes `idea-stage/IDEA_CANDIDATES.md`.
+- **OUTPUT_DIR = `idea-stage/`** — All idea-stage outputs go here. Create the directory if it doesn't exist.
+- **REF_PAPER = false** — Reference paper to base ideas on. Accepts a local PDF path, arXiv URL, or paper URL. When set, summarize it first and use it as idea-generation context.
+- **RENDER_HTML = true** — When `true` (default), auto-render `idea-stage/IDEA_REPORT.md` to HTML at workflow end via `/render-html`. Uses `--no-review` (source already passed novelty + cross-model review during Phase 3). Set `false` to skip, or pass `— render html: false`.
+
+> 💡 These are defaults. Override by telling the skill, e.g., `/idea-discovery "topic" — ref paper: https://arxiv.org/abs/2406.04329` or `/idea-discovery "topic" — compact: true`.
+
+## Pipeline
+
+### Phase 0: Load Research Brief (if available)
+
+Before starting any other phase, check for a detailed research brief in the project:
+
+1. Look for `RESEARCH_BRIEF.md` in the project root or a path passed in `$ARGUMENTS`.
+2. If found, read it and extract:
+   - problem statement and context
+   - constraints: compute, data, timeline, venue
+   - what the user already tried and what did not work
+   - domain knowledge and non-goals
+   - existing results, if any
+3. Use this as the primary context for all subsequent phases; it replaces the one-line prompt when more specific.
+4. If both `RESEARCH_BRIEF.md` and one-line `$ARGUMENTS` exist, merge them: the brief has priority for details, and the argument sets the direction.
+
+If no brief exists, proceed normally with `$ARGUMENTS` as the research direction.
+
+Recommended template:
+
+```markdown
+# Research Brief
+
+## Problem Statement
+[What problem are we trying to solve?]
+
+## Context
+[Relevant field, current approach, why this matters]
+
+## Constraints
+- Compute:
+- Data:
+- Timeline:
+- Target venue:
+
+## What We Already Tried
+- [attempt] -> [outcome]
+
+## Non-Goals
+- [what not to pursue]
+```
+
+### Phase 0.5: Reference Paper Summary (when REF_PAPER is set)
+
+**Skip entirely if `REF_PAPER` is `false`.**
+
+Summarize the reference paper before searching the literature:
+
+1. **If arXiv URL** — invoke `/arxiv "ARXIV_ID" — download` to fetch the PDF, then read the first 5 pages.
+2. **If local PDF path** — read the PDF directly, focusing on the title, abstract, introduction, and method overview.
+3. **If other URL** — fetch the content and extract the method, results, and limitations.
+4. **Generate `idea-stage/REF_PAPER_SUMMARY.md`** using this template:
+
+```markdown
+# Reference Paper Summary
+
+## What They Did
+[2-3 sentences: core method and contribution]
+
+## Key Results
+[Main quantitative findings]
+
+## Limitations & Open Questions
+[Acknowledged weaknesses, missing experiments, future work]
+
+## Potential Improvement Directions
+[Concrete ways to extend, challenge, or improve the paper]
+
+## Codebase
+[If `base repo` is set: link to the repo and identify relevant entry points]
+```
+
+Use `idea-stage/REF_PAPER_SUMMARY.md` as additional context in both Phase 1 and Phase 2.
+
+### Phase 1: Literature Survey
+
+Invoke `/research-lit` to map the research landscape:
+
+```
+/research-lit "$ARGUMENTS"
+```
+
+**What this does:**
+- Search arXiv, Google Scholar, Semantic Scholar for recent papers
+- Build a landscape map: sub-directions, approaches, open problems
+- Identify structural gaps and recurring limitations
+- Output a literature summary (saved to working notes)
+
+**🚦 Checkpoint:** Present the landscape summary to the user. Ask:
+
+```
+📚 Literature survey complete. Here's what I found:
+- [key findings, gaps, open problems]
+
+Does this match your understanding? Should I adjust the scope before generating ideas?
+(If no response, I'll proceed with the top-ranked direction.)
+```
+
+- **User approves** (or no response + AUTO_PROCEED=true) → proceed to Phase 2 with best direction.
+- **User requests changes** (e.g., "focus more on X", "ignore Y", "too broad") → refine the search with updated queries, re-run `/research-lit` with adjusted scope, and present again. Repeat until the user is satisfied.
+
+### Phase 2: Idea Generation + Filtering + Pilots
+
+Invoke `/idea-creator` with the landscape context and `idea-stage/REF_PAPER_SUMMARY.md` if available:
+
+```
+/idea-creator "$ARGUMENTS"
+```
+
+**What this does:**
+- If `idea-stage/REF_PAPER_SUMMARY.md` exists, include it as context so ideas explicitly build on, improve, or extend the reference paper
+- Brainstorm 8-12 concrete ideas via GPT-5.5 xhigh
+- Filter by feasibility, compute cost, quick novelty search
+- Deep validate top ideas (full novelty check + devil's advocate)
+- Run parallel pilot experiments on available GPUs (top 2-3 ideas)
+- Rank by empirical signal
+- Output `idea-stage/IDEA_REPORT.md`
+
+**🚦 Checkpoint:** Present `idea-stage/IDEA_REPORT.md` ranked ideas to the user. Ask:
+
+```
+💡 Generated X ideas, filtered to Y, piloted Z. Top results:
+
+1. [Idea 1] — Pilot: POSITIVE (+X%)
+2. [Idea 2] — Pilot: WEAK POSITIVE (+Y%)
+3. [Idea 3] — Pilot: NEGATIVE, eliminated
+
+Which ideas should I validate further? Or should I regenerate with different constraints?
+(If no response, I'll proceed with the top-ranked ideas.)
+```
+
+- **User picks ideas** (or no response + AUTO_PROCEED=true) → proceed to Phase 3 with top-ranked ideas.
+- **User unhappy with all ideas** → collect feedback ("what's missing?", "what direction do you prefer?"), update the prompt with user's constraints, and re-run Phase 2 (idea generation). Repeat until the user selects at least 1 idea.
+- **User wants to adjust scope** → go back to Phase 1 with refined direction.
+
+### Phase 3: Deep Novelty Verification
+
+For each top idea (positive pilot signal), run a thorough novelty check:
+
+```
+/novelty-check "[top idea 1 description]"
+/novelty-check "[top idea 2 description]"
+```
+
+**What this does:**
+- Multi-source literature search (arXiv, Scholar, Semantic Scholar)
+- Cross-verify with GPT-5.5 xhigh
+- Check for concurrent work (last 3-6 months)
+- Identify closest existing work and differentiation points
+
+**Update `idea-stage/IDEA_REPORT.md`** with deep novelty results. Eliminate any idea that turns out to be already published.
+
+### Phase 4: External Critical Review
+
+For the surviving top idea(s), get brutal feedback:
+
+```
+/research-review "[top idea with hypothesis + pilot results]"
+```
+
+**What this does:**
+- GPT-5.5 xhigh acts as a senior reviewer (NeurIPS/ICML level)
+- Scores the idea, identifies weaknesses, suggests minimum viable improvements
+- Provides concrete feedback on experimental design
+
+**Update `idea-stage/IDEA_REPORT.md`** with reviewer feedback and revised plan.
+
+### Phase 4.5: Method Refinement + Experiment Planning
+
+After review, refine the top idea into a concrete proposal and plan experiments:
+
+```
+/research-refine-pipeline "[top idea description + pilot results + reviewer feedback]"
+```
+
+**What this does:**
+- Freeze a **Problem Anchor** to prevent scope drift
+- Iteratively refine the method via GPT-5.5 review (up to 5 rounds, until score ≥ 9)
+- Generate a claim-driven experiment roadmap with ablations, budgets, and run order
+- Output: `refine-logs/FINAL_PROPOSAL.md`, `refine-logs/EXPERIMENT_PLAN.md`, `refine-logs/EXPERIMENT_TRACKER.md`
+
+**🚦 Checkpoint:** Present the refined proposal summary:
+
+```
+🔬 Method refined and experiment plan ready:
+- Problem anchor: [anchored problem]
+- Method thesis: [one sentence]
+- Dominant contribution: [what's new]
+- Must-run experiments: [N blocks]
+- First 3 runs to launch: [list]
+
+Proceed to implementation? Or adjust the proposal?
+```
+
+- **User approves** (or AUTO_PROCEED=true) → proceed to Final Report.
+- **User requests changes** → pass feedback to `/research-refine` for another round.
+- **Lite mode:** If reviewer score < 6 or pilot was weak, run `/research-refine` only (skip `/experiment-plan`) and note remaining risks in the report.
+
+### Phase 5: Final Report
+
+Finalize `idea-stage/IDEA_REPORT.md` with all accumulated information:
+
+```markdown
+# Idea Discovery Report
+
+**Direction**: $ARGUMENTS
+**Date**: [today]
+**Pipeline**: research-lit → idea-creator → novelty-check → research-review → research-refine-pipeline
+
+## Executive Summary
+[2-3 sentences: best idea, key evidence, recommended next step]
+
+## Literature Landscape
+[from Phase 1]
+
+## Ranked Ideas
+[from Phase 2, updated with Phase 3-4 results]
+
+### 🏆 Idea 1: [title] — RECOMMENDED
+- Pilot: POSITIVE (+X%)
+- Novelty: CONFIRMED (closest: [paper], differentiation: [what's different])
+- Reviewer score: X/10
+- Next step: implement full experiment → /auto-review-loop
+
+### Idea 2: [title] — BACKUP
+...
+
+## Eliminated Ideas
+[ideas killed at each phase, with reasons]
+
+## Refined Proposal
+- Proposal: `refine-logs/FINAL_PROPOSAL.md`
+- Experiment plan: `refine-logs/EXPERIMENT_PLAN.md`
+- Tracker: `refine-logs/EXPERIMENT_TRACKER.md`
+
+## Next Steps
+- [ ] /run-experiment to deploy experiments from the plan
+- [ ] /auto-review-loop to iterate until submission-ready
+- [ ] Or invoke /research-pipeline for the complete end-to-end flow
+```
+
+### Phase 5.5: Write Compact Files (when COMPACT = true)
+
+**Skip entirely if `COMPACT` is `false`.**
+
+Write `idea-stage/IDEA_CANDIDATES.md` — a lean summary of the top 3-5 surviving ideas:
+
+```markdown
+# Idea Candidates
+
+| # | Idea | Pilot Signal | Novelty | Reviewer Score | Status |
+|---|------|-------------|---------|---------------|--------|
+| 1 | [title] | +X% | Confirmed | X/10 | RECOMMENDED |
+| 2 | [title] | +Y% | Confirmed | X/10 | BACKUP |
+| 3 | [title] | Negative | — | — | ELIMINATED |
+
+## Active Idea: #1 — [title]
+- Hypothesis: [one sentence]
+- Key evidence: [pilot result]
+- Next step: /experiment-bridge or /research-refine
+```
+
+## Output Protocols
+
+> Follow these shared protocols for all output files:
+> - **[Output Versioning Protocol](../../shared-references/output-versioning.md)** — write timestamped file first, then copy to fixed name
+> - **[Output Manifest Protocol](../../shared-references/output-manifest.md)** — log every output to MANIFEST.md
+> - **[Output Language Protocol](../../shared-references/output-language.md)** — respect the project's language setting
+
+## Render HTML view (auto, when `RENDER_HTML = true`)
+
+After finalizing `idea-stage/IDEA_REPORT.md` (and the optional `IDEA_CANDIDATES.md`), invoke `/render-html` on the report so the user has a single-file HTML view for tablet / phone reading:
+
+```
+/render-html "idea-stage/IDEA_REPORT.md" --no-review
+```
+
+`--no-review` is intentional: source MD already passed this skill's own novelty + cross-model review. HTML render is a structural conversion, not a new claim-audit gate.
+
+**Non-blocking**: if `/render-html` fails (helper missing, secondary Codex agent unavailable, file write error), log the failure and continue. Skip entirely if `RENDER_HTML = false`.
+
+## Key Rules
+
+- **Large file handling**: If the Write tool fails due to file size, immediately retry using Bash (`cat << 'EOF' > file`) to write in chunks. Do NOT ask the user for permission — just do it silently.
+
+- **Don't skip phases.** Each phase filters and validates — skipping leads to wasted effort later.
+- **Checkpoint between phases.** Briefly summarize what was found before moving on.
+- **Kill ideas early.** It's better to kill 10 bad ideas in Phase 3 than to implement one and fail.
+- **Empirical signal > theoretical appeal.** An idea with a positive pilot outranks a "sounds great" idea without evidence.
+- **Document everything.** Dead ends are just as valuable as successes for future reference.
+- **Be honest with the reviewer.** Include negative results and failed pilots in the review prompt.
+- **Feishu notifications are optional.** If `~/.codex/feishu.json` exists, send `checkpoint` at each phase transition and `pipeline_done` at final report. If absent/off, skip silently.
+
+## Composing with Workflow 2
+
+After this pipeline produces a validated top idea:
+
+```
+/idea-discovery "direction"         ← you are here (Workflow 1, includes method refinement + experiment planning)
+/run-experiment                     ← deploy experiments from the plan
+/auto-review-loop "top idea"        ← Workflow 2: iterate until submission-ready
+
+Or use /research-pipeline for the full end-to-end flow.
+```