Academic Assignment Pipeline

Run an assignment as one evidence chain: spec -> code -> results -> claims -> prose -> layout -> validated package. Each stage has an exit gate; do not let prose outrun evidence, and do not fix layout by editing content.

Operating Rules

1. The assignment spec is the source of truth. Read the supplied PDF/slides before planning. Extract every deliverable and constraint into a checklist (methods, dataset, visualization count, language, deadline, submission address). Never rely on memory of the spec.
2. Evidence before prose. Every number in the report must trace to a results file produced by the code. Keep the chain raw run -> metrics JSON -> aggregate CSV/summary -> table/figure -> sentence.
3. One protocol for all methods. Fix coordinate frame, error metric, thresholds, verification, aggregation, and confidence semantics before the first run. Changing the protocol mid-study invalidates comparisons.
4. Natural layout only. Control float placement through declaration order, never by forced page breaks or \FloatBarrier in the main body. Never compress prose to make a page look full.
5. Packaging is copy-only. Hashing before and after proves the source code and PDF were not modified. Do not rebuild or reformat during packaging.
6. Read-only means read-only. When asked to audit, report findings and do not edit files.
7. Do not send email or submit on the user's behalf. Prepare the package, draft the body, and stop for explicit confirmation.

Stage Map

| Stage | Goal | Exit gate | Primary skills | |---|---|---|---| | 0. Intake | Turn the spec into a requirement checklist | Every deliverable and constraint is written down | none | | 1. Code | One reproducible evaluation entry point | All configurations run through the same protocol | none | | 2. Experiments | Official-data results and analysis artifacts | Completed == expected pairs, failed == 0, aggregates saved | ccf-experiment-designer (optional) | | 3. Manuscript | Evidence-bound English report | Every claim and number traceable; every float referenced | ccf-humanization, ccf-common, ccf-paper-writer, ccf-visual-composer | | 4. Prose | Remove defensive framing and AI tells | Whole-paper sweep; translations synchronized | anti-defensive-writing, humanizer | | 5. Typesetting | Required page/float map with natural flow | Rendered page map matches target; no gaps or overlaps | ccf-visual-composer, ccf-submission-checker | | 6. Validation | Numbers, labels, PDF, figures agree | Automated checks pass; PDF opens and paginates correctly | ccf-integrity-auditor | | 7. Package | Correctly named ZIP + PDF + email body | Three files, integrity pass, hashes recorded | ccf-submission-checker |

Stage 0: Intake

• Read the spec file directly; quote exact constraints.
• Build a checklist with one line per requirement: comparison family/methods, dataset and official source, number of qualitative pairs, code expectations, report language/format, page limit, deadline, recipient.
• Record unknowns explicitly. Ask only for decisions that change the deliverable.

Example checklist rows: "compare traditional vs DNN detector-based", "compare detector-free vs detector-based", "use official dataset images", "visualize >= 10 pairs", "code + English report", "submit by <date> to <address>".

Stage 1: Code

Use a layout that separates data, methods, geometry, evaluation, and reporting so every number can be regenerated:

project/
  src/<pkg>/
    data/          # manifest loading, pair sampling
    methods/       # base class, one adapter per configuration, registry
    geometry/      # epipolar error, metrics
    evaluation/    # runner: per-pair loop, manifests, aggregation
    visualization/ # qualitative panels
    reporting.py   # aggregate tables
  configs/methods/*.yaml
  scripts/run_unified_evaluation.sh
  tests/unit/
  pyproject.toml
  README.md

Requirements:

• One runner and one script evaluate every configuration through identical I/O and scoring code.
• Each run writes run_manifest.json (pair count, manifest SHA-256, config) and metrics.json (completed/failed, aggregates).
• Record the official manifest SHA-256 in code and README; assert it at load time.
• Keep third-party weights, datasets, and virtual environments out of the submission; document how to obtain them.
• Add unit tests for error math, aggregation, and manifest handling.
• README must state install, data path, run command, test command, and exactly which artifacts are included.

Stage 2: Experiments

1. Write the protocol down before running: coordinate frame, error definition, thresholds, robust verification, pair-weighted vs correspondence-weighted aggregation, confidence-rank scope, strata definitions, CI method.
2. Validate the pair set first: count, category balance, scene coverage, hash.
3. Run all configurations; assert pairs_completed == expected and pairs_failed == 0.
4. Save compact aggregates (CSV + JSON) and per-method metrics. If per-pair outputs are too large to ship, say so in the README instead of implying they are included.
5. Select qualitative pairs deterministically by declared strata; ship the selection JSON so panels are reproducible.
6. Keep runtime measurement descriptive; do not present it as a controlled benchmark unless hardware and warm-up are fixed.

Stage 3: Manuscript

Activate in this order: ccf-humanization -> ccf-common -> specialist (ccf-paper-writer, ccf-visual-composer, ccf-submission-checker). See references/skill-installation.md.

Write around the strongest supported result, not a chronological work log:

• Abstract and introduction: problem -> gap -> what this study does -> headline evidence.
• Related work: position the method families, not a list of papers.
• Protocol: enough detail to reproduce every aggregate.
• Experiments: one interpretation per table/figure; family-level mechanism plus within-family contrasts; no unsupported causal claims.
• Conclusion: restate what is established, not new caveats.

Every figure and table must be referenced in the text. Keep a sentence-level Chinese translation in sync when the user asks for one; update it in the same pass as the English edit.

Stage 4: Prose

• anti-defensive-writing: remove apology, self-undermining, process narration, and "we only/limited/failed" framing while preserving real limitations that affect interpretation.
• humanizer: remove not-X-but-Y contrasts, one-line closers, staged openers, forced triads, dash habits, inflated significance, and stock AI vocabulary. Preserve numbers, citations, and terminology.
• Sweep the whole manuscript, not just the paragraph being edited. Re-read the final text; check that caution was not replaced by hype.
• Apply the same edits to translations. Never leave the two versions out of sync.

Stage 5: Typesetting

See references/paper-and-typesetting.md for the full procedure. Core loop:

1. Declare floats where the compiled order should place them.
2. Build and extract captions per page to check the actual page map.
3. Move declarations (not prose) until the map matches; accept natural whitespace.
4. Never add \clearpage, \newpage, or \FloatBarrier in the main body.

Stage 6: Validation

• Run the project's validate_paper.py (or equivalent) to assert manifest hash, pair counts, per-method completion, category balance, qualitative case count, and figure existence.
• Run scripts/audit_latex_labels.py <paper_dir> to catch duplicate labels, undefined references, and unreferenced figures/tables. It follows \input from main.tex, so stale drafts are ignored.
• Inspect the built PDF: page count, font embedding, text extraction, and the rendered pages.
• Cross-check each headline number in text against the summary JSON/CSV.

Stage 7: Package

See references/delivery-checklist.md. Package into a new folder; never alter the source directory. Required contents: the ZIP, the latest PDF, and the email body text, all named with the student/project identifier where required. Verify with unzip -t, pdfinfo, and SHA-256 before reporting completion.

Bundled Resources

• references/skill-installation.md: install, verify, and invoke the CCFA family plus anti-defensive-writing and humanizer; usage order and handoffs.
• references/stage-workflow.md: detailed per-stage playbook with code, protocol, experiment, and prose checklists.
• references/paper-and-typesetting.md: LaTeX float/page-map control, build commands, and PDF checks.
• references/delivery-checklist.md: naming, ZIP/PDF/email packaging, and verification.
• scripts/audit_latex_labels.py: label/reference audit for the compiled manuscript.