Outline Generation Overview

problem definition

Input: research area $A$ and in-scope papers $P$
Output: a survey outline $O$

Skills:

• create-outline — orchestrates the complete evidence, design, review, and finalization pipeline
• web-research — researches the area online and writes a concise, cited field report
• select-outline-lens — develops three organizing-lens variants, compares them, and synthesizes an outline backbone
• compare-outline-variants — compares the lenses embodied in complete outline variants and selects a backbone
• select-outline-structure — develops structural refinements while holding the selected lens fixed, then promotes one complete candidate
• compare-outline-refinements — compares the baseline and three refinements without synthesizing across candidates
• review-outline — runs the validated editorial review-and-revision loop for at most three cycles
• review-outline-counterfactual — tests the candidate against a credible alternative structure without source anchoring
• review-outline-ownership — audits explanatory ownership, peer relations, and fidelity to the selected lens
• review-outline-decisions — walks the four research decisions the survey should support using field evidence
• compare-outline-reviews — verifies the three Review Variants and produces the final critique and disposition
• outline-critique — defines the five-dimension, non-compensatory critique and verdict contract
• outline-revision — applies required repairs while preserving accepted structure and content
• finalize-outline — converts accepted Markdown to JSON, adds matching keywords, and reports paper coverage

algorithm

Two-part process: evidence gathering → outline design

evidence gathering

Goal: collect grounded signals about the area’s vocabulary, mechanisms, relationships, tensions, and missing threads.

• Collect paper tags $T$ and their frequencies $F$ during host-side preprocessing.
  • generate tags $T_p$ for each paper $p\in P$
  • use agglomerative clustering to condense all paper tags into $K$ canonical tags $T$ (currently $K=200$)
  • count how frequently each canonical tag occurs across the papers, producing $F$
• Dispatch a web-research subagent.
  • research $A$ online and retain source titles and URLs
  • write the concise, cited report $W$ to out/web_research.md

outline design

Goal: shape a coherent survey outline that helps readers understand the field, select appropriate methods, identify open problems, and avoid duplicating existing work.

• Select the organizing lens with select-outline-lens.
  • generate three complete outline variants $O_L^{(1)},O_L^{(2)},O_L^{(3)}$ using $T$, $F$, and $W$, each based on a different organizational lens
  • spawn an outline-variant-comparison subagent using compare-outline-variants
  • compare how each lens supports understanding the field, choosing methods, finding open problems, and avoiding duplicated work
  • choose one organizational lens $L^{\ast }$ and synthesize its selected backbone with compatible learnings from the other lenses, producing the initial outline draft $O_0$
• Select its structural realization with select-outline-structure, holding $L^{\ast }$ fixed.
  • preserve $O_0$ as the baseline candidate $O_R^{(0)}$
  • generate three complete refinement candidates $O_R^{(1)},O_R^{(2)},O_R^{(3)}$ that explore varying ordering, boundaries, hierarchy, selective depth, and top-level compression
  • spawn an outline-refinement-comparison subagent using compare-outline-refinements
  • deterministically choose and promote one complete candidate as $O_1$; do not synthesize across refinement candidates
• Review and revise with review-outline for at most three cycles.
  • for each version $O_i$:
    • concurrently spawn three fresh-context Review Variants:
      • counterfactual: read only $O_i$ and test a credible alternative ordering or partition
      • ownership: read $O_i$ plus prior lens/refinement comparisons; do not read tags or web research
      • research decisions: read $O_i$, $T$, $F$, and $W$, then walk the four supported reader tasks
    • spawn an outline-review-comparison subagent using compare-outline-reviews; it independently checks the candidate and evidence, verifies reviewer claims, and writes critique $C_i$
    • validate that $C_i$ contains all five rubric dimensions, consistent statuses, the correct target count, and one recognized verdict
    • if ready_for_instrumentation, accept and promote $O_i$
    • if review_unresolved, repeat the review when a cycle remains; otherwise stop without promotion
    • if needs_revision before cycle three, spawn outline-revision to produce $O_{i+1}$
    • if $O_{i+1}$ changes headings, nesting, or order, return it to the three-review loop
    • if it changes only descriptions, verify every requested repair and unchanged heading order directly; accept it without another full review when those checks pass
• Finalize the accepted outline with finalize-outline.
  • convert the accepted outline $O_i$ from Markdown into JSON
  • preserve the accepted Markdown structure exactly
  • add lowercase matching keywords, surface forms, abbreviations, and synonyms to each node
  • use inputs/papers.json only now, through the sizing script, to tune keyword coverage and produce out/outline_paper_list.json
  • validate both JSON artifacts and report top-level sections, total nodes, and matched/other percentages
  • return the finalized outline $O$

system diagram

HTML diagram