superlab 0.1.66 → 0.1.68

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

@@ -39,6 +39,41 @@ REQUIRED_TABLE_NOTE_MARKERS = (
 )
 WIDTH_CONTROL_NOTE_MARKER = "% Width control:"
 TABLE_ABBREVIATION_EXCEPTIONS = {"TODO", "TBD"}
+PLACEHOLDER_TABLE_NOTE_PREFIXES = (
+    "explain ",
+    "state ",
+    "expand ",
+    "describe ",
+    "fill ",
+    "todo",
+    "tbd",
+    "待补",
+    "待定",
+    "说明每",
+)
+SERVICE_STYLE_PHRASES = (
+    "user asked",
+    "the user asked",
+    "as requested by the user",
+    "let me explain",
+    "i will explain",
+    "用户说",
+    "用户要求",
+    "按你的要求",
+    "我来解释",
+    "我会说明",
+)
+WORKFLOW_ONLY_MANUSCRIPT_PHRASES = (
+    "Figure intent:",
+    "Asset intent:",
+    "figure intent:",
+    "asset intent:",
+    "图的意图",
+    "资产意图",
+    "占位符",
+    "workflow-language",
+    "translation layer",
+)
 
 
 def parse_args():
@@ -53,6 +88,15 @@ def read_text(path: Path) -> str:
     return path.read_text(encoding="utf-8")
 
 
+def strip_latex_comments(text: str) -> str:
+    return re.sub(r"%.*", "", text)
+
+
+def contains_any(text: str, needles: tuple[str, ...]) -> bool:
+    lowered = text.lower()
+    return any(needle.lower() in lowered for needle in needles)
+
+
 def find_workflow_config(start_path: Path) -> Path | None:
     search_roots = [start_path, *start_path.parents]
     for root in search_roots:
@@ -67,6 +111,23 @@ def load_workflow_config(path: Path) -> dict:
     return json.loads(path.read_text(encoding="utf-8"))
 
 
+def project_root_from_workflow_config(path: Path) -> Path:
+    if path.parent.name == "config" and path.parent.parent.name == ".lab":
+        return path.parent.parent.parent
+    return path.parent.parent
+
+
+def is_workflow_language_layer_target(paper_dir: Path, workflow_config_path: Path, config: dict) -> bool:
+    workflow_language = config.get("workflow_language")
+    paper_language = config.get("paper_language", workflow_language)
+    if not workflow_language or workflow_language == paper_language:
+        return False
+    project_root = project_root_from_workflow_config(workflow_config_path)
+    deliverables_root = (project_root / config.get("deliverables_root", "docs/research")).resolve()
+    workflow_layer_dir = (deliverables_root / "paper" / "workflow-language").resolve()
+    return paper_dir.resolve() == workflow_layer_dir
+
+
 def extract_section_body(text: str, patterns: tuple[str, ...]) -> str:
     for pattern in patterns:
         match = re.search(pattern, text, flags=re.MULTILINE)
@@ -149,54 +210,6 @@ 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
@@ -217,6 +230,13 @@ def section_references_label(text: str, label: str) -> bool:
     return bool(re.search(REF_PATTERN_TEMPLATE % re.escape(label), text))
 
 
+def section_includes_asset(text: str, asset_path: str) -> bool:
+    escaped = re.escape(asset_path)
+    return bool(
+        re.search(rf"\\(?:input|include|wlpath)\{{{escaped}(?:\.tex)?\}}", text)
+    )
+
+
 def check_exists(path: Path, issues: list[str], label: str):
     if not path.exists():
         issues.append(f"missing required file: {label} ({path})")
@@ -258,18 +278,23 @@ 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")
+    for marker in REQUIRED_TABLE_NOTE_MARKERS:
+        for line in text.splitlines():
+            stripped = line.strip()
+            if not stripped.startswith(marker):
+                continue
+            value = stripped.removeprefix(marker).strip().lower()
+            if (
+                not value
+                or "placeholder" in value
+                or "占位" in value
+                or any(value.startswith(prefix) for prefix in PLACEHOLDER_TABLE_NOTE_PREFIXES)
+            ):
+                issues.append(f"{label} contains placeholder table note text for `{marker}`")
     caption_text = extract_caption(text)
     note_text = extract_table_note(text)
     local_context = "\n".join((caption_text, note_text))
