psyclaw 0.27.22 → 0.28.0

package/vendor/ars/scripts/check_390_revision_patch_discipline.py

@@ -0,0 +1,296 @@
+#!/usr/bin/env python3
+"""#390 Slice B revision-mode patch-adoption lint (#424).
+
+Block-scoped string checks per repo convention (check_394 pattern) on the
+prompt surfaces that carry the patch protocol, plus schema example
+validation. Spec: docs/design/2026-06-10-390-diff-patch-revision-mode-
+spec.md (§0 Slice B amendment + §3.2-§3.6 + §8.5).
+
+Invariants:
+  1. draft_writer_agent.md carries the patch-output discipline block:
+     patch-not-full-draft, sidecar emission path, copy-hashes-never-compute,
+     the pre-drafting escalation tag, the <!--block: prohibition, the
+     retry-once rule, and the provisional-response role boundary.
+  2. pipeline_orchestrator_agent.md carries the sequencing block with the
+     current steps IN ORDER (anchorize → authority → dispatch → apply →
+     finalizer → Schema 8/bundle completion), the no-rewrite window, both
+     escalation trigger layers, the MANDATORY checkpoint, current/legacy
+     isolation, exact-authority rebinding, and the 0.6 threshold.
+  3. academic-paper/SKILL.md: mode-table revision row says patch document;
+     the Revision Mode Patch Protocol section exists with the #670 exact
+     authority/bundle boundary and the protocol-doc pointer.
+  4. Schema 8 (shared/handoff_schemas.md): ResponseItem carries
+     change_block_ids, populated by the orchestrator, never by the writer.
+  5. revision_patch_protocol.md ships the exact Mode B commands
+     (anchorize / apply / --acknowledge-structural), exit codes, the
+     apply-report-as-re-review-input rule, and the marker lifecycle.
+  6. Marker rules exist at both consumers: formatter_agent.md ARS Marker
+     Stripping (all three kinds, after-gates ordering, working drafts
+     keep markers) and word_count_conventions.md strip-before-count.
+  7. Threshold value lock: DEFAULT_TOUCHED_RATIO_THRESHOLD == 0.6 in
+     ars_apply_revision_patch.py, the argparse --touched-ratio-threshold
+     default IS that constant (AST, so a regression to None/literal is
+     caught even when the constant still reads 0.6), and the spec §0
+     amendment records the same decisions the prose cites.
+  8. The spec §3.2 example patch validates against
+     revision_patch.schema.json (schema example validation, §8.5).
+"""
+from __future__ import annotations
+
+import json
+import re
+import sys
+from pathlib import Path
+
+import jsonschema
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+if str(REPO_ROOT / "scripts") not in sys.path:
+    sys.path.insert(0, str(REPO_ROOT / "scripts"))
+
+from _skill_lint import check_section_literals, h2_section_body
+from ars_apply_revision_patch import DEFAULT_TOUCHED_RATIO_THRESHOLD
+
+WRITER = REPO_ROOT / "academic-paper/agents/draft_writer_agent.md"
+ORCHESTRATOR = REPO_ROOT / "academic-pipeline/agents/pipeline_orchestrator_agent.md"
+PAPER_SKILL = REPO_ROOT / "academic-paper/SKILL.md"
+SCHEMAS = REPO_ROOT / "shared/handoff_schemas.md"
+PROTOCOL = REPO_ROOT / "academic-paper/references/revision_patch_protocol.md"
+FORMATTER = REPO_ROOT / "academic-paper/agents/formatter_agent.md"
+WORD_COUNT = REPO_ROOT / "shared/references/word_count_conventions.md"
+SPEC = REPO_ROOT / "docs/design/2026-06-10-390-diff-patch-revision-mode-spec.md"
+PATCH_SCHEMA = REPO_ROOT / "shared/contracts/patch/revision_patch.schema.json"
+APPLY_SCRIPT = REPO_ROOT / "scripts/ars_apply_revision_patch.py"
+
+WRITER_HEADING = "## Patch-Document Revision Emission (#390)"
+ORCH_HEADING = "## Revision-Round Patch Sequencing (#390)"
+SKILL_HEADING = "## Revision Mode Patch Protocol (#390)"
+FMT_HEADING = "## ARS Marker Stripping (#390)"
+AMENDMENT_HEADING = "## §0 Slice B amendment (2026-06-11, #424)"
+ESCALATION_TAG = "[PATCH-ESCALATION-REQUIRED:"
+
+
+def check_writer(text: str) -> list[str]:
+    """Invariant 1."""
+    return check_section_literals(1, text, WRITER_HEADING, "writer", {
+        "patch-not-full-draft": "cannot produce a current #670 authorization witness",
+        "schema path": "shared/contracts/patch/revision_patch.schema.json",
+        "sidecar emission path": "phase6_*/revision_patch_round<N>.json",
+        "hash copy discipline": "Copy hashes/bindings, never compute them.",
+        "escalation tag": ESCALATION_TAG + " layer=pre_drafting",
+        "block-marker prohibition": "MUST NOT contain `<!--block:` markers",
+        "retry-once": "Do not patch the patch",
+        "role boundary": "emit **provisional** Schema 8 response items",
+    })
+
+
+def check_orchestrator(text: str) -> list[str]:
+    """Invariant 2."""
+    fails = check_section_literals(2, text, ORCH_HEADING, "orchestrator", {
+        "no-rewrite window": "nothing may rewrite the draft between steps 1 and 3",
+        "layer-1 trigger": ESCALATION_TAG,
+        "layer-2 trigger": "refused_structural",
+        "checkpoint": "MANDATORY CHECKPOINT",
+        "legacy isolation": "outside the current #670 contract",
+        "no current replay fallback": "cannot emit a current",
+        "retry-once": "one patch re-emission",
+        "Schema 8 completion": "change_block_ids",
+        "bundle completion": "revision-evidence-bundle/1.0",
+        "budget surface": "preserved_ratio",
+        "threshold value": "0.6",
+        "authority rebinding": "re-anchorize/rebuild bindings",
+    })
+    section = h2_section_body(text, ORCH_HEADING)
+    if section is not None:
+        steps = [
+            "**Anchorize and chain-start:**",
+            "**Build/validate explicit authority:**",
+            "**Dispatch the writer**",
+            "**Apply with full authority arguments:**",
+            "**Token-conservation + finalizer:**",
+            "**Complete Schema 8 mechanical fields**",
+        ]
+        positions = [section.find(s) for s in steps]
+        if -1 in positions:
+            fails.append(
+                "invariant 2: orchestrator sequencing lost step "
+                f"{steps[positions.index(-1)]!r}")
+        elif positions != sorted(positions):
+            fails.append(
+                "invariant 2: orchestrator sequencing steps are out of the "
+                "normative order (anchorize → authority → dispatch → apply "
+                "→ finalizer → Schema 8/bundle completion)")
+    return fails
+
+
+def check_paper_skill(text: str) -> list[str]:
+    """Invariant 3."""
+    fails = check_section_literals(3, text, SKILL_HEADING, "SKILL.md", {
+        "protocol doc pointer": "references/revision_patch_protocol.md",
+        "current patch": "patch 1.1",
+        "bundle boundary": "revision-evidence-bundle/1.0",
+        "honest boundary": "unregistered semantic drift still requires E6 review",
+        "legacy boundary": "legacy full re-emission cannot claim current authorization PASS",
+    })
+    row = next(
+        (line for line in text.splitlines()
+         if line.lstrip().startswith("| `revision` |")), None)
+    if row is None:
+        fails.append("invariant 3: mode table lost the `revision` row")
+    elif "Patch document" not in row:
+        fails.append(
+            "invariant 3: mode-table revision row no longer names the "
+            "patch document deliverable")
+    return fails
+
+
+def check_schema8(text: str) -> list[str]:
+    """Invariant 4."""
+    return check_section_literals(
+        4, text, "## Schema 8: Response to Reviewers", "Schema 8", {
+            "field row": "`change_block_ids`",
+            "producer split": "never by the writer",
+            "consumer cross-check": "apply report",
+        })
+
+
+def check_protocol_doc(text: str | None) -> list[str]:
+    """Invariant 5."""
+    if text is None:
+        return [f"invariant 5: protocol doc missing ({PROTOCOL})"]
+    literals = {
+        "anchorize command": "python scripts/ars_anchorize_draft.py",
+        "apply command": "python scripts/ars_apply_revision_patch.py",
+        "acknowledge flag": "--acknowledge-structural",
+        "new-artifact rule": "MUST be a new file",
+        "exit codes": "`2` Phase 1 rejection",
+        "re-review input": "required input to re-review",
+        "threshold value": "0.6",
+        "marker lifecycle": "## Marker lifecycle",
+        "honest claim": "cannot be silently distorted",
+    }
+    return [
+        f"invariant 5: protocol doc lost the {name} literal ({lit!r})"
+        for name, lit in literals.items() if lit not in text
+    ]
+
+
+def check_marker_rules(formatter_text: str, word_count_text: str) -> list[str]:
+    """Invariant 6."""
+    fails = check_section_literals(
+        6, formatter_text, FMT_HEADING, "formatter", {
+            "block marker": "<!--block:",
+            "ref marker": "<!--ref:",
+            "anchor marker": "<!--anchor:",
+            "ordering": "ONLY AFTER every marker-dependent gate",
+            "working-draft preservation": "keep their markers untouched",
+        })
+    if "### HTML-comment markers" not in word_count_text:
+        fails.append(
+            "invariant 6: word_count_conventions lost the HTML-comment "
+            "markers section")
+    if "Strip every `<!--...-->` comment before computing" not in word_count_text:
+        fails.append(
+            "invariant 6: word_count_conventions lost the strip-before-"
+            "count rule")
+    return fails
+
+
+def _cli_default_is_the_constant(apply_src: str) -> bool:
+    """True iff the apply script's --touched-ratio-threshold argparse arg
+    has `default=DEFAULT_TOUCHED_RATIO_THRESHOLD`. AST, not string match,
+    so a regression to `default=None` or a re-hardcoded literal is caught
+    even though the constant itself still equals 0.6."""
+    import ast
+    tree = ast.parse(apply_src)
+    for node in ast.walk(tree):
+        if not (isinstance(node, ast.Call)
+                and isinstance(node.func, ast.Attribute)
+                and node.func.attr == "add_argument"):
+            continue
+        if not (node.args and isinstance(node.args[0], ast.Constant)
+                and node.args[0].value == "--touched-ratio-threshold"):
+            continue
+        for kw in node.keywords:
+            if kw.arg == "default":
+                return (isinstance(kw.value, ast.Name)
+                        and kw.value.id == "DEFAULT_TOUCHED_RATIO_THRESHOLD")
+    return False
+
+
+def check_threshold_lock(spec_text: str, apply_src: str) -> list[str]:
+    """Invariant 7."""
+    fails: list[str] = []
+    if DEFAULT_TOUCHED_RATIO_THRESHOLD != 0.6:
+        fails.append(
+            "invariant 7: DEFAULT_TOUCHED_RATIO_THRESHOLD is "
+            f"{DEFAULT_TOUCHED_RATIO_THRESHOLD!r}, the recorded #424 ship "
+            "decision is 0.6 — changing it requires a new spec amendment "
+            "AND updating every 0.6 prose citation this lint guards")
+    if not _cli_default_is_the_constant(apply_src):
+        fails.append(
+            "invariant 7: the --touched-ratio-threshold argparse default is "
+            "not `DEFAULT_TOUCHED_RATIO_THRESHOLD` — a regression to None or "
+            "a re-hardcoded literal would disable/desync the ship-decision "
+            "default while the constant still reads 0.6")
+    fails.extend(check_section_literals(
+        7, spec_text, AMENDMENT_HEADING, "spec amendment", {
+            "threshold decision": "0.6",
+            "exemption decision": "heading-anchor exemption",
+            "emission decision": "sidecar file",
+        }))
+    return fails
+
+
+def spec_example_patch(spec_text: str) -> dict | None:
+    """First ```json block of spec §3.2, parsed."""
+    section = spec_text.split("### 3.2 Patch document", 1)
+    if len(section) < 2:
+        return None
+    m = re.search(r"```json\n(.*?)```", section[1], re.DOTALL)
+    if m is None:
+        return None
+    return json.loads(m.group(1))
+
+
+def check_spec_example(spec_text: str, schema: dict) -> list[str]:
+    """Invariant 8."""
+    example = spec_example_patch(spec_text)
+    if example is None:
+        return ["invariant 8: spec §3.2 example patch JSON block not found"]
+    try:
+        jsonschema.validate(example, schema)
+    except jsonschema.ValidationError as exc:
+        return [f"invariant 8: spec §3.2 example no longer validates "
+                f"against revision_patch.schema.json: {exc.message}"]
+    return []
+
+
+def main() -> int:
+    failures: list[str] = []
+    failures += check_writer(WRITER.read_text(encoding="utf-8"))
+    failures += check_orchestrator(ORCHESTRATOR.read_text(encoding="utf-8"))
+    failures += check_paper_skill(PAPER_SKILL.read_text(encoding="utf-8"))
+    failures += check_schema8(SCHEMAS.read_text(encoding="utf-8"))
+    failures += check_protocol_doc(
+        PROTOCOL.read_text(encoding="utf-8") if PROTOCOL.exists() else None)
+    failures += check_marker_rules(
+        FORMATTER.read_text(encoding="utf-8"),
+        WORD_COUNT.read_text(encoding="utf-8"))
+    spec_text = SPEC.read_text(encoding="utf-8")
+    failures += check_threshold_lock(
+        spec_text, APPLY_SCRIPT.read_text(encoding="utf-8"))
+    failures += check_spec_example(
+        spec_text, json.loads(PATCH_SCHEMA.read_text(encoding="utf-8")))
+
+    if failures:
+        print("check_390_revision_patch_discipline: FAIL")
+        for failure in failures:
+            print(f"  - {failure}")
+        return 1
+    print("check_390_revision_patch_discipline: OK (8 invariants)")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/vendor/ars/scripts/check_392_citation_verification_intake.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+"""#392 lint — citation-verification intake question stays wired and byte-equivalent.
+
+Step 13 of the intake interview surfaces the `terminal_policies.citation_existence`
+choice (mark only / strict). Two failure modes this lint pins:
+
+1. **Orphaning** — the exact #327 P1 failure that hit Step 12: the no-handoff
+   interview directive bounds the flow short of the step, so the most common
+   full-mode entry never asks the question. The directive must affirmatively
+   reach Step 13 (`then Step 13`), not merely contain the token somewhere.
+2. **Byte-equivalence erosion** — the advisory path must write NOTHING to the
+   passport (per-key absence == advisory, Invariant 7). The Step 13 block must
+   retain the write-nothing rule; a future edit that makes the advisory answer
+   write an explicit key silently breaks byte-equivalence with pre-#392 runs.
+
+Invariants:
+  I1: intake_agent.md has the `### Step 13: Citation Verification Level` heading.
+  I2: the `### When No Handoff Materials Are Detected` block affirmatively
+      reaches Step 13 (contains "then Step 13").
+  I3: the PCR template carries a `**Citation Verification**` row.
+  I4: the Step 13 block retains the advisory write-nothing rule (a "write
+      nothing to the passport" phrase) AND the strict seeding target
+      (`terminal_policies.citation_existence: strict`).
+
+Exit codes: 0 = pass, 1 = invariant violated, 2 = parse failure (file/heading
+moved) — fail loud, never skip silently.
+"""
+from __future__ import annotations
+
+import argparse
+import re
+import sys
+from pathlib import Path
+
+INTAKE_REL = Path("academic-paper/agents/intake_agent.md")
+STEP13_HEADING = "### Step 13: Citation Verification Level"
+NO_HANDOFF_HEADING = "### When No Handoff Materials Are Detected"
+PCR_ROW_RE = re.compile(r"^\|\s*\*\*Citation Verification\*\*\s*\|", re.MULTILINE)
+WRITE_NOTHING_RE = re.compile(r"write nothing to the passport", re.IGNORECASE)
+STRICT_SEED_RE = re.compile(r"terminal_policies\.citation_existence:\s*strict")
+
+
+def _section(text: str, heading: str) -> str:
+    """Return the block from `heading` to the next heading of <= its level."""
+    start = text.find(heading)
+    if start < 0:
+        raise RuntimeError(f"heading not found: {heading!r}")
+    level = heading.split(" ")[0]  # e.g. '###'
+    pattern = re.compile(rf"^#{{2,{len(level)}}}\s", re.MULTILINE)
+    m = pattern.search(text, start + len(heading))
+    return text[start : m.start()] if m else text[start:]
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--root",
+        type=Path,
+        default=Path(__file__).resolve().parent.parent,
+        help="repo root (tests point this at a fake tree)",
+    )
+    args = parser.parse_args(argv)
+
+    try:
+        text = (args.root / INTAKE_REL).read_text(encoding="utf-8")
+    except OSError as exc:
+        print(f"PARSE ERROR: {exc}", file=sys.stderr)
+        return 2
+
+    errors: list[str] = []
+
+    # I1
+    if STEP13_HEADING not in text:
+        print(
+            f"PARSE ERROR: heading not found: {STEP13_HEADING!r} "
+            "(step removed or renamed — update this lint in the same change)",
+            file=sys.stderr,
+        )
+        return 2
+
+    # I2 — anti-orphan (mirror of check_domain_evidence_profile C8 / #327 P1)
+    try:
+        no_handoff = _section(text, NO_HANDOFF_HEADING)
+    except RuntimeError as exc:
+        print(f"PARSE ERROR: {exc}", file=sys.stderr)
+        return 2
+    if "then Step 13" not in no_handoff:
+        errors.append(
+            "I2: the no-handoff interview directive does not affirmatively reach "
+            "Step 13 — the citation-verification question is orphaned from the "
+            "most common full-mode entry (the #327 P1 failure mode). The "
+            "directive must contain 'then Step 13'."
+        )
+
+    # I3
+    if not PCR_ROW_RE.search(text):
+        errors.append(
+            "I3: PCR template has no '**Citation Verification**' row — the "
+            "scholar's answer has no recorded home."
+        )
+
+    # I4 — byte-equivalence (advisory writes nothing; strict seeds the key)
+    step13 = _section(text, STEP13_HEADING)
+    if not WRITE_NOTHING_RE.search(step13):
+        errors.append(
+            "I4: Step 13 lost the advisory write-nothing rule — an explicit "
+            "advisory key would break Invariant 7 byte-equivalence with "
+            "pre-#392 runs."
+        )
+    if not STRICT_SEED_RE.search(step13):
+        errors.append(
+            "I4: Step 13 lost the strict seeding target "
+            "(`terminal_policies.citation_existence: strict`)."
+        )
+
+    if errors:
+        for e in errors:
+            print(f"FAIL {e}", file=sys.stderr)
+        return 1
+
+    print("citation-verification intake (#392): all 4 invariants pass")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/vendor/ars/scripts/check_394_submission_policy.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+"""#394 slice-4 submission-package terminality lint.
+
+Runs alongside the other policy lints (check_v3_10_policy.py pattern).
+Verifies the slice-4 contract across the terminal-policies schema, the
+orchestrator prompt, the formatter prompt, the verifier script, and the
+report schema. Spec: docs/design/2026-06-10-394-submission-package-verifier-
+spec.md §5.2/§5.3/§7.
+
+Invariants (plan D5, post-gate-1):
+  1. terminal_policies.schema.json `submission_package` enum is EXACTLY
+     {advisory, strict} and carries no JSON-Schema `default` (the absent-key
+     default is an evaluator runtime convention — a schema default would be
+     non-operational false comfort, the Invariant-3 lesson).
+  2. The orchestrator's Submission-Package Terminal Gate section exists and
+     carries the load-bearing literals: the fix-loop bound ("bounded: 2 fix
+     rounds"), VERIFICATION-INCOMPLETE, --check-freshness, the sole-reader
+     sentence, and the gate-on-tokens-not-exit-codes sentence.
+  3. The formatter carries the Submission Package Advisories section with its
+     emptiness contract ("mandatory and non-empty iff") and the stamp-only
+     boundary (Invariant 13 stays cited in the section).
+  4. AST single-homed guard (§5.3): verify_submission_package.py contains NO
+     runtime ACCESS of the "terminal_policies" key — no Subscript
+     x["terminal_policies"] and no .get("terminal_policies") anywhere in the
+     module. Docstrings / comments / help text may mention the word freely
+     (a literal grep would die on the module docstring — gate-1 P2).
+  5. The report schema's policy_slug is the closed enum
+     {null, advisory, strict} — exactly the values the CLI stamps — and its
+     description documents the null-never-fresh semantics.
+"""
+from __future__ import annotations
+
+import ast
+import json
+import sys
+from pathlib import Path
+
+if str(Path(__file__).resolve().parent) not in sys.path:
+    sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from _skill_lint import check_section_literals
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+TP_SCHEMA = REPO_ROOT / "shared/contracts/passport/terminal_policies.schema.json"
+REPORT_SCHEMA = (
+    REPO_ROOT / "shared/contracts/submission/"
+    "submission_verification_report.schema.json"
+)
+ORCHESTRATOR = (
+    REPO_ROOT / "academic-pipeline/agents/pipeline_orchestrator_agent.md"
+)
+FORMATTER = REPO_ROOT / "academic-paper/agents/formatter_agent.md"
+VERIFIER = REPO_ROOT / "scripts/verify_submission_package.py"
+
+ORCH_HEADING = "## Submission-Package Terminal Gate"
+FMT_HEADING = "## Submission Package Advisories"
+
+
+def check_tp_schema(schema: dict) -> list[str]:
+    """Invariant 1."""
+    fails: list[str] = []
+    sp = schema.get("properties", {}).get("submission_package")
+    if sp is None:
+        return ["invariant 1: terminal_policies schema has no "
+                "submission_package key"]
+    if set(sp.get("enum", [])) != {"advisory", "strict"}:
+        fails.append(
+            "invariant 1: submission_package enum is "
+            f"{sp.get('enum')!r}, expected exactly ['advisory', 'strict']")
+    if "default" in sp:
+        fails.append(
+            "invariant 1: submission_package MUST NOT carry a JSON-Schema "
+            "`default` (absent-key advisory is an evaluator runtime "
+            "convention; a schema default is non-operational)")
+    return fails
+
+
+def check_orchestrator(text: str) -> list[str]:
+    """Invariant 2."""
+    return check_section_literals(2, text, ORCH_HEADING,
+                                   "orchestrator gate", {
+        "fix-loop bound": "bounded: 2 fix rounds",
+        "fail-closed verdict": "VERIFICATION-INCOMPLETE",
+        "freshness guard": "--check-freshness",
+        "sole-reader sentence":
+            "SOLE reader of `terminal_policies.submission_package`",
+        "token-not-exit-code sentence":
+            "Gate on stdout tokens, NEVER on exit codes",
+        "recompute discipline": "Recompute each pass",
+    })
+
+
+def check_formatter(text: str) -> list[str]:
+    """Invariant 3."""
+    return check_section_literals(3, text, FMT_HEADING,
+                                   "formatter advisories", {
+        "emptiness contract": "mandatory and non-empty iff",
+        "stamp-only boundary": "Invariant 13",
+        "not_applicable exclusion": "`not_applicable` rows",
+    })
+
+
+def find_terminal_policies_access(source: str) -> list[str]:
+    """Invariant 4 core: return descriptions of every runtime ACCESS of the
+    'terminal_policies' key — a Subscript x["terminal_policies"] or a
+    .get("terminal_policies", ...) call. Mentions in docstrings, comments, or
+    help text never match (this is the AST replacement for the dead-on-
+    arrival literal grep, gate-1 P2)."""
+    hits: list[str] = []
+    tree = ast.parse(source)
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Subscript):
+            sl = node.slice
+            if isinstance(sl, ast.Constant) and sl.value == "terminal_policies":
+                hits.append(f"Subscript access at line {node.lineno}")
+        elif (isinstance(node, ast.Call)
+              and isinstance(node.func, ast.Attribute)
+              and node.func.attr == "get"
+              and node.args
+              and isinstance(node.args[0], ast.Constant)
+              and node.args[0].value == "terminal_policies"):
+            hits.append(f".get() access at line {node.lineno}")
+    return hits
+
+
+def check_verifier_single_homed(source: str) -> list[str]:
+    """Invariant 4."""
+    return [
+        f"invariant 4: verify_submission_package.py reads the "
+        f"terminal_policies key ({hit}) — the script must stay single-homed "
+        f"(§5.3: the orchestrator is the only policy reader)"
+        for hit in find_terminal_policies_access(source)
+    ]
+
+
+def check_report_schema(schema: dict) -> list[str]:
+    """Invariant 5."""
+    fails: list[str] = []
+    slug = (schema.get("properties", {}).get("header", {})
+            .get("properties", {}).get("policy_slug"))
+    if slug is None:
+        return ["invariant 5: report schema has no header.policy_slug"]
+    # Direct value comparison — None must be JSON null, not the string
+    # "None" (a str() mapping would let the two collide; final-round P3).
+    if set(slug.get("enum", [])) != {None, "advisory", "strict"}:
+        fails.append(
+            f"invariant 5: policy_slug enum is {slug.get('enum')!r}, "
+            "expected exactly [null, 'advisory', 'strict'] — the closed set "
+            "of values the CLI stamps")
+    desc = slug.get("description", "")
+    if "null" not in desc or "freshness" not in desc:
+        fails.append(
+            "invariant 5: policy_slug description must document the "
+            "null-stamped-never-fresh semantics")
+    return fails
+
+
+def main() -> int:
+    failures: list[str] = []
+    failures += check_tp_schema(
+        json.loads(TP_SCHEMA.read_text(encoding="utf-8")))
+    failures += check_orchestrator(ORCHESTRATOR.read_text(encoding="utf-8"))
+    failures += check_formatter(FORMATTER.read_text(encoding="utf-8"))
+    failures += check_verifier_single_homed(
+        VERIFIER.read_text(encoding="utf-8"))
+    failures += check_report_schema(
+        json.loads(REPORT_SCHEMA.read_text(encoding="utf-8")))
+    if failures:
+        print("#394 slice-4 submission-policy lint FAILED:")
+        for f in failures:
+            print(f"- {f}")
+        return 1
+    print("#394 slice-4 submission-policy lint OK")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())