superlab 0.1.64 → 0.1.66

package/package-assets/shared/lab/.managed/scripts/validate_manuscript_delivery.py

@@ -149,6 +149,54 @@ def extract_table_note(text: str) -> str:
     return "\n".join(line.strip() for line in text.splitlines() if line.strip().startswith("%"))
 
 
+def extract_tabular_specs(text: str) -> list[str]:
+    return re.findall(r"\\begin\{tabular\}(?:\[[^\]]*\])?\{([^}]*)\}", text)
+
+
+def extract_tabular_bodies(text: str) -> list[str]:
+    return [
+        match.group(1)
+        for match in re.finditer(
+            r"\\begin\{tabular\}(?:\[[^\]]*\])?\{[^}]*\}([\s\S]*?)\\end\{tabular\}",
+            text,
+        )
+    ]
+
+
+def strip_latex_for_table_cell(cell: str) -> str:
+    cell = re.sub(r"%.*", "", cell)
+    cell = re.sub(r"\\(?:textbf|mathbf|emph)\{([^}]*)\}", r"\1", cell)
+    cell = re.sub(r"\\[A-Za-z@*]+(?:\[[^\]]*\])?", " ", cell)
+    cell = cell.replace("$", " ")
+    return cell.strip()
+
+
+def check_numeric_precision_consistency(text: str, issues: list[str], label: str):
+    for body in extract_tabular_bodies(text):
+        column_precisions: dict[int, set[int]] = {}
+        rows = re.split(r"\\\\", body)
+        for row in rows:
+            row = re.sub(r"\\(?:toprule|midrule|bottomrule|cmidrule)(?:\{[^}]*\})?", " ", row)
+            if "&" not in row:
+                continue
+            cells = [strip_latex_for_table_cell(cell) for cell in row.split("&")]
+            for index, cell in enumerate(cells):
+                matches = re.findall(r"(?<![A-Za-z])[-+]?\d+\.(\d+)", cell)
+                if not matches:
+                    continue
+                column_precisions.setdefault(index, set()).update(len(match) for match in matches)
+        inconsistent_columns = [
+            str(index + 1)
+            for index, precisions in sorted(column_precisions.items())
+            if len(precisions) > 1
+        ]
+        if inconsistent_columns:
+            issues.append(
+                f"{label} has inconsistent numeric precision in column(s): {', '.join(inconsistent_columns)}"
+            )
+            return
+
+
 def detect_uppercase_abbreviations(text: str) -> set[str]:
     return {
         token
@@ -210,8 +258,16 @@ def check_table_file(path: Path, issues: list[str], label: str):
         issues.append(f"{label} must contain a table environment")
     if r"\caption{" not in text or r"\label{" not in text:
         issues.append(f"{label} must contain both caption and label")
+    first_caption = text.find(r"\caption{")
+    first_tabular = text.find(r"\begin{tabular}")
+    if first_caption != -1 and first_tabular != -1 and first_caption > first_tabular:
+        issues.append(f"{label} should place its caption before the tabular body")
     if not all(token in text for token in (r"\toprule", r"\midrule", r"\bottomrule")):
         issues.append(f"{label} must use booktabs structure")
+    if any("|" in spec for spec in extract_tabular_specs(text)) or r"\vline" in text:
+        issues.append(f"{label} must not use vertical table rules; use booktabs spacing instead")
+    if r"\hline" in text or r"\cline" in text:
+        issues.append(f"{label} must not mix legacy \\hline/\\cline rules with booktabs tables")
     if not all(marker in text for marker in REQUIRED_TABLE_NOTE_MARKERS):
         issues.append(f"{label} must include a local table note scaffold")
     caption_text = extract_caption(text)
@@ -234,6 +290,7 @@ def check_table_file(path: Path, issues: list[str], label: str):
             continue
         if value < 3.0:
             issues.append(f"{label} sets \\tabcolsep below the safe range for paper-facing main tables")
+    check_numeric_precision_consistency(text, issues, label)
 
 
 def check_figure_file(path: Path, issues: list[str], label: str):

package/package-assets/shared/lab/.managed/scripts/validate_section_draft.py

@@ -91,6 +91,14 @@ def has_meaningful_field_value(value: str) -> bool:
     return normalized not in {"", "-", "n/a", "na", "none", "no", "not applicable", "null", "false"}
 
 
+def latest_write_iteration(project_root: Path) -> Path | None:
+    iteration_dir = project_root / ".lab" / "writing" / "iterations"
+    if not iteration_dir.exists():
+        return None
+    iteration_files = sorted(iteration_dir.glob("*.md"))
+    return iteration_files[-1] if iteration_files else None
+
+
 SECTION_STYLE_WARNINGS = {
     "abstract": [
         (
@@ -432,6 +440,32 @@ def check_active_paper_topology(section_path: Path, issues: list[str]):
     issues.extend(validate_topology_artifacts(project_root))
 
 
+def check_reference_template_intake(section_path: Path, issues: list[str]):
+    project_root = find_project_root(section_path)
+    if project_root is None:
+        return
+
+    reference_root = project_root / ".lab" / "writing" / "reference-patterns"
+    aggregate_playbook = reference_root / "aggregate-template-playbook.md"
+    legacy_notes_root = project_root / ".lab" / "writing" / "pdf-structure-notes"
+    has_legacy_notes = legacy_notes_root.exists() and any(legacy_notes_root.glob("*"))
+
+    latest_iteration = latest_write_iteration(project_root)
+    reference_sources = ""
+    if latest_iteration:
+        iteration_text = read_text(latest_iteration)
+        reference_sources = extract_markdown_field(
+            iteration_text,
+            "Reference Template Intake",
+            "Reference sources used:",
+        )
+
+    if (has_legacy_notes or has_meaningful_field_value(reference_sources)) and not aggregate_playbook.exists():
+        issues.append(
+            "reference papers appear to be used without .lab/writing/reference-patterns/aggregate-template-playbook.md; run extract_reference_paper_structure.py and use structured section/visual templates instead of legacy pdf-structure-notes"
+        )
+
+
 def check_abstract(text: str, issues: list[str]):
     numbers = re.findall(r"\b\d+(?:\.\d+)?\b", text)
     if len(numbers) > 6:
@@ -504,6 +538,100 @@ def check_method(text: str, issues: list[str]):
         issues.append("method should explain the technical advantage")
 
 
+def has_performance_claim(text: str) -> bool:
+    return contains_any(
+        text,
+        (
+            "outperform",
+            "outperforms",
+            "improve",
+            "improves",
+            "improved",
+            "gain",
+            "gains",
+            "better",
+            "stronger",
+            "superior",
+            "state-of-the-art",
+            "sota",
+            "reduce",
+            "reduces",
+            "降低",
+            "提升",
+            "优于",
+            "超过",
+            "更好",
+            "增益",
+        ),
+    )
+
+
+def has_numeric_or_table_evidence(text: str) -> bool:
+    if re.search(r"\b\d+\.\d+\b", text):
+        return True
+    if re.search(r"\b\d+(?:\.\d+)?\s*(?:%|pp|points?|AUUC|Qini|AUC|F1)\b", text, flags=re.IGNORECASE):
+        return True
+    if r"\pm" in text:
+        return True
+    return bool(
+        re.search(r"\\(?:auto|c|C)?ref\{(?:tab|fig):", text)
+        or re.search(r"\b(?:Table|Figure|Fig\.|表|图)~?\\ref\{", text)
+    )
+
+
+def has_generic_comparator_without_anchor(text: str) -> bool:
+    generic_comparator = contains_any(
+        text,
+        (
+            "previous methods",
+            "prior methods",
+            "existing methods",
+            "several baselines",
+            "the baselines",
+            "baseline suite",
+            "previous work",
+            "prior work",
+            "现有方法",
+            "已有方法",
+            "若干基线",
+            "基线集合",
+        ),
+    )
+    if not generic_comparator:
+        return False
+    if r"\cite{" in text or r"\citet{" in text or r"\citep{" in text:
+        return False
+    return not bool(re.search(r"\b[A-Z][A-Za-z0-9-]{2,}(?:\s*,\s*[A-Z][A-Za-z0-9-]{2,})+", text))
+
+
+def has_repeated_split_protocol(text: str) -> bool:
+    return bool(
+        re.search(r"\b\d+\s+(?:random\s+)?(?:splits|seeds|runs)\b", text, flags=re.IGNORECASE)
+        or re.search(r"\bacross\s+(?:random\s+)?(?:splits|seeds|runs)\b", text, flags=re.IGNORECASE)
+        or re.search(r"\b重复\s*\d+\s*次", text)
+    )
+
+
+def has_variance_report(text: str) -> bool:
+    return contains_any(
+        text,
+        (
+            r"\pm",
+            "standard deviation",
+            "std",
+            "confidence interval",
+            "confidence intervals",
+            "ci",
+            "variance",
+            "mean",
+            "平均",
+            "标准差",
+            "置信区间",
+            "方差",
+        ),
+    )
+
+
 def check_experiments(text: str, issues: list[str]):
     if not contains_any(
         text,
@@ -531,6 +659,18 @@ def check_experiments(text: str, issues: list[str]):
         ),
     ):
         issues.append("experiments should include benchmark scene notes")
+    if has_performance_claim(text) and not has_numeric_or_table_evidence(text):
+        issues.append(
+            "experiment performance claims should tie to concrete metric or numeric evidence instead of prose-only claims"
+        )
+    if has_generic_comparator_without_anchor(text):
+        issues.append(
+            "experiments use generic comparator names; name the comparator family, table anchor, or citations before more polish"
+        )
+    if has_repeated_split_protocol(text) and not has_variance_report(text):
+        issues.append(
+            "repeated split or seed protocol should report variance, confidence intervals, or an explicit variance disposition"
+        )
 
 
 def check_conclusion(text: str, issues: list[str]):
@@ -566,6 +706,7 @@ def main():
     check_workflow_language_targeting(section_path, blocking_issues)
     check_common_section_gate_risks(text, warning_issues)
     check_section_style_policy(text, args.section, warning_issues)
+    check_reference_template_intake(section_path, warning_issues)
     SECTION_CHECKS[args.section](text, warning_issues)
     check_neighbor_asset_files(args.section, section_path, warning_issues)
 

package/package-assets/shared/lab/.managed/templates/reference-template-intake.md

@@ -0,0 +1,50 @@
+# Reference Template Intake
+
+## Purpose
+
+- Help `/lab:write` reproduce mature paper structure from multiple reference templates.
+- Extract section slots, paragraph roles, and table/figure functions.
+- Reuse structure and logic only; do not copy wording, claims, metrics, or conclusions.
+
+## Sources
+
+- Source paths or URLs:
+- Extraction command:
+- Output root:
+
+## Section Templates
+
+- Abstract:
+- Introduction:
+- Related work:
+- Method:
+- Experiments:
+- Experiments protocol slots:
+  - Dataset descriptions:
+  - Dataset statistics / appendix link:
+  - Split or sampling protocol:
+  - Baseline setup:
+  - Metric definitions:
+  - Implementation and tuning details:
+  - Main results:
+  - Ablations:
+  - Sensitivity or analysis:
+- Conclusion:
+
+## Visual/Table Templates
+
+- Main result tables:
+- Ablation tables:
+- Dataset/protocol tables:
+- Method overview figures:
+- Result or trade-off figures:
+- Analysis/sensitivity figures:
+
+## Write Handoff
+
+- Aggregate template playbook:
+- Section template selected for this round:
+- Visual/table template selected for this round:
+- Multi-template reproduction plan:
+- Current-paper evidence that will fill the template:
+- Structure-only reuse boundary:

package/package-assets/shared/lab/.managed/templates/write-iteration.md

@@ -67,6 +67,33 @@
 - Any discouraged move kept and why:
 - Any banned move found:
 
+## Review Issue Bundle
+
+- Issue bundle path:
+- New issues:
+- Resolved issues:
+- Open issues:
+- Quote-backed findings recorded:
+- Script-backed findings separated from judgment-backed findings:
+
+## Re-Audit Status
+
+- Previous issue bundle compared:
+- Fully addressed root causes:
+- Partially addressed root causes:
+- Not addressed root causes:
+- New root causes:
+- Which root-cause issues block further prose polish:
+
+## Reference Template Intake
+
+- Reference sources used:
+- Aggregate template playbook:
+- Section templates consulted:
+- Visual/table templates consulted:
+- Multi-template reproduction plan:
+- Structure-only reuse boundary:
+
 ## Table Semantics
 
 - Metrics promised in Method:

package/package-assets/shared/skills/lab/stages/write.md

@@ -113,6 +113,15 @@ Run these on every round:
 - Load only the current section guide. Do not load every section guide at once.
 - Reuse example-bank structure, paragraph roles, sentence logic, and paper-facing LaTeX asset patterns when examples are bundled, but never copy wording verbatim.
 - Treat example cites and example file names as writing references, not as evidence for the current paper.
+- When the user provides local PDFs, PDF URLs, HTML pages, or reference papers while invoking `/lab:write`, run `.lab/.managed/scripts/extract_reference_paper_structure.py --output-dir .lab/writing/reference-patterns <sources...>` before drafting unless an up-to-date `.lab/writing/reference-patterns/aggregate-template-playbook.md` already covers those exact sources.
+- Treat reference-paper intake as an internal write capability, not a separate user command. The user should still only need `/lab:write`; do not ask them to learn another workflow.
+- The purpose of reference-paper intake is to help `/lab:write` reproduce mature multi-template writing structure: section slots, paragraph roles, argument sequence, table and figure functions, placement logic, and bridge sentences.
+- Use at least two compatible reference templates when available. If only one reference is available, mark it as a single-template pattern and avoid treating it as a universal standard.
+- For every reference table or figure, extract what reader question it answers, which section/subsection it supports, why it is placed there, what the prose before it should do, and what the prose after it should explain.
+- When drafting from reference templates, reproduce structure and logic only. Do not copy wording, claims, metrics, baselines, data, captions, or conclusions from reference papers.
+- Before drafting a section from reference templates, read `.lab/writing/reference-patterns/aggregate-template-playbook.md`, the matching file under `.lab/writing/reference-patterns/section-templates/`, and the matching visual/table template under `.lab/writing/reference-patterns/visual-templates/` when the section uses tables or figures.
+- For experiment sections, also read `.lab/writing/reference-patterns/section-templates/experiments-protocol.json` when it exists and preserve its protocol slot logic: dataset descriptions, dataset statistics, split/sampling protocol, baseline setup, metric definitions, implementation or tuning details, main results, ablations, sensitivity analysis, and appendix-to-main links.
+- Do not accept coarse labels such as “setup” or “overall performance” as a complete experiment-template extraction when the source papers contain explicit dataset, baseline, metric, implementation, or appendix-detail paragraphs.
 - Build a compact mini-outline before prose.
 - Academic readability standards are the same in `workflow_language` and `paper_language`; changing languages must not lower external-reader clarity.
 - If the current round introduces or revises key terms, abbreviations, metric names, mechanism names, or system labels, explain them at first mention by briefly stating what they are and why they matter here.
@@ -126,6 +135,10 @@ Run these on every round:
 - Before any additional tighten, compress, or polish pass on the same section, run a section-level acceptance gate first.
 - The section-level acceptance gate is passed only when canonical naming consistency, adjacent-section consistency, claim, metric, and ranking consistency with the current evidence, local clarity, local concision, and section-style compliance are all explicitly checked and no unresolved blocker remains.
 - If the current section still contains a banned expression or banned rhetorical move from `section-style-policies.md`, the round has not passed the section-level acceptance gate.
+- If reviewer notes, validator warnings, or prior write rounds produced issues, record them as a review issue bundle in the write-iteration artifact before further polishing.
+- Review issue bundles should separate script-backed findings from judgment-backed findings, preserve the source quote or local pointer when available, and track whether each issue is new, resolved, open, or superseded.
+- Before continuing prose polish after a review issue bundle exists, run a re-audit pass that compares the current draft against previous root causes and records fully addressed, partially addressed, not addressed, and newly introduced root causes.
+- Do not answer a review issue by merely changing wording around it. Fix the underlying section structure, evidence support, terminology definition, or asset/table linkage that caused the issue.
 - If the current round changes the paper's canonical experiment or evaluation protocol (for example split ratio, train/test size, seed or split count, benchmark set, or main-table evaluation contract), treat it as a canonical protocol replacement unless the user explicitly scopes it as supplementary or appendix-only.
 - A canonical protocol replacement requires a paper-wide impact audit before more polishing: identify stale sections and assets across Abstract, Introduction, Method, Experiments, Conclusion, tables, figures, analysis assets, and `.lab/writing/plan.md`, then update the plan and highest-impact stale targets first.
 - When a paper-wide impact audit is still open, default the next write action to the highest-impact canonical stale section or asset instead of polishing the same section again.
@@ -163,6 +176,7 @@ Run these on every round:
 - During ordinary draft rounds, run `.lab/.managed/scripts/validate_section_draft.py --section <section> --section-file <section-file> --mode draft` and `.lab/.managed/scripts/validate_paper_claims.py --section-file <section-file> --mode draft` after revising the active section.
 - Treat draft-round output from the section and claim validators as warnings that must be recorded and addressed in the write-iteration artifact, not as immediate stop conditions.
 - If the active section already lives under a paper-layer `sections/` directory, the draft section validator should also warn when the neighboring required figure or analysis placeholder files are still missing from that same paper layer.
+- For experiment sections, treat prose-only performance claims, unnamed generic comparator phrases, repeated split/seed protocols without variance disposition, and result paragraphs without concrete metric/table anchors as section warnings that must be fixed before more prose-only polishing.
 - For each subsection, explicitly include motivation, design, and technical advantage when applicable.
 - Avoid a writing style that reads like incremental patching of a naive baseline.
 - Keep terminology stable across the full paper.
@@ -183,6 +197,9 @@ Run these on every round:
   - `<deliverables_root>/paper/analysis/analysis-asset.tex`
 - Table assets must use paper-facing LaTeX structure with `booktabs`, caption, label, and consistent precision.
 - Table assets must also include a local table note that explains row meaning, column meaning, metric definitions, comparison scope, and any important caveat.
+- Table assets must avoid vertical rules, `\hline`, and `\cline`; use `booktabs` rules and whitespace instead.
+- Table captions should appear before the tabular body so the table can be read top-down in manuscript order.
+- Numeric precision should be consistent within each metric column unless the table note explains a deliberate exception.
 - Table assets must not rely on aggressive width hacks by default; if width control is still needed after table redesign, document it locally and keep it readable.
 - Figure placeholders must explain what the final figure should show and why the reader needs it.
 - Core asset coverage for a paper-facing final draft should include a problem-setting or teaser figure, a method overview figure, a results overview figure, a main-results table, an ablation table, and one additional analysis asset.
@@ -200,6 +217,8 @@ Run these on every round:
 - When a round introduces or revises key terms, include a compact terminology note in the user-facing round summary and record the terminology-clarity self-check in the write-iteration artifact.
 - Record the section-level acceptance gate in the write-iteration artifact before recommending further tightening on the same section.
 - Record section-style policy compliance, any retained discouraged move, and any banned move found in the write-iteration artifact.
+- Record the review issue bundle and re-audit status in the write-iteration artifact whenever the round follows reviewer notes, validator warnings, or prior failed writing rounds.
+- Record the reference template intake in the write-iteration artifact whenever the round uses PDFs, URLs, or `.lab/writing/reference-patterns/` artifacts: sources used, aggregate playbook path, section templates consulted, visual/table templates consulted, multi-template reproduction plan, and structure-only reuse boundary.
 - Record the round target layer in the write-iteration artifact as `canonical manuscript`, `workflow-language paper layer`, or `both`.
 - If workflow-language was active and the round still targeted the canonical manuscript, record why canonical-only writing was acceptable in the write-iteration artifact.
 - If both layers were edited, record why the cross-language sync was required and whether it was explicitly requested by the user or required by final-draft/export finalization.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superlab",
-  "version": "0.1.64",
+  "version": "0.1.66",
   "description": "Strict /lab research workflow installer for Codex and Claude",
   "keywords": [
     "codex",