@@ -290,7 +315,6 @@ 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):
@@ -309,8 +333,11 @@ def check_figure_file(path: Path, issues: list[str], label: str):
         issues.append(f"{label} must contain a figure environment")
     if r"\caption{" not in text or r"\label{" not in text:
         issues.append(f"{label} must contain both caption and label")
-    if "Figure intent:" not in text and "图意图：" not in text:
-        issues.append(f"{label} must explain figure intent")
+    paper_facing_text = strip_latex_comments(text)
+    if contains_any(paper_facing_text, SERVICE_STYLE_PHRASES):
+        issues.append(f"{label} contains service-style or AI-assistant meta language")
+    if contains_any(paper_facing_text, WORKFLOW_ONLY_MANUSCRIPT_PHRASES):
+        issues.append(f"{label} contains workflow-only placeholder language in paper-facing text")
 
 
 def check_analysis_asset(path: Path, issues: list[str]):
@@ -322,8 +349,11 @@ def check_analysis_asset(path: Path, issues: list[str]):
         issues.append("analysis/analysis-asset.tex must contain a table or figure environment")
     if r"\caption{" not in text or r"\label{" not in text:
         issues.append("analysis/analysis-asset.tex must contain both caption and label")
-    if "Asset intent:" not in text and "资产意图：" not in text:
-        issues.append("analysis/analysis-asset.tex must explain asset intent")
+    paper_facing_text = strip_latex_comments(text)
+    if contains_any(paper_facing_text, SERVICE_STYLE_PHRASES):
+        issues.append("analysis/analysis-asset.tex contains service-style or AI-assistant meta language")
+    if contains_any(paper_facing_text, WORKFLOW_ONLY_MANUSCRIPT_PHRASES):
+        issues.append("analysis/analysis-asset.tex contains workflow-only placeholder language in paper-facing text")
 
 
 def require_section_reference(section_text: str, label: str | None, issues: list[str], section_name: str, asset_name: str):
