superlab 0.1.63 → 0.1.64

package/lib/auto_state.cjs

@@ -99,6 +99,7 @@ function parseAutoStatus(targetDir) {
     resolvedStage: extractValue(text, ["Resolved stage", "解析后的阶段"]),
     resolvedMode: extractValue(text, ["Resolved mode", "解析后的模式"]),
     resolvedTarget: extractValue(text, ["Resolved target", "解析后的目标"]),
+    preflightStamp: extractValue(text, ["Preflight stamp", "预检签名"]),
     overrideReason: extractValue(text, ["Override reason, if any", "如有覆盖理由"]),
     status: extractValue(text, ["Status", "状态"]),
     currentStage: extractValue(text, ["Current stage", "当前阶段"]),
@@ -155,6 +156,7 @@ function renderAutoStatus(status, { lang = "en" } = {}) {
 - 解析后的阶段: ${status.resolvedStage || ""}
 - 解析后的模式: ${status.resolvedMode || ""}
 - 解析后的目标: ${status.resolvedTarget || ""}
+- 预检签名: ${status.preflightStamp || ""}
 - 如有覆盖理由: ${status.overrideReason || ""}
 
 ## 运行状态
@@ -194,6 +196,7 @@ function renderAutoStatus(status, { lang = "en" } = {}) {
 - Resolved stage: ${status.resolvedStage || ""}
 - Resolved mode: ${status.resolvedMode || ""}
 - Resolved target: ${status.resolvedTarget || ""}
+- Preflight stamp: ${status.preflightStamp || ""}
 - Override reason, if any: ${status.overrideReason || ""}
 
 ## Runtime State

package/lib/i18n.cjs

@@ -2082,9 +2082,10 @@ ZH_CONTENT[path.join(".codex", "skills", "lab", "stages", "write.md")] = `# \`/l
 ## 规则预检
 
 - 起草前先读取 \`.lab/.managed/rule-manifest.json\`。
-- 在 write iteration artifact 里先写 \`Rule Preflight\`，再改 prose。
-- \`Rule Preflight\` 至少记录：Rule source file、Rule source revision、Project version、Resolved stage、Resolved mode、Resolved target，以及任何 override reason。
+- 先用 \`.lab/.managed/scripts/render_rule_preflight.py\` 生成 write iteration 里的 \`Rule Preflight\`，再改 prose；不要凭记忆手填。
+- \`Rule Preflight\` 至少记录：Rule source file、Rule source revision、Project version、Resolved stage、Resolved mode、Resolved target、Preflight stamp，以及任何 override reason。
 - 如果已安装的 write 规则和当前轮次行为不一致，就先修正目标层或补充有效 override 理由，再继续编辑。
+- 在 draft 模式下，\`Rule Preflight\` 不一致和 paper topology 不一致都属于 blocker，不是可以带着 warning 继续润色的问题。
 
 ## 小步写作规则
 
@@ -2393,7 +2394,8 @@ description: 严格研究工作流，覆盖 idea、data、auto、framing、spec
 - 使用 \`.lab/config/workflow.json\` 作为全局约束，统一管理 workflow language、paper language、paper format、results_root、figures_root、deliverables_root、paper_template_root 和 paper-language 的最终定稿决定。
 - 工作流中间工件默认跟随安装语言。
 - 每个 \`/lab:*\` stage 开始前，都要先读取 \`.lab/.managed/rule-manifest.json\` 并完成一段 \`Rule Preflight\`。
-- 每个 stage round 的受管工件都要先记录：Rule source file、Rule source revision、Project version、Resolved stage、Resolved mode、Resolved target，以及任何 override reason。
+- 每个 stage round 的受管工件都要先记录：Rule source file、Rule source revision、Project version、Resolved stage、Resolved mode、Resolved target、Preflight stamp，以及任何 override reason。
+- 这段 \`Rule Preflight\` 应通过受管脚本生成，而不是靠记忆手填。
 - 如果 \`Rule Preflight\` 缺失、过期或和实际行为冲突，就把它视为 stage-contract failure，而不是继续润色或继续推进。
 - 项目里已安装的规则优先于模型记忆；如果记忆里的旧做法和 \`.lab/.managed/rule-manifest.json\` 记录的规则冲突，以项目里安装的规则为准。
 - 最终论文默认输出为 LaTeX，论文语言与工作流语言分开决定。
@@ -2878,7 +2880,7 @@ ZH_CONTENT[path.join(".codex", "skills", "lab", "stages", "auto.md")] = `# \`/la
 ## 规则预检
 
 - 启动 auto 前先读取 \`.lab/.managed/rule-manifest.json\`。
-- 可见的 \`Auto preflight\` 块里除了契约字段外，还要写明：Rule source file、Rule source revision、Project version、Resolved stage、Resolved mode、Resolved target，以及任何 override reason。
+- 可见的 \`Auto preflight\` 块里除了契约字段外，还要写明：Rule source file、Rule source revision、Project version、Resolved stage、Resolved mode、Resolved target、Preflight stamp，以及任何 override reason。
 - 这些 \`Rule Preflight\` 字段也要保存在 \`.lab/context/auto-status.md\`。
 - 如果已安装的 auto 规则和当前 campaign 行为不一致，就先修正契约或补充有效 override 理由，再启动 loop。
 

package/lib/install.cjs

@@ -7,7 +7,7 @@ const { getLocalizedContent } = require("./i18n.cjs");
 
 const REPO_ROOT = path.resolve(__dirname, "..");
 const PACKAGE_VERSION = require(path.join(REPO_ROOT, "package.json")).version;
-const LAYOUT_VERSION = 1;
+const LAYOUT_VERSION = 2;
 const SUPERLAB_START = "<!-- superlab:start -->";
 const SUPERLAB_END = "<!-- superlab:end -->";
 

package/lib/rule_preflight.cjs

@@ -1,5 +1,6 @@
 const fs = require("node:fs");
 const path = require("node:path");
+const crypto = require("node:crypto");
 
 function ruleManifestPath(targetDir) {
   return path.join(targetDir, ".lab", ".managed", "rule-manifest.json");
@@ -33,7 +34,7 @@ function buildRulePreflight({
   overrideReason = "",
 } = {}) {
   const entry = resolveStageRuleEntry(targetDir, stage) || {};
-  return {
+  const preflight = {
     ruleSourceFile: entry.ruleSourceFile || "",
     ruleSourceRevision: entry.ruleSourceRevision || "",
     projectVersion: entry.packageVersion || "",
@@ -42,11 +43,58 @@ function buildRulePreflight({
     resolvedTarget: target || "",
     overrideReason: overrideReason || "",
   };
+  return {
+    ...preflight,
+    preflightStamp: computeRulePreflightStamp(preflight),
+  };
+}
+
+function computeRulePreflightStamp(preflight = {}) {
+  const payload = {
+    ruleSourceFile: preflight.ruleSourceFile || "",
+    ruleSourceRevision: preflight.ruleSourceRevision || "",
+    projectVersion: preflight.projectVersion || "",
+    resolvedStage: preflight.resolvedStage || "",
+    resolvedMode: preflight.resolvedMode || "",
+    resolvedTarget: preflight.resolvedTarget || "",
+    overrideReason: preflight.overrideReason || "",
+  };
+  return crypto.createHash("sha256").update(JSON.stringify(payload)).digest("hex");
+}
+
+function renderRulePreflightSection(preflight = {}, { lang = "en" } = {}) {
+  if (lang === "zh") {
+    return `## 规则预检
+
+- 规则来源文件: ${preflight.ruleSourceFile || ""}
+- 规则来源修订: ${preflight.ruleSourceRevision || ""}
+- 项目版本: ${preflight.projectVersion || ""}
+- 解析后的阶段: ${preflight.resolvedStage || ""}
+- 解析后的模式: ${preflight.resolvedMode || ""}
+- 解析后的目标: ${preflight.resolvedTarget || ""}
+- 预检签名: ${preflight.preflightStamp || ""}
+- 如有覆盖理由: ${preflight.overrideReason || ""}
+`;
+  }
+
+  return `## Rule Preflight
+
+- Rule source file: ${preflight.ruleSourceFile || ""}
+- Rule source revision: ${preflight.ruleSourceRevision || ""}
+- Project version: ${preflight.projectVersion || ""}
+- Resolved stage: ${preflight.resolvedStage || ""}
+- Resolved mode: ${preflight.resolvedMode || ""}
+- Resolved target: ${preflight.resolvedTarget || ""}
+- Preflight stamp: ${preflight.preflightStamp || ""}
+- Override reason, if any: ${preflight.overrideReason || ""}
+`;
 }
 
 module.exports = {
   buildRulePreflight,
+  computeRulePreflightStamp,
   readRuleManifest,
+  renderRulePreflightSection,
   resolveStageRuleEntry,
   ruleManifestPath,
 };

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

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+
+
+DEPRECATION_MARKERS = ("archived", "deprecated", "legacy", "out-of-band", "归档", "废弃", "旧层", "旁路", "历史")
+PATH_TOKEN_PATTERN = re.compile(
+    r"(/[^ \t\n\r)]+|(?:[A-Za-z0-9_.-]+/)+[A-Za-z0-9_.\-/]+)"
+)
+
+
+def find_project_root(start_path: Path) -> Path | None:
+    for parent in (start_path, *start_path.parents):
+        workflow_config = parent / ".lab" / "config" / "workflow.json"
+        if workflow_config.exists():
+            return parent
+    return None
+
+
+def load_workflow_config(project_root: Path | None) -> dict:
+    if project_root is None:
+        return {}
+    workflow_config = project_root / ".lab" / "config" / "workflow.json"
+    if not workflow_config.exists():
+        return {}
+    try:
+        return json.loads(workflow_config.read_text(encoding="utf-8"))
+    except json.JSONDecodeError:
+        return {}
+
+
+def resolve_paper_topology(project_root: Path, workflow_config: dict | None = None) -> dict:
+    config = workflow_config or load_workflow_config(project_root)
+    deliverables_root = (project_root / config.get("deliverables_root", "docs/research")).resolve()
+    canonical_root = (deliverables_root / "paper").resolve()
+    workflow_language = config.get("workflow_language", "")
+    paper_language = config.get("paper_language", "")
+    workflow_language_active = bool(workflow_language and paper_language and workflow_language != paper_language)
+    workflow_root = (canonical_root / "workflow-language").resolve() if workflow_language_active else None
+    return {
+        "project_root": project_root.resolve(),
+        "deliverables_root": deliverables_root,
+        "canonical_root": canonical_root,
+        "workflow_root": workflow_root,
+        "workflow_language_active": workflow_language_active,
+    }
+
+
+def normalize_path(path_value: str | Path, project_root: Path) -> Path:
+    path_obj = Path(path_value)
+    return path_obj.resolve() if path_obj.is_absolute() else (project_root / path_obj).resolve()
+
+
+def is_within(candidate: Path, root: Path | None) -> bool:
+    if root is None:
+        return False
+    try:
+        candidate.relative_to(root)
+        return True
+    except ValueError:
+        return False
+
+
+def classify_paper_path(path_value: str | Path, topology: dict) -> tuple[str, Path]:
+    candidate = normalize_path(path_value, topology["project_root"])
+    if topology["workflow_language_active"] and is_within(candidate, topology["workflow_root"]):
+        return "active-workflow-language", candidate
+    if is_within(candidate, topology["canonical_root"]):
+        return "active-canonical", candidate
+
+    parts = candidate.parts
+    if any(part.startswith("review_") or part.startswith("translation_") or part.startswith("sections_") for part in parts):
+        return "legacy-paper-layer", candidate
+    if "deliverables" in parts and ("sections" in parts or "workflow-language" in parts):
+        return "legacy-paper-layer", candidate
+    if "docs" in parts and "lab" in parts and "paper" in parts:
+        return "legacy-paper-layer", candidate
+    return "out-of-band", candidate
+
+
+def line_is_deprecated(line: str) -> bool:
+    lowered = line.lower()
+    return any(marker in lowered for marker in DEPRECATION_MARKERS)
+
+
+def iter_path_tokens(text: str):
+    for line_number, line in enumerate(text.splitlines(), start=1):
+        for match in PATH_TOKEN_PATTERN.finditer(line):
+            yield line_number, line, match.group(1)

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

@@ -0,0 +1,115 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import re
+from pathlib import Path
+
+from validate_rule_preflight import compute_preflight_stamp
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Render or inject a machine-generated Rule Preflight block for a managed lab stage artifact."
+    )
+    parser.add_argument("--artifact", required=True, help="Markdown artifact to update in place")
+    parser.add_argument("--stage", required=True, help="Stage name, e.g. write or auto")
+    parser.add_argument("--project-root", required=True, help="Project root containing .lab/.managed/rule-manifest.json")
+    parser.add_argument("--mode", required=True, help="Resolved mode for this round")
+    parser.add_argument("--target", required=True, help="Resolved target for this round")
+    parser.add_argument("--override-reason", default="", help="Optional override reason")
+    parser.add_argument("--lang", choices=("en", "zh"), default="en", help="Render language for the section")
+    return parser.parse_args()
+
+
+def read_manifest(project_root: Path, stage: str) -> dict:
+    manifest_path = project_root / ".lab" / ".managed" / "rule-manifest.json"
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    stage_entry = (manifest.get("stages") or {}).get(stage)
+    if not stage_entry:
+        raise SystemExit(f"stage `{stage}` is missing from {manifest_path}")
+    return {
+        "rule_source_file": stage_entry.get("rule_source_file", ""),
+        "rule_source_revision": stage_entry.get("rule_source_revision", ""),
+        "project_version": manifest.get("package_version", ""),
+    }
+
+
+def render_preflight_block(values: dict[str, str], lang: str) -> str:
+    values = dict(values)
+    values["preflight_stamp"] = compute_preflight_stamp(values)
+    if lang == "zh":
+        lines = [
+            "## 规则预检",
+            "",
+            f"- 规则来源文件: {values['rule_source_file']}",
+            f"- 规则来源修订: {values['rule_source_revision']}",
+            f"- 项目版本: {values['project_version']}",
+            f"- 解析后的阶段: {values['resolved_stage']}",
+            f"- 解析后的模式: {values['resolved_mode']}",
+            f"- 解析后的目标: {values['resolved_target']}",
+            f"- 预检签名: {values['preflight_stamp']}",
+            f"- 如有覆盖理由: {values['override_reason']}",
+            "",
+        ]
+    else:
+        lines = [
+            "## Rule Preflight",
+            "",
+            f"- Rule source file: {values['rule_source_file']}",
+            f"- Rule source revision: {values['rule_source_revision']}",
+            f"- Project version: {values['project_version']}",
+            f"- Resolved stage: {values['resolved_stage']}",
+            f"- Resolved mode: {values['resolved_mode']}",
+            f"- Resolved target: {values['resolved_target']}",
+            f"- Preflight stamp: {values['preflight_stamp']}",
+            f"- Override reason, if any: {values['override_reason']}",
+            "",
+        ]
+    return "\n".join(lines)
+
+
+def replace_or_insert_rule_preflight(text: str, block: str) -> str:
+    pattern = re.compile(r"^##\s+(?:Rule Preflight|规则预检)\s*$", flags=re.MULTILINE)
+    match = pattern.search(text)
+    if match:
+        start = match.start()
+        next_heading = re.search(r"^##\s+", text[match.end():], flags=re.MULTILINE)
+        end = match.end() + next_heading.start() if next_heading else len(text)
+        prefix = text[:start].rstrip() + "\n\n"
+        suffix = text[end:].lstrip("\n")
+        return prefix + block.rstrip() + ("\n\n" + suffix if suffix else "\n")
+
+    title_match = re.search(r"^# .*$", text, flags=re.MULTILINE)
+    if not title_match:
+        return block.rstrip() + "\n\n" + text.lstrip()
+    insert_at = title_match.end()
+    prefix = text[:insert_at].rstrip() + "\n\n"
+    suffix = text[insert_at:].lstrip("\n")
+    return prefix + block.rstrip() + ("\n\n" + suffix if suffix else "\n")
+
+
+def main():
+    args = parse_args()
+    artifact_path = Path(args.artifact)
+    project_root = Path(args.project_root)
+    values = read_manifest(project_root, args.stage)
+    values.update(
+        {
+            "resolved_stage": args.stage,
+            "resolved_mode": args.mode,
+            "resolved_target": args.target,
+            "override_reason": args.override_reason,
+        }
+    )
+    block = render_preflight_block(values, args.lang)
+    original = artifact_path.read_text(encoding="utf-8") if artifact_path.exists() else ""
+    updated = replace_or_insert_rule_preflight(original, block)
+    artifact_path.parent.mkdir(parents=True, exist_ok=True)
+    artifact_path.write_text(updated, encoding="utf-8")
+    print("rule preflight written")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -5,6 +5,7 @@ import re
 import sys
 from pathlib import Path
 from validate_rule_preflight import validate_rule_preflight
+from validate_paper_topology import validate_topology_artifacts
 
 
 ABSOLUTE_PATH_MARKERS = ("/Users/", "/home/", "/tmp/", "/private/tmp/")
@@ -609,6 +610,7 @@ def check_latest_write_iteration_preflight(paper_dir: Path, issues: list[str]):
         issues.append("missing latest write iteration needed for rule preflight validation")
         return
     issues.extend(validate_rule_preflight(latest_iteration, "write", project_root=project_root))
+    issues.extend(validate_topology_artifacts(project_root))
 
 
 def main():

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

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from paper_topology import (
+    classify_paper_path,
+    find_project_root,
+    iter_path_tokens,
+    line_is_deprecated,
+    resolve_paper_topology,
+)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Validate that plan/context artifacts point at the active paper topology instead of legacy side layers."
+    )
+    parser.add_argument("--project-root", required=True, help="Project root containing .lab/config/workflow.json")
+    return parser.parse_args()
+
+
+def read_text(path: Path) -> str:
+    return path.read_text(encoding="utf-8")
+
+
+def validate_file(file_path: Path, topology: dict, issues: list[str]):
+    if not file_path.exists():
+        return
+    text = read_text(file_path)
+    current_heading_deprecated = False
+    for line_number, line in enumerate(text.splitlines(), start=1):
+        stripped = line.strip()
+        if stripped.startswith("#"):
+            current_heading_deprecated = line_is_deprecated(stripped)
+        for _, _, token in iter_path_tokens(line):
+            role, normalized_path = classify_paper_path(token, topology)
+            if role in {"active-canonical", "active-workflow-language"}:
+                continue
+            if current_heading_deprecated or line_is_deprecated(line):
+                continue
+            if role == "legacy-paper-layer":
+                issues.append(
+                    f"{file_path}:line {line_number} treats legacy-paper-layer path as active topology: {token} -> {normalized_path}"
+                )
+
+
+def validate_topology_artifacts(project_root: Path) -> list[str]:
+    topology = resolve_paper_topology(project_root)
+    files_to_check = [
+        project_root / ".lab" / "writing" / "plan.md",
+        topology["deliverables_root"] / "artifact-status.md",
+        project_root / ".lab" / "context" / "evidence-index.md",
+    ]
+
+    issues: list[str] = []
+    for file_path in files_to_check:
+        validate_file(file_path, topology, issues)
+    return issues
+
+
+def main():
+    args = parse_args()
+    project_root = find_project_root(Path(args.project_root).resolve())
+    if project_root is None:
+        print("could not find .lab/config/workflow.json for project root", file=sys.stderr)
+        return 1
+
+    issues = validate_topology_artifacts(project_root)
+
+    if issues:
+        for issue in issues:
+            print(issue, file=sys.stderr)
+        return 1
+
+    print("paper topology is consistent")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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

@@ -0,0 +1,183 @@
+#!/usr/bin/env python3
+import argparse
+import hashlib
+import json
+import re
+import sys
+from pathlib import Path
+
+
+SECTION_PATTERNS = (r"^##\s+Rule Preflight\s*$", r"^##\s+规则预检\s*$")
+FIELD_LABELS = {
+    "rule_source_file": ("Rule source file", "规则来源文件"),
+    "rule_source_revision": ("Rule source revision", "规则来源修订"),
+    "project_version": ("Project version", "项目版本"),
+    "resolved_stage": ("Resolved stage", "解析后的阶段"),
+    "resolved_mode": ("Resolved mode", "解析后的模式"),
+    "resolved_target": ("Resolved target", "解析后的目标"),
+    "preflight_stamp": ("Preflight stamp", "预检签名"),
+    "override_reason": ("Override reason, if any", "Override 理由（如有）"),
+}
+BASE_REQUIRED_FIELD_KEYS = (
+    "rule_source_file",
+    "rule_source_revision",
+    "project_version",
+    "resolved_stage",
+    "resolved_mode",
+    "resolved_target",
+)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Validate that a managed stage artifact records a consistent Rule Preflight block."
+    )
+    parser.add_argument("--artifact", required=True, help="Path to the managed stage artifact")
+    parser.add_argument("--stage", required=True, help="Stage name, e.g. write or auto")
+    parser.add_argument(
+        "--project-root",
+        required=False,
+        help="Optional project root; if omitted, infer it by walking upward for .lab/config/workflow.json",
+    )
+    return parser.parse_args()
+
+
+def read_text(path: Path) -> str:
+    return path.read_text(encoding="utf-8")
+
+
+def find_project_root(start_path: Path) -> Path | None:
+    for parent in (start_path.parent, *start_path.parents):
+        workflow_config = parent / ".lab" / "config" / "workflow.json"
+        if workflow_config.exists():
+            return parent
+    return None
+
+
+def extract_section_body(text: str, patterns: tuple[str, ...]) -> str:
+    for pattern in patterns:
+        match = re.search(pattern, text, flags=re.MULTILINE)
+        if not match:
+            continue
+        start = match.end()
+        next_heading = re.search(r"^##\s+", text[start:], flags=re.MULTILINE)
+        end = start + next_heading.start() if next_heading else len(text)
+        return text[start:end].strip()
+    return ""
+
+
+def extract_field_value(body: str, labels: tuple[str, ...]) -> str | None:
+    for label in labels:
+        pattern = re.compile(
+            rf"^\s*(?:-|\d+\.)\s*{re.escape(label)}[:：][ \t]*([^\n]+?)\s*$",
+            flags=re.MULTILINE,
+        )
+        for match in pattern.finditer(body):
+            return match.group(1).strip()
+    return None
+
+
+def has_meaningful_value(value: str | None) -> bool:
+    if value is None:
+        return False
+    normalized = value.strip().lower()
+    return normalized not in {"", "-", "n/a", "na", "none", "null", "todo", "tbd"}
+
+
+def compute_preflight_stamp(values: dict[str, str | None]) -> str:
+    payload = {
+        "ruleSourceFile": values.get("rule_source_file") or "",
+        "ruleSourceRevision": values.get("rule_source_revision") or "",
+        "projectVersion": values.get("project_version") or "",
+        "resolvedStage": values.get("resolved_stage") or "",
+        "resolvedMode": values.get("resolved_mode") or "",
+        "resolvedTarget": values.get("resolved_target") or "",
+        "overrideReason": values.get("override_reason") or "",
+    }
+    return hashlib.sha256(json.dumps(payload, ensure_ascii=False).encode("utf-8")).hexdigest()
+
+
+def validate_rule_preflight(artifact_path: Path, stage: str, project_root: Path | None = None) -> list[str]:
+    issues: list[str] = []
+    if project_root is None:
+        project_root = find_project_root(artifact_path)
+    if project_root is None:
+        issues.append("could not infer project root for rule preflight validation")
+        return issues
+
+    manifest_path = project_root / ".lab" / ".managed" / "rule-manifest.json"
+    if not manifest_path.exists():
+        issues.append(f"missing managed rule manifest: {manifest_path.as_posix()}")
+        return issues
+
+    try:
+        manifest = json.loads(read_text(manifest_path))
+    except json.JSONDecodeError:
+        issues.append(f"managed rule manifest is invalid JSON: {manifest_path.as_posix()}")
+        return issues
+
+    stage_entry = (manifest.get("stages") or {}).get(stage)
+    if not stage_entry:
+        issues.append(f"managed rule manifest does not define stage `{stage}`")
+        return issues
+
+    if not artifact_path.exists():
+        issues.append(f"artifact does not exist: {artifact_path.as_posix()}")
+        return issues
+
+    body = extract_section_body(read_text(artifact_path), SECTION_PATTERNS)
+    if not body:
+        issues.append("missing Rule Preflight section")
+        return issues
+
+    values = {
+        key: extract_field_value(body, labels)
+        for key, labels in FIELD_LABELS.items()
+    }
+    required_field_keys = list(BASE_REQUIRED_FIELD_KEYS)
+    if int(manifest.get("layout_version") or 0) >= 2:
+        required_field_keys.append("preflight_stamp")
+    missing = [key for key in required_field_keys if not has_meaningful_value(values[key])]
+    if missing:
+        pretty = ", ".join(FIELD_LABELS[key][0] for key in missing)
+        issues.append(f"missing required rule preflight fields: {pretty}")
+        return issues
+
+    if values["rule_source_file"] != stage_entry.get("rule_source_file"):
+        issues.append(
+            f"rule preflight source file mismatch: expected {stage_entry.get('rule_source_file')}, got {values['rule_source_file']}"
+        )
+    if values["rule_source_revision"] != stage_entry.get("rule_source_revision"):
+        issues.append(
+            "rule preflight source revision mismatch"
+        )
+    if values["project_version"] != manifest.get("package_version"):
+        issues.append(
+            f"rule preflight project version mismatch: expected {manifest.get('package_version')}, got {values['project_version']}"
+        )
+    if values["resolved_stage"].strip().lower() != stage.strip().lower():
+        issues.append(
+            f"rule preflight stage mismatch: expected {stage}, got {values['resolved_stage']}"
+        )
+    if int(manifest.get("layout_version") or 0) >= 2:
+        expected_stamp = compute_preflight_stamp(values)
+        if values["preflight_stamp"] != expected_stamp:
+            issues.append("rule preflight stamp mismatch")
+    return issues
+
+
+def main():
+    args = parse_args()
+    artifact_path = Path(args.artifact)
+    project_root = Path(args.project_root) if args.project_root else None
+    issues = validate_rule_preflight(artifact_path, args.stage, project_root=project_root)
+    if not issues:
+        print("rule preflight is valid")
+        return 0
+    for issue in issues:
+        print(issue, file=sys.stderr)
+    return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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

@@ -10,6 +10,7 @@ from paper_topology import (
     load_workflow_config,
     resolve_paper_topology,
 )
+from validate_paper_topology import validate_topology_artifacts
 from validate_rule_preflight import validate_rule_preflight
 
 
@@ -424,6 +425,13 @@ def check_write_rule_preflight(section_path: Path, issues: list[str]):
     issues.extend(validate_rule_preflight(latest_iteration, "write", project_root=project_root))
 
 
+def check_active_paper_topology(section_path: Path, issues: list[str]):
+    project_root = find_project_root(section_path)
+    if project_root is None:
+        return
+    issues.extend(validate_topology_artifacts(project_root))
+
+
 def check_abstract(text: str, issues: list[str]):
     numbers = re.findall(r"\b\d+(?:\.\d+)?\b", text)
     if len(numbers) > 6:
@@ -550,25 +558,33 @@ def main():
         return 1
 
     text = read_text(section_path)
-    issues: list[str] = []
-    check_common_section_gate_risks(text, issues)
-    check_write_rule_preflight(section_path, issues)
-    check_paper_topology_targeting(section_path, issues)
-    check_workflow_language_targeting(section_path, issues)
-    check_section_style_policy(text, args.section, issues)
-    SECTION_CHECKS[args.section](text, issues)
-    check_neighbor_asset_files(args.section, section_path, issues)
-
-    if not issues:
+    blocking_issues: list[str] = []
+    warning_issues: list[str] = []
+    check_write_rule_preflight(section_path, blocking_issues)
+    check_active_paper_topology(section_path, blocking_issues)
+    check_paper_topology_targeting(section_path, blocking_issues)
+    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)
+    SECTION_CHECKS[args.section](text, warning_issues)
+    check_neighbor_asset_files(args.section, section_path, warning_issues)
+
+    if not blocking_issues and not warning_issues:
         print("section draft is valid")
         return 0
 
     if args.mode == "draft":
-        for issue in issues:
+        if blocking_issues:
+            for issue in blocking_issues:
+                print(issue, file=sys.stderr)
+            for issue in warning_issues:
+                print(f"WARNING: {issue}")
+            return 1
+        for issue in warning_issues:
             print(f"WARNING: {issue}")
         return 0
 
-    for issue in issues:
+    for issue in [*blocking_issues, *warning_issues]:
         print(issue, file=sys.stderr)
     return 1
 

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

@@ -8,6 +8,7 @@
 - Resolved stage:
 - Resolved mode:
 - Resolved target:
+- Preflight stamp:
 - Override reason, if any:
 
 ## Round

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

@@ -8,6 +8,7 @@
 - Resolved stage:
 - Resolved mode:
 - Resolved target:
+- Preflight stamp:
 - Override reason, if any:
 
 ## Round

package/package-assets/shared/lab/context/auto-status.md

@@ -8,6 +8,7 @@
 - Resolved stage:
 - Resolved mode:
 - Resolved target:
+- Preflight stamp:
 - Override reason, if any:
 
 ## Runtime State

package/package-assets/shared/skills/lab/SKILL.md

@@ -37,7 +37,9 @@ Use this skill when the user invokes `/lab:*` or asks for the structured researc
   - `Resolved stage`
   - `Resolved mode`
   - `Resolved target`
+  - `Preflight stamp`
   - `Override reason, if any`
+- Generate the `Rule Preflight` block from `.lab/.managed/rule-manifest.json` with the managed preflight renderer instead of handwriting it from memory.
 - Treat missing, stale, or contradictory `Rule Preflight` data as a stage-contract failure.
 - Project-installed rules take priority over model memory. If remembered patterns conflict with the installed rule source, follow the installed source recorded in `.lab/.managed/rule-manifest.json`.
 - Final paper output should default to LaTeX, and its manuscript language should be decided separately from the workflow language.

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

@@ -29,7 +29,7 @@
 ## Rule Preflight
 
 - Read `.lab/.managed/rule-manifest.json` before arming auto mode.
-- The visible `Auto preflight` summary must also record the installed rule source file, rule source revision, project version, resolved stage, resolved mode, resolved target, and any override reason.
+- The visible `Auto preflight` summary must also record the installed rule source file, rule source revision, project version, resolved stage, resolved mode, resolved target, a machine-generated preflight stamp, and any override reason.
 - Keep the same `Rule Preflight` fields in `.lab/context/auto-status.md` while the campaign is live.
 - If the installed auto rule and the current campaign behavior disagree, stop and fix the contract or record a valid override reason before launching the loop.
 

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

@@ -33,9 +33,10 @@
 ## Rule Preflight
 
 - Read `.lab/.managed/rule-manifest.json` before drafting.
-- Record a `Rule Preflight` block in the write-iteration artifact before revising prose.
-- The `Rule Preflight` block must record the installed rule source file, rule source revision, project version, resolved stage, resolved mode, resolved target, and any override reason.
+- Write the `Rule Preflight` block with `.lab/.managed/scripts/render_rule_preflight.py` before revising prose; do not hand-fill it from memory.
+- The `Rule Preflight` block must record the installed rule source file, rule source revision, project version, resolved stage, resolved mode, resolved target, a machine-generated preflight stamp, and any override reason.
 - If the installed write rule and the current round behavior disagree, fix the targeting or record a valid override reason before further editing.
+- In draft mode, rule-preflight mismatches and paper-topology mismatches are blockers, not polish warnings.
 
 ## Context Write Set
 
@@ -156,7 +157,7 @@ Run these on every round:
   - record what each figure or analysis asset should show and why the reader needs it
   - record which citation anchors must appear in the section and why each anchor matters
 - Before drafting `introduction`, `method`, `experiments`, `related work`, or `conclusion`, run `.lab/.managed/scripts/validate_paper_plan.py --paper-plan .lab/writing/plan.md`.
-- Before drafting `introduction`, `method`, `experiments`, `related work`, or `conclusion`, also run `.lab/.managed/scripts/validate_paper_topology.py --project-root .` so plan/context files cannot keep presenting legacy layers as the active paper topology.
+- Before drafting `introduction`, `method`, `experiments`, `related work`, or `conclusion`, also run `.lab/.managed/scripts/validate_paper_topology.py --project-root .` so plan/context files cannot keep presenting legacy layers as the active paper topology. If that validator fails, do not mark the topology as repaired and do not continue section polish.
 - When the repository workflow config is available, the paper-plan validator also checks that `.lab/writing/plan.md` stays in `workflow_language` instead of silently drifting into another language.
 - If the paper-plan validator fails, stop and fill `.lab/writing/plan.md` first instead of drafting prose.
 - 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.

package/package.json

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