superlab 0.1.62 → 0.1.64

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

@@ -4,6 +4,13 @@ import json
 import re
 import sys
 from pathlib import Path
+from paper_topology import (
+    classify_paper_path,
+    find_project_root,
+    load_workflow_config,
+    resolve_paper_topology,
+)
+from validate_paper_topology import validate_topology_artifacts
 from validate_rule_preflight import validate_rule_preflight
 
 
@@ -60,26 +67,6 @@ def has_local_naming_bridge(text: str) -> bool:
     )
 
 
-def find_project_root(section_path: Path) -> Path | None:
-    for parent in (section_path.parent, *section_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 extract_markdown_field(text: str, section_heading: str, field_label: str) -> str:
     section_match = re.search(
         rf"^##\s+{re.escape(section_heading)}\s*$([\s\S]*?)(?=^##\s+|\Z)",
@@ -317,6 +304,53 @@ def check_neighbor_asset_files(section: str, section_path: Path, issues: list[st
             )
 
 
+def check_paper_topology_targeting(section_path: Path, issues: list[str]):
+    project_root = find_project_root(section_path)
+    workflow_config = load_workflow_config(project_root)
+    if project_root is None or not workflow_config:
+        return
+
+    topology = resolve_paper_topology(project_root, workflow_config)
+    target_role, _ = classify_paper_path(section_path, topology)
+    if target_role in {"active-canonical", "active-workflow-language"}:
+        return
+
+    iteration_dir = project_root / ".lab" / "writing" / "iterations"
+    if not iteration_dir.exists():
+        issues.append(
+            "section target is outside the active paper topology, but no write-iteration audit explains why this out-of-band edit was acceptable"
+        )
+        return
+
+    iteration_files = sorted(iteration_dir.glob("*.md"))
+    if not iteration_files:
+        issues.append(
+            "section target is outside the active paper topology, but no write-iteration audit explains why this out-of-band edit was acceptable"
+        )
+        return
+
+    iteration_text = read_text(iteration_files[-1])
+    recorded_role = extract_markdown_field(
+        iteration_text,
+        "Paper Topology Target",
+        "Resolved target path role:",
+    )
+    out_of_band_reason = extract_markdown_field(
+        iteration_text,
+        "Paper Topology Target",
+        "If the target path was outside the active paper topology, why was out-of-band editing acceptable:",
+    )
+
+    if recorded_role and target_role not in recorded_role:
+        issues.append(
+            f"section target is outside the active paper topology, but the latest write iteration records a different target role ({recorded_role})"
+        )
+    if not has_meaningful_field_value(out_of_band_reason):
+        issues.append(
+            "section target is outside the active paper topology, but the latest write iteration does not explain why this out-of-band edit was acceptable"
+        )
+
+
 def check_workflow_language_targeting(section_path: Path, issues: list[str]):
     project_root = find_project_root(section_path)
     workflow_config = load_workflow_config(project_root)
@@ -325,7 +359,10 @@ def check_workflow_language_targeting(section_path: Path, issues: list[str]):
     if not workflow_language or not paper_language or workflow_language == paper_language:
         return
 
-    if "workflow-language" in section_path.parts:
+    topology = resolve_paper_topology(project_root, workflow_config) if project_root else None
+    target_role = classify_paper_path(section_path, topology)[0] if topology else ""
+
+    if target_role != "active-canonical":
         return
 
     if project_root is None:
@@ -388,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:
@@ -514,24 +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_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
@@ -92,6 +93,13 @@
 - If both canonical manuscript and workflow-language layer were edited, why:
 - Was cross-language sync explicitly requested or required by final-draft/export:
 
+## Paper Topology Target
+
+- Active canonical paper root:
+- Active workflow-language paper root:
+- Resolved target path role:
+- If the target path was outside the active paper topology, why was out-of-band editing acceptable:
+
 ## Protocol / Scope Impact Audit
 
 - Did this round replace a canonical experiment or evaluation protocol:

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.
@@ -225,8 +227,10 @@ Use this skill when the user invokes `/lab:*` or asks for the structured researc
 - Ordinary manuscript drafting rounds should follow `workflow_language`.
 - In those ordinary rounds, the manuscript is still LaTeX, so the initial `.tex` section drafts must stay in `workflow_language` rather than jumping straight to `paper_language`.
 - When `workflow_language` and `paper_language` differ, treat the workflow-language paper layer as active and use it as the default ordinary working layer.
+- Resolve the active paper topology from `.lab/config/workflow.json` before drafting; only paths under `<deliverables_root>/paper/` or `<deliverables_root>/paper/workflow-language/` count as managed manuscript targets.
 - Ordinary write rounds should still edit one target paper layer at a time, not both language layers at once.
 - If the user names a concrete file or layer, treat that as the only target for the round unless they also explicitly request synchronization.
+- If the named file falls outside the active paper topology, treat it as an out-of-band file edit instead of a managed manuscript round.
 - If a workflow-language paper layer is active and the round still targets the canonical manuscript, record why canonical-only writing was acceptable in the latest write iteration artifact.
 - If `paper_language_finalization_decision=convert-to-paper-language`, explicit canonical-manuscript work may target the canonical `paper_language` manuscript, but that does not make canonical the default ordinary working layer while workflow-language remains active.
 - Treat the workflow-language paper as a real persisted paper layer, not as a review layer.
@@ -279,6 +283,7 @@ Use this skill when the user invokes `/lab:*` or asks for the structured researc
 - Record the round target layer in the latest 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 latest 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.
+- Record the active canonical paper root, active workflow-language paper root, resolved target path role, and any out-of-band justification in the latest write iteration artifact.
 - Record the protocol/scope impact audit in the latest write iteration artifact whenever a round replaces or rewrites a canonical experiment/evaluation protocol.
 - If the round is an export or remote-publication round, record the export target, whether the workflow-language paper layer was included in the exported or pushed bundle, and why any canonical-only export was acceptable.
 - If a claim is not supported by evidence, weaken or remove it.

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.