@@ -340,10 +370,9 @@ def check_introduction_section(paper_dir: Path, issues: list[str]):
         return
     text = read_text(introduction)
     has_problem_figure = any(
-        token in text
-        for token in (
-            r"\input{figures/problem-setting}",
-            r"\begin{figure}",
+        (
+            section_includes_asset(text, "figures/problem-setting"),
+            r"\begin{figure}" in text,
         )
     )
     if not has_problem_figure:
@@ -357,25 +386,22 @@ def check_experiments_section(paper_dir: Path, issues: list[str]):
         return
     text = read_text(experiments)
     has_table = any(
-        token in text
-        for token in (
-            r"\input{tables/main-results}",
-            r"\input{tables/ablations}",
-            r"\begin{table}",
+        (
+            section_includes_asset(text, "tables/main-results"),
+            section_includes_asset(text, "tables/ablations"),
+            r"\begin{table}" in text,
         )
     )
     has_figure = any(
-        token in text
-        for token in (
-            r"\input{figures/results-overview}",
-            r"\begin{figure}",
+        (
+            section_includes_asset(text, "figures/results-overview"),
+            r"\begin{figure}" in text,
         )
     )
     has_analysis = any(
-        token in text
-        for token in (
-            r"\input{analysis/analysis-asset}",
-            r"\input{tables/analysis}",
+        (
+            section_includes_asset(text, "analysis/analysis-asset"),
+            section_includes_asset(text, "tables/analysis"),
         )
     )
     if not has_table:
@@ -429,10 +455,9 @@ def check_method_section(paper_dir: Path, issues: list[str]):
         return
     text = read_text(method)
     has_figure = any(
-        token in text
-        for token in (
-            r"\input{figures/method-overview}",
-            r"\begin{figure}",
+        (
+            section_includes_asset(text, "figures/method-overview"),
+            r"\begin{figure}" in text,
         )
     )
     if not has_figure:
@@ -462,6 +487,17 @@ def check_language_layers(paper_dir: Path, issues: list[str]):
     if not workflow_language or workflow_language == paper_language:
         return
 
+    if is_workflow_language_layer_target(paper_dir, workflow_config, config):
+        sections_dir = paper_dir / "sections"
+        section_text = "\n".join(
+            read_text(path) for path in sorted(sections_dir.glob("*.tex")) if path.is_file()
+        )
+        if section_text and not text_looks_like_language(section_text, workflow_language):
+            issues.append(
+                f"workflow-language paper-layer sections should follow workflow_language={workflow_language}"
+            )
+        return
+
     if finalization_decision == "unconfirmed":
         issues.append(
             "workflow_language and paper_language differ; confirm paper_language_finalization_decision before finalizing the manuscript"
@@ -657,7 +693,7 @@ def check_latest_write_iteration_preflight(paper_dir: Path, issues: list[str]):
     if workflow_config is None:
         return
 
-    project_root = workflow_config.parent.parent
+    project_root = project_root_from_workflow_config(workflow_config)
     manifest_path = project_root / ".lab" / ".managed" / "rule-manifest.json"
     if not manifest_path.exists():
         return

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

@@ -82,6 +82,7 @@ TABLE_DETAIL_FIELDS = (
 FIGURE_DETAIL_FIELDS = (
     "Asset file",
     "Section",
+    "Figure role",
     "Figure intent",
     "Evidence",
     "Status",
@@ -95,6 +96,7 @@ ANALYSIS_DETAIL_FIELDS = (
     "Asset file",
     "Asset type",
     "Section",
+    "Asset role",
     "Asset intent",
     "Evidence",
     "Status",

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

@@ -0,0 +1,348 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import re
+import sys
+from pathlib import Path
+
+from paper_topology import find_project_root
+
+
+SECTION_CHOICES = (
+    "abstract",
+    "introduction",
+    "related-work",
+    "method",
+    "experiments",
+    "conclusion",
+)
+
+REQUIRED_HEADINGS = (
+    "## Sources",
+    "## Adopted Structure Slots",
+    "## Rejected or Waived Slots",
+    "## Section Mapping",
+    "## Paragraph Role Mapping",
+    "## Asset Mapping",
+    "## Reuse Boundary",
+)
+
+EXPERIMENT_CORE_SLOTS = {
+    "dataset_description": ("dataset_description", "dataset statistics", "dataset", "datasets", "数据集"),
+    "split_protocol": ("split_protocol", "split protocol", "split", "train/test", "划分", "切分"),
+    "baseline_setup": ("baseline_setup", "baseline", "baselines", "comparator", "comparators", "基线", "对比方法"),
+    "metric_definition": ("metric_definition", "metric", "metrics", "ranking", "指标", "排序"),
+    "main_results": ("main_results", "main result", "main results", "primary comparison", "主结果", "主要结果"),
+}
+
+EXPERIMENT_WAIVABLE_SLOTS = {
+    "ablation": ("ablation", "component analysis", "消融", "组件分析"),
+    "sensitivity": ("sensitivity", "robustness", "trade-off", "敏感性", "稳健性"),
+    "implementation_details": ("implementation_details", "implementation", "reproducibility", "实现", "复现"),
+}
+
+EXPERIMENT_TEXT_ALIASES = {
+    "dataset_description": (
+        "dataset",
+        "datasets",
+        "benchmark",
+        "benchmarks",
+        "cohort",
+        "population",
+        "数据集",
+        "基准",
+        "样本",
+    ),
+    "split_protocol": (
+        "split",
+        "splits",
+        "train",
+        "test",
+        "training",
+        "testing",
+        "random",
+        "seed",
+        "划分",
+        "切分",
+        "训练",
+        "测试",
+    ),
+    "baseline_setup": (
+        "baseline",
+        "baselines",
+        "comparator",
+        "comparators",
+        "prior method",
+        "compared",
+        "comparison",
+        "基线",
+        "对比方法",
+        "比较",
+    ),
+    "metric_definition": (
+        "metric",
+        "metrics",
+        "auuc",
+        "qini",
+        "primary metric",
+        "ranking",
+        "higher is better",
+        "指标",
+        "排序",
+        "越高越好",
+    ),
+    "main_results": (
+        "main result",
+        "main results",
+        "primary comparison",
+        "table",
+        "result",
+        "results",
+        "主结果",
+        "主要结果",
+        "结果",
+        "表",
+    ),
+    "ablation": (
+        "ablation",
+        "ablations",
+        "component",
+        "variant",
+        "消融",
+        "组件",
+        "变体",
+    ),
+    "sensitivity": (
+        "sensitivity",
+        "robustness",
+        "stability",
+        "diagnostic",
+        "trade-off",
+        "敏感性",
+        "稳健性",
+        "稳定性",
+        "诊断",
+    ),
+    "implementation_details": (
+        "implementation",
+        "training",
+        "hyperparameter",
+        "reproducibility",
+        "实现",
+        "训练",
+        "复现",
+    ),
+}
+
+SERVICE_STYLE_PHRASES = (
+    "user asked",
+    "the user asked",
+    "as requested by the user",
+    "i will explain",
+    "let me explain",
+    "below i",
+    "用户说",
+    "用户要求",
+    "按你的要求",
+    "我来解释",
+    "我会说明",
+    "下面我",
+    "这版",
+    "已完成",
+    "已按",
+)
+
+WORKFLOW_ONLY_PHRASES = (
+    "figure intent",
+    "asset intent",
+    "placeholder",
+    "workflow-language",
+    "review layer",
+    "translation layer",
+    "图的意图",
+    "资产意图",
+    "占位符",
+    "工作流语言",
+    "同步到",
+)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Validate that reference-paper structure was consumed as structure, not as shallow prose polish."
+    )
+    parser.add_argument("--section", required=True, choices=SECTION_CHOICES)
+    parser.add_argument("--section-file", required=True)
+    parser.add_argument("--consumption-plan", help="Path to .lab/writing/reference-patterns/consumption-plan/<section>.md")
+    parser.add_argument("--mode", required=True, choices=("draft", "final"))
+    return parser.parse_args()
+
+
+def read_text(path: Path) -> str:
+    return path.read_text(encoding="utf-8")
+
+
+def contains_any(text: str, phrases: tuple[str, ...]) -> bool:
+    lowered = text.lower()
+    return any(phrase.lower() in lowered for phrase in phrases)
+
+
+def strip_latex_comments(text: str) -> str:
+    return re.sub(r"%.*", "", text)
+
+
+def infer_consumption_plan(section_file: Path, section: str) -> Path | None:
+    project_root = find_project_root(section_file.resolve())
+    if project_root is None:
+        return None
+    return project_root / ".lab" / "writing" / "reference-patterns" / "consumption-plan" / f"{section}.md"
+
+
+def section_block(text: str, heading: str) -> str:
+    match = re.search(
+        rf"^##\s+{re.escape(heading.removeprefix('## ').strip())}\s*$([\s\S]*?)(?=^##\s+|\Z)",
+        text,
+        flags=re.MULTILINE,
+    )
+    return match.group(1) if match else ""
+
+
+def nonempty_bullets(block: str) -> list[str]:
+    return [
+        line.strip()
+        for line in block.splitlines()
+        if line.strip().startswith("-") and line.strip().lower() not in {"- none", "- n/a", "- na"}
+    ]
+
+
+def line_mentions_any(line: str, aliases: tuple[str, ...]) -> bool:
+    lowered = line.lower()
+    return any(alias.lower() in lowered for alias in aliases)
+
+
+def slot_is_mapped(plan_text: str, aliases: tuple[str, ...]) -> bool:
+    mapping_blocks = "\n".join(
+        [
+            section_block(plan_text, "Adopted Structure Slots"),
+            section_block(plan_text, "Section Mapping"),
+            section_block(plan_text, "Asset Mapping"),
+        ]
+    )
+    for line in mapping_blocks.splitlines():
+        if line_mentions_any(line, aliases) and ("->" in line or ":" in line):
+            return True
+    return False
+
+
+def slot_is_waived(plan_text: str, aliases: tuple[str, ...]) -> bool:
+    waiver_block = section_block(plan_text, "Rejected or Waived Slots")
+    for line in waiver_block.splitlines():
+        lowered = line.lower()
+        if line_mentions_any(line, aliases) and any(token in lowered for token in ("waiv", "not used", "not applicable", "不采用", "不适用", "跳过")):
+            return True
+    return False
+
+
+def validate_plan_shape(plan_text: str, issues: list[str]) -> None:
+    for heading in REQUIRED_HEADINGS:
+        if heading not in plan_text:
+            issues.append(f"reference consumption plan is missing required heading: {heading}")
+
+    source_block = section_block(plan_text, "Sources")
+    if len(nonempty_bullets(source_block)) == 0:
+        issues.append("reference consumption plan must list at least one reference source")
+
+    boundary = section_block(plan_text, "Reuse Boundary").lower()
+    required_boundary_terms = ("structure", "wording", "claims", "metrics", "captions", "conclusions")
+    if not all(term in boundary for term in required_boundary_terms):
+        issues.append(
+            "reuse boundary must explicitly say to reuse structure only and not copy wording, claims, metrics, captions, or conclusions"
+        )
+
+
+def validate_experiment_slots(plan_text: str, issues: list[str]) -> None:
+    for slot, aliases in EXPERIMENT_CORE_SLOTS.items():
+        if not slot_is_mapped(plan_text, aliases):
+            issues.append(f"experiments reference consumption must map required slot: {slot}")
+
+    for slot, aliases in EXPERIMENT_WAIVABLE_SLOTS.items():
+        if not slot_is_mapped(plan_text, aliases) and not slot_is_waived(plan_text, aliases):
+            issues.append(f"experiments reference consumption must map or explicitly waive slot: {slot}")
+
+
+def mapped_experiment_slots(plan_text: str) -> list[str]:
+    slots: list[str] = []
+    for slot, aliases in {**EXPERIMENT_CORE_SLOTS, **EXPERIMENT_WAIVABLE_SLOTS}.items():
+        if slot_is_mapped(plan_text, aliases):
+            slots.append(slot)
+    return slots
+
+
+def validate_experiment_section_realizes_slots(plan_text: str, section_text: str, issues: list[str]) -> None:
+    paper_text = strip_latex_comments(section_text).lower()
+    if not re.search(r"\\subsection\{|\\paragraph\{", section_text):
+        issues.append(
+            "experiments reference consumption mapped multiple structure slots, but the section has no subsection or paragraph anchors"
+        )
+
+    for slot in mapped_experiment_slots(plan_text):
+        aliases = EXPERIMENT_TEXT_ALIASES.get(slot, ())
+        if aliases and not contains_any(paper_text, aliases):
+            issues.append(
+                f"mapped slot `{slot}` is not realized in the section text; expand the current section instead of recording a shallow consumption plan"
+            )
+
+
+def validate_section_text(section_text: str, issues: list[str]) -> None:
+    prose_text = strip_latex_comments(section_text)
+    if contains_any(prose_text, SERVICE_STYLE_PHRASES):
+        issues.append("section prose contains service-style or AI-assistant meta language; rewrite as paper-facing academic prose")
+    if contains_any(prose_text, WORKFLOW_ONLY_PHRASES):
+        issues.append("section prose contains workflow-only placeholder language; move authoring notes out of the manuscript")
+
+
+def main() -> int:
+    args = parse_args()
+    section_path = Path(args.section_file)
+    if not section_path.exists():
+        print(f"section file does not exist: {section_path}", file=sys.stderr)
+        return 1
+
+    plan_path = Path(args.consumption_plan) if args.consumption_plan else infer_consumption_plan(section_path, args.section)
+    if plan_path is None or not plan_path.exists():
+        message = (
+            "missing reference consumption plan; create "
+            f".lab/writing/reference-patterns/consumption-plan/{args.section}.md before reference-guided deep writing"
+        )
+        if args.mode == "draft":
+            print(f"WARNING: {message}")
+            return 0
+        print(message, file=sys.stderr)
+        return 1
+
+    issues: list[str] = []
+    plan_text = read_text(plan_path)
+    section_text = read_text(section_path)
+    validate_plan_shape(plan_text, issues)
+    if args.section == "experiments":
+        validate_experiment_slots(plan_text, issues)
+        validate_experiment_section_realizes_slots(plan_text, section_text, issues)
+    validate_section_text(section_text, issues)
+
+    if not issues:
+        print("reference consumption is valid")
+        return 0
+
+    if args.mode == "draft":
+        for issue in issues:
+            print(f"WARNING: {issue}")
+        return 0
+
+    for issue in issues:
+        print(issue, file=sys.stderr)
+    return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())