@antoneeo/mkt-agentic-sdlc-skill 0.26.0 → 0.28.0

package/skills/mkt-agentic-sdlc/scripts/sdlc_core.py

@@ -100,6 +100,10 @@ CHRONOLOGY_EPOCH = "2026-10-18"
 # filled '## Guide check'. The day AFTER the rule was written, so the analyses
 # opened that day by parallel units (which never saw the template) stay quiet.
 GUIDE_CHECK_EPOCH = "2026-10-24"
+# Owner design approval (F-087): an L3 started on/after this date owes a request-
+# record entry labelled `design approved` before implementation. The day AFTER the
+# rule was written, like GUIDE_CHECK_EPOCH.
+DESIGN_APPROVAL_EPOCH = "2026-10-31"
 NEXT_MAX_CHARS = 240        # this repository's longest `next:` was 214 at the epoch
 ID_SCAN_MAX_REFS = 300      # A3 is skipped above it (one advisory says so, T9)
 ID_SCAN_REFS_PER_CALL = 50  # keeps one git command line far below 32k chars
@@ -265,6 +269,7 @@ REQUIRED_CAPABILITIES = frozenset({
 OPTIONAL_CAPABILITIES = frozenset({
     "architect_pass",         # does the component already exist? (code overlay)
     "interaction_contract",   # actor-facing surface spec between use cases and solution (code overlay)
+    "preservation_constraints",  # the Impact's P table, and validate's note on its absence (code overlay)
     "taxonomy_pass",          # do the categories/topics already exist? (knowledge overlay)
     "comprehension_guides",   # source_kind: code maps of complex components
     "tdd",                    # test-first discipline
@@ -574,12 +579,20 @@ def stray_shadow(solutions_dir, doc_key):
                 None)
 
 
+def skip_dir(name):
+    """The one definition of a directory that holds no project files: VCS and
+    dependency/build directories, every dot-directory, and the docs root (by
+    name, at any depth). `iter_files` and the knowledge layer's inventory both
+    walk by it, so the two can never disagree about what the project is."""
+    return name in SKIP_DIRS or name == docs_dir() or name.startswith(".")
+
+
 def iter_files(target):
     if target.is_file():
         yield target
         return
     for dirpath, dirnames, filenames in os.walk(target):
-        dirnames[:] = [d for d in dirnames if d not in SKIP_DIRS and d != docs_dir() and not d.startswith(".")]
+        dirnames[:] = [d for d in dirnames if not skip_dir(d)]
         for name in filenames:
             yield Path(dirpath) / name
 
@@ -1470,17 +1483,50 @@ def id_advisories(root):
     return out
 
 
-def design_review_due(meta):
-    """True when an L3 ANALYSIS owes a design-review row (review.md moment 1):
-    implementation has started or finished, and it began on/after the gate
-    shipped. PLANNED is exempt -- the review is due at the END of Phase 3, so an
-    analysis still being drafted is not late."""
+def _l3_in_work_since(meta, epoch):
+    """True when an L3 ANALYSIS is in implementation or done and began on/after
+    `epoch` (an ISO date string)."""
     if meta.get("level", "").upper() != "L3":
         return False
     if meta.get("status") not in ("IN_PROGRESS", "COMPLETED"):
         return False
     started = parse_iso((meta.get("start_date") or "").strip().strip("'\""))
-    return started is not None and started >= parse_iso(DESIGN_REVIEW_EPOCH)
+    return started is not None and started >= parse_iso(epoch)
+
+
+def design_review_due(meta):
+    """True when an L3 ANALYSIS owes a design-review row (review.md moment 1):
+    implementation has started or finished, and it began on/after the gate
+    shipped. PLANNED is exempt -- the review is due at the END of Phase 3, so an
+    analysis still being drafted is not late."""
+    return _l3_in_work_since(meta, DESIGN_REVIEW_EPOCH)
+
+
+def design_approval_due(meta):
+    """True when an L3 ANALYSIS owes the owner's design approval (review.md
+    section When a review is due): in implementation or done, begun on/after
+    DESIGN_APPROVAL_EPOCH. PLANNED is exempt -- the question comes after the PASS."""
+    return _l3_in_work_since(meta, DESIGN_APPROVAL_EPOCH)
+
+
+def requests_naming(root, analysis_name):
+    """The request records whose `analysis:` field names this ANALYSIS file."""
+    req = ai_path(root, "audit", "requests")
+    if not req.is_dir():
+        return []
+    return [r for r in sorted(req.glob("REQUEST_*.md"))
+            if str(load_frontmatter(read_text(r).splitlines()).get("analysis") or "")
+            .strip().strip("'\"`") == analysis_name]
+
+
+def design_approval_logged(root, analysis_name):
+    """True when a request record naming this ANALYSIS has an entry whose LABEL
+    begins `design approved` (case-insensitive). Only the label is read, never
+    the quoted words: a quotation is data, and a 'design approved?' inside a
+    refusal approves nothing."""
+    return any(label.lower().startswith("design approved")
+               for r in requests_naming(root, analysis_name)
+               for _, _, label, _ in request_entries(read_text(r))[0])
 
 
 def review_logged(root, analysis_name):
@@ -1792,6 +1838,12 @@ def cmd_validate(root, strict=False, hybrid=False):
             advisories.append(f"{rel}: L3 in implementation with no design-review row in "
                               f"{review_log_rel()} -- the design was reviewed by nobody but its "
                               "author before code was written (review.md moment 1)")
+        if (not hybrid and design_approval_due(meta)
+                and not design_approval_logged(root, p.name)):
+            advisories.append(f"{rel}: L3 in implementation with no design approval in its "
+                              "request record (no entry whose label begins 'design approved') -- the "
+                              "owner never said the design was what they meant before the "
+                              "work started (review.md, When a review is due)")
         if ledger_due(meta) and not has_ledger_heading(text):
             advisories.append(f"{rel}: L3 without '## Capability Ledger' -- the architect pass "
                               "left no record (architect.md); run it before the Impact")
@@ -1799,6 +1851,18 @@ def cmd_validate(root, strict=False, hybrid=False):
             advisories.append(f"{rel}: L3 without a filled '## Guide check' -- does a CURRENT "
                               "guide cover what this touches, and did understanding it force "
                               "a model of a complex component no guide covers (guides.md, section 1)?")
+        # F-085 FS7: code lens only (R12: the lens, not merely the domain -- a kb
+        # install validating a code-domain unit sees no change), open L3 only, a
+        # note and never an error, so no `--strict` exit changes (P5).
+        impact = section_body(text, IMPACT_SECTION)
+        if (has_capability("preservation_constraints") and domain == "code"
+                and str(level or "").upper() == "L3"
+                and status in ("PLANNED", "IN_PROGRESS")
+                and impact is not None and not has_preservation_record(impact)):
+            advisories.append(f"{rel}: open L3 whose '## Impact' has neither the "
+                              f"'{PRESERVATION_HEADING}' table nor the line "
+                              f"'{NO_SYMBOL_LINE}' -- what existing code must keep "
+                              "doing is not extractable (templates.md)")
 
     # Generated index aligned
     hist = ai / "strategic" / "features_history.md"
@@ -2479,6 +2543,28 @@ def read_hook_payload():
     return payload if isinstance(payload, dict) else None
 
 
+def hook_project(target, root=None, docs_name=None):
+    """The project root an edit hook judges, with its docs root name set, or None
+    when two docs roots sit side by side. The hook runs in the session's current
+    directory, which a `cd` moves (live probe 2026-10-27): the project AND its docs
+    root name are the ones holding the edited file, never the ones around the
+    working directory. An explicit root (--root) is kept as given."""
+    start = Path(root) if root is not None else Path(target).resolve().parent
+    try:
+        found_root, name = resolve_docs_dir(argparse.Namespace(docs_dir=docs_name), start)
+    except AmbiguousDocsRoot:
+        return None
+    set_docs_dir(name)
+    if root is not None:
+        return Path(root)
+    if found_root is not None:
+        return found_root
+    found_root = find_project_root(start)  # an explicit name: discovery did not run
+    # No docs root above the edited file: the session's own project, as before the
+    # hook resolved from the file -- the file's folder would unprotect a gated path.
+    return found_root if ai_path(found_root).is_dir() else find_project_root()
+
+
 def cmd_gate(args):
     file_path = args.file or ""
     if args.hook:
@@ -2487,9 +2573,12 @@ def cmd_gate(args):
             file_path = (payload.get("tool_input") or {}).get("file_path") or ""
         except AttributeError:
             return 0  # unparseable input: do not block
-    if not file_path:
+    if not isinstance(file_path, str) or not file_path:
         return 0
-    root = Path(args.root).resolve() if args.root else find_project_root()
+    root = hook_project(file_path, Path(args.root).resolve() if args.root else None,
+                        getattr(args, "docs_dir", None))
+    if root is None:
+        return 0  # two docs roots side by side: cannot tell which governs
     try:
         rel = str(Path(file_path).resolve().relative_to(root)).replace("\\", "/")
     except ValueError:
@@ -2516,7 +2605,8 @@ def cmd_gate(args):
     sys.stderr.write(
         f"[sdlc gate] '{rel}' is on a protected path but no ANALYSIS_*.md is IN_PROGRESS. "
         "If your analysis already exists, set its frontmatter to 'status: IN_PROGRESS' "
-        "(that flip is what opens the gate); otherwise write it first (Phase 3).\n")
+        "(that flip is what opens the gate; at L3, only after the owner's design approval, "
+        "review.md); otherwise write it first (Phase 3).\n")
     return 2
 
 
@@ -2532,10 +2622,24 @@ VERDICT_EDIT_TOOLS = ("Edit", "Write", "MultiEdit", "NotebookEdit")
 VERDICT_MAX_BYTES = 256 * 1024 * 1024  # a larger transcript: cannot afford to tell
 VERDICT_LINE_MAX = 1024 * 1024         # assistant lines are small; skip the rest unparsed
 # Markdown emphasis between the word and the colon ("**router**: no match") and
-# "Router verdict:" are the same declaration: format drift resolves to silence.
+# "Router verdict:" are the same declaration.
 _VERDICT_ROUTER_RE = re.compile(r"router(?:[\s*_`]+verdict)?[\s*_`]*:(.*)", re.IGNORECASE)
+# A declaration line may open with markdown: emphasis, quote, heading, bullet or a
+# numbered item ("## Level: L1", "1. Level: L1", "• router: no match").
+_LINE_OPEN = r"^[ \t>*_`#+•-]*(?:\d+[.)][ \t*_`]*)?"
+_LEVEL_WORD = r"(?:level|livello|niveau|nivel|stufe)\b[ \t*_`:·—–-]*(?:è[ \t]+)?"
+# ...and only on a line that opens with `router` or with a level (`L2`, `Spike`): a
+# verdict quoted inside a sentence is not one.
+_VERDICT_LINE_RE = re.compile(
+    _LINE_OPEN + r"(?:router\b|" + _LEVEL_WORD + r"(?:(?:research[ \t]+)?spike|[A-Z][123])\b)", re.IGNORECASE)
 _VERDICT_NONE_RE = re.compile(r"[\s`*_\"'(]*(no match|absent)", re.IGNORECASE)
-_VERDICT_TRIVIAL_RE = re.compile(r"\blevel[\s*_`]*:[\s`*_]*[A-Z]1\b", re.IGNORECASE)
+# A level is DECLARED by a line that opens with the level word, in the form Rule
+# Zero prescribes -- level 1 alone, 2/3 with `router` on the same line -- so a level
+# quoted inside a sentence is not one. The letter is the lens's own (`L1`, `E1`):
+# groups are (letter, "1" or "", "2"/"3" or "").
+_DECLARATION_RE = re.compile(
+    _LINE_OPEN + _LEVEL_WORD +
+    r"([A-Z])(?:(1)\b|([23])\b(?=[^\n]*\brouter\b))", re.IGNORECASE | re.MULTILINE)
 _GUIDE_NAME_RE = re.compile(r"GUIDE_[A-Za-z0-9_-]+\.md")
 
 
@@ -2545,7 +2649,7 @@ def transcript_facts(path):
 
     Returns {"assistant": entries parsed, "sidechain": a subagent's own transcript
     (Claude Code marks every entry of one `isSidechain`), "declared": a router verdict seen,
-    "trivial": a `Level: X1` seen, "named": guides the verdicts name,
+    "trivial": a level-1 declaration seen (`Level: L1`, `E1`), "named": guides the verdicts name,
     "read": guide names that appeared in a non-edit tool's input}."""
     facts = {"assistant": 0, "sidechain": False, "declared": False, "trivial": False,
              "named": set(), "read": set()}
@@ -2574,10 +2678,11 @@ def transcript_facts(path):
                         continue
                     if block.get("type") == "text":
                         for line in str(block.get("text") or "").splitlines():
-                            if _VERDICT_TRIVIAL_RE.search(line):
+                            d = _DECLARATION_RE.match(line)
+                            if d and d.group(2):
                                 facts["trivial"] = True
                             m = _VERDICT_ROUTER_RE.search(line)
-                            if m:
+                            if m and (d or _VERDICT_LINE_RE.match(line)):
                                 facts["declared"] = True
                                 if not _VERDICT_NONE_RE.match(m.group(1)):
                                     facts["named"].update(_GUIDE_NAME_RE.findall(m.group(1)))
@@ -2590,15 +2695,19 @@ def transcript_facts(path):
     return facts
 
 
-def verdict_reason(payload, root):
-    """The refusal line for this edit event, or None when the edit may proceed."""
+def verdict_reason(payload, root=None, docs_name=None):
+    """The refusal line for this edit event, or None when the edit may proceed.
+    Without a root, the project is the one holding the edited file (hook_project)."""
     if payload.get("tool_name") not in VERDICT_EDIT_TOOLS or payload.get("agent_id"):
         return None
     tool_input = payload.get("tool_input") or {}
     target = tool_input.get("file_path") or tool_input.get("notebook_path")
     transcript = payload.get("transcript_path")
-    if not target or not transcript:
+    if not isinstance(target, str) or not target or not transcript:
         return None
+    root = hook_project(target, root, docs_name)
+    if root is None:
+        return None  # two docs roots side by side: cannot tell which governs
     try:
         Path(target).resolve().relative_to(root)
     except (ValueError, OSError):
@@ -2636,8 +2745,8 @@ def cmd_verdict(args):
         payload = read_hook_payload()
         if payload is None:
             return 0
-        root = Path(args.root).resolve() if args.root else find_project_root()
-        reason = verdict_reason(payload, root)
+        root = Path(args.root).resolve() if args.root else None
+        reason = verdict_reason(payload, root, getattr(args, "docs_dir", None))
         if reason:
             print(json.dumps({"hookSpecificOutput": {
                 "hookEventName": "PreToolUse",
@@ -2648,6 +2757,456 @@ def cmd_verdict(args):
     return 0
 
 
+# -------------------------------------------------------------- constraints
+# F-085: the constraint reader. It reads what an ANALYSIS already states in
+# extractable form -- id'd use cases, spec items and threats, and the rows of
+# the `### Preservation constraints` table -- and binds each to the files it
+# names. It names no feature and computes nothing: no count, rank or marker
+# reaches the output, and every view ends with CONSTRAINTS_SENTENCE naming what
+# it could not extract, so a short view never reads as a complete one.
+
+CONSTRAINT_SECTIONS = (("## Use Cases",), ("## Functional Spec",), SECURITY_SECTION)
+INTERFACE_SECTION = ("## Interface Contract",)
+IMPACT_SECTION = ANALYSIS_SECTIONS[2]
+PRESERVATION_HEADING = "### Preservation constraints"
+NO_SYMBOL_LINE = "No existing symbol changed."
+CONSTRAINTS_SENTENCE = ("This view shows only the constraints written in extractable "
+                        "form and never replaces the ANALYSIS")
+CONSTRAINT_LINE_MAX = 300
+
+_ITEM_RE = re.compile(r"^\s*([-*+]\s+|#{3,4}\s+|\|\s*)(?:\*\*|__)?(?:UC|FS|T)\d+\b")
+_P_ROW_RE = re.compile(r"^\|\s*(?:\*\*)?(P\d+)\b")
+_ITEM_ID_RE = re.compile(r"(UC|FS|T)\d+")
+_CITE_RE = re.compile(r"\b(UC|FS|T)(\d+)(?:\s*[–-]\s*(?:UC|FS|T)?(\d+))?\b")
+_BACKTICK_RE = re.compile(r"`([^`\n]+)`")
+_PATH_TOKEN_RE = re.compile(r"^[A-Za-z0-9_.\-/]+(?:::[A-Za-z0-9_.]+)?$")
+_PATH_EXT_RE = re.compile(r"[^./]\.[A-Za-z0-9]+$")
+_SENTENCE_END_RE = re.compile(r"[.!?](?=\s|$)")
+_CELL_SPLIT_RE = re.compile(r"(?<!\\)\|")
+_CONTROL_RE = re.compile(r"[\x00-\x08\x0b-\x1f\x7f]")
+
+
+def _norm_rel(path):
+    """Repository-relative, forward slashes, case-folded where the filesystem is."""
+    p = path.replace("\\", "/")
+    while p.startswith("./"):
+        p = p[2:]
+    return p.casefold() if os.name == "nt" else p
+
+
+def _path_tokens(text, need_slash):
+    """The backticked file paths in `text`; `path::symbol` yields its path. An elided
+    (`...`), globbed, placeholder or parent-relative path binds nothing; in prose
+    (`need_slash`) a bare file name is a mention, not a binding."""
+    out = set()
+    for token in _BACKTICK_RE.findall(text or ""):
+        t = token.strip()
+        if "..." in t or "*" in t or t.startswith("/") or not _PATH_TOKEN_RE.match(t):
+            continue
+        path = t.split("::", 1)[0]
+        while path.startswith("./"):
+            path = path[2:]
+        if ".." in path.split("/") or not _PATH_EXT_RE.search(path):
+            continue
+        if need_slash and "/" not in path:
+            continue
+        out.add(_norm_rel(path))
+    return out
+
+
+def _first_sentence(text):
+    """Up to the first sentence end outside a backticked span (so `a.py` never ends
+    one); a bold title such as `**FS1 Ids.**` ends nothing either."""
+    masked = _BACKTICK_RE.sub(lambda m: "`" + "x" * len(m.group(1)) + "`", text)
+    m = _SENTENCE_END_RE.search(masked)
+    return text[:m.end()] if m else text
+
+
+def _cells(row):
+    return [c.strip() for c in _CELL_SPLIT_RE.split(row.strip().strip("|"))]
+
+
+def _cited_ids(text):
+    """Ids cited in `text`, a range such as `FS3–FS7` expanded."""
+    out = set()
+    for prefix, start, end in _CITE_RE.findall(text or ""):
+        a = int(start)
+        b = int(end) if end else a
+        if b < a or b - a > 50:
+            b = a
+        out.update(f"{prefix}{n}" for n in range(a, b + 1))
+    return out
+
+
+def parse_constraints(text):
+    """Every constraint `text` states in extractable form, in document order: a dict
+    with `id`, `kind` (`item` or `P`), `section` (its `## ` heading), `line`
+    (1-based), `statement`, `bindings` (normalized paths), `evidence` and
+    `released` (a P row's release reference, or None)."""
+    lines = (text or "").splitlines()
+    items, impact_rows = [], []
+    section, extracted, impact, preservation = None, False, False, False
+    for n, line in enumerate(lines):
+        if line.startswith("## "):
+            section = line.strip()
+            extracted = any(line.startswith(a) for s in CONSTRAINT_SECTIONS for a in s)
+            impact = any(line.startswith(a) for a in IMPACT_SECTION)
+            preservation = False
+            continue
+        if impact:
+            if line.startswith("### "):
+                preservation = line.strip().lower() == PRESERVATION_HEADING.lower()
+                continue
+            if not line.lstrip().startswith("|"):
+                continue
+            cells = _cells(line)
+            if preservation:
+                m = _P_ROW_RE.match(line.strip())
+                if m and len(cells) >= 5:
+                    must = cells[3]
+                    released = None
+                    if must.startswith("RELEASED (") and ")" in must:
+                        released = must[len("RELEASED ("):must.index(")")]
+                    items.append({"id": m.group(1), "kind": "P", "section": section,
+                                  "line": n + 1, "statement": must,
+                                  "bindings": _path_tokens(cells[1], False),
+                                  "evidence": cells[4], "released": released})
+            elif cells:
+                paths = _path_tokens(cells[0], False)
+                if paths:
+                    impact_rows.append((paths, _cited_ids(" | ".join(cells[1:]))))
+            continue
+        if not extracted:
+            continue
+        m = _ITEM_RE.match(line)
+        if not m:
+            continue
+        marker = m.group(1).strip()
+        body = []
+        if not marker.startswith("|"):
+            for nxt in lines[n + 1:]:
+                if nxt.startswith("#") or _ITEM_RE.match(nxt):
+                    break
+                if marker.startswith("#"):
+                    if nxt.strip():
+                        body.append(nxt.strip())
+                elif nxt.strip() and nxt[:1].isspace():
+                    body.append(nxt.strip())
+                else:
+                    break
+        if marker.startswith("|"):
+            statement = _first_sentence(" | ".join(_cells(line)))
+            whole = line
+        elif marker.startswith("#"):
+            title = line.lstrip("#").strip()
+            rest = " ".join(body)
+            statement = title + (" — " + _first_sentence(rest) if rest else "")
+            whole = " ".join([line] + body)
+        else:
+            joined = " ".join([line.strip()[len(marker):].strip()] + body)
+            statement = _first_sentence(joined)
+            whole = joined
+        items.append({"id": _ITEM_ID_RE.search(line).group(0), "kind": "item",
+                      "section": section, "line": n + 1, "statement": statement,
+                      "bindings": _path_tokens(whole, True), "evidence": None,
+                      "released": None})
+    for paths, ids in impact_rows:
+        for c in items:
+            if c["kind"] == "item" and c["id"] in ids:
+                c["bindings"] |= paths
+    return items
+
+
+def has_preservation_record(impact_body):
+    """True when an Impact body holds the preservation table or the no-symbol line."""
+    return any(b.strip().lower() == PRESERVATION_HEADING.lower() or b.strip() == NO_SYMBOL_LINE
+               for b in (impact_body or "").splitlines())
+
+
+def unread_sections(text, items=None):
+    """The `## ` headings the view could not extract, in document order: the
+    Interface Contract (its items carry no id), an extracted section holding prose
+    but no id'd item, and an Impact with neither the preservation table nor the
+    no-symbol line."""
+    items = parse_constraints(text) if items is None else items
+    homes = {c["section"] for c in items if c["kind"] == "item"}
+    lines = (text or "").splitlines()
+    names = []
+    for i, line in enumerate(lines):
+        if not line.startswith("## "):
+            continue
+        body = []
+        for nxt in lines[i + 1:]:
+            if nxt.startswith("## "):
+                break
+            body.append(nxt)
+        heading = line.strip()
+        if any(line.startswith(a) for a in INTERFACE_SECTION):
+            names.append(heading)
+        elif any(line.startswith(a) for s in CONSTRAINT_SECTIONS for a in s):
+            if any(b.strip() for b in body) and heading not in homes:
+                names.append(heading)
+        elif any(line.startswith(a) for a in IMPACT_SECTION):
+            if not has_preservation_record("\n".join(body)):
+                names.append(heading)
+    return names
+
+
+def constraints_sentence(names):
+    if not names:
+        return CONSTRAINTS_SENTENCE + "."
+    return CONSTRAINTS_SENTENCE + "; read in full: " + ", ".join(f"`{n}`" for n in names) + "."
+
+
+def _clip(line):
+    line = _CONTROL_RE.sub("", line)
+    return line if len(line) <= CONSTRAINT_LINE_MAX else line[:CONSTRAINT_LINE_MAX - 1] + "…"
+
+
+def constraint_lines(home, items, grouped):
+    """FS4's lines: `ID — statement — home:line`, a P row followed by its evidence;
+    `grouped` puts each home heading before its first item."""
+    out, current = [], None
+    for c in items:
+        if grouped and c["section"] != current:
+            current = c["section"]
+            out.append(_clip(current))
+        out.append(_clip(f"{c['id']} — {c['statement']} — {home}:{c['line']}"))
+        if c["kind"] == "P" and c["evidence"]:
+            out.append(_clip(f"    evidence: {c['evidence']}"))
+    return out
+
+
+def unit_constraints(root, unit):
+    """[(path, meta, items, unread)] for the ANALYSIS files of `unit` -- an id such
+    as F-001, or a file name with or without `.md`; [] when none matches."""
+    key = str(unit or "").strip()
+    name = key if key.endswith(".md") else key + ".md"
+    out = []
+    for p, meta, text in list_analyses(root):
+        m = UNIT_ID_RE.search(str(meta.get("id") or ""))
+        if p.name == name or (m and m.group(1) == key):
+            items = parse_constraints(text)
+            out.append((p, meta, items, unread_sections(text, items)))
+    return out
+
+
+def project_relative(root, path):
+    """`path` relative to `root`, normalized as bindings are, or None outside it."""
+    raw = str(path or "").replace("\\", "/")
+    if not raw:
+        return None
+    p = Path(raw)
+    if not p.is_absolute():
+        p = Path.cwd() / p
+    try:
+        rel = p.resolve().relative_to(Path(root).resolve())
+    except (ValueError, OSError):
+        return None
+    return _norm_rel(rel.as_posix())
+
+
+def open_code_units(root):
+    """[(path, meta, text)] for the tree's open L3 units of the code domain. Open
+    units come from `_open_units`, unchanged (P1)."""
+    if not ai_path(root).is_dir():
+        return []
+    open_names = {n for names in _open_units(root).values() for n in names}
+    if not open_names:
+        return []
+    default = project_default_domain(root)
+    return [(p, meta, text) for p, meta, text in list_analyses(root)
+            if p.name in open_names
+            and str(meta.get("level", "")).upper() == "L3"
+            and meta.get("status") in ("PLANNED", "IN_PROGRESS")
+            and resolve_domain(meta, default)[0] == "code"]
+
+
+def file_constraints(root, path):
+    """[(path, meta, bound items, unread)] for each open L3 unit of the code domain
+    with an unreleased constraint bound to `path`."""
+    rel = project_relative(root, path)
+    if rel is None:
+        return []
+    out = []
+    for p, meta, text in open_code_units(root):
+        items = parse_constraints(text)
+        bound = [c for c in items if not c["released"] and rel in c["bindings"]]
+        if bound:
+            out.append((p, meta, bound, unread_sections(text, items)))
+    return out
+
+
+# The recall hook (FS6). It informs, never decides: its JSON carries no
+# `permissionDecision`, so the user's permission flow is the one without it
+# (P6). A level is read with the verdict hook's `_DECLARATION_RE`; only the code
+# lens's `L` levels count here.
+CONSTRAINTS_HOOK_LINES = 15
+_WORK_TOOLS = VERDICT_EDIT_TOOLS + ("Read",)
+
+
+def transcript_work(path):
+    """What the session transcript shows about the work, or None when it cannot be
+    read within the verdict hook's bounds: {"assistant": entries parsed,
+    "sidechain": a subagent's transcript, "level": the last declared level ("1",
+    "2", "3") or None, "touched": normalized absolute paths this session read or
+    wrote}."""
+    work = {"assistant": 0, "sidechain": False, "level": None, "touched": set()}
+    try:
+        p = Path(path)
+        if not p.is_file() or p.stat().st_size > VERDICT_MAX_BYTES:
+            return None
+        with p.open("rb") as fh:
+            for raw in fh:
+                if len(raw) > VERDICT_LINE_MAX or b'"assistant"' not in raw:
+                    continue
+                try:
+                    entry = json.loads(raw.decode("utf-8", errors="replace"))
+                except ValueError:
+                    continue
+                if not isinstance(entry, dict) or entry.get("type") != "assistant":
+                    continue
+                content = (entry.get("message") or {}).get("content")
+                if not isinstance(content, list):
+                    continue
+                work["assistant"] += 1
+                if entry.get("isSidechain") is True:
+                    work["sidechain"] = True
+                for block in content:
+                    if not isinstance(block, dict):
+                        continue
+                    if block.get("type") == "text":
+                        for letter, one, other in _DECLARATION_RE.findall(
+                                str(block.get("text") or "")):
+                            if letter.upper() == "L":
+                                work["level"] = one or other
+                    elif block.get("type") == "tool_use" and block.get("name") in _WORK_TOOLS:
+                        inp = block.get("input") or {}
+                        target = inp.get("file_path") or inp.get("notebook_path")
+                        if isinstance(target, str) and target:
+                            try:
+                                work["touched"].add(_norm_rel(Path(target).resolve().as_posix()))
+                            except (OSError, ValueError):
+                                pass
+    except (OSError, ValueError, TypeError, AttributeError):
+        return None
+    return work
+
+
+def _hook_new_text(tool_input):
+    """The text an edit is about to write: Edit, Write, MultiEdit, NotebookEdit."""
+    parts = [tool_input.get(k) for k in ("new_string", "content", "new_source")]
+    for e in tool_input.get("edits") or []:
+        if isinstance(e, dict):
+            parts.append(e.get("new_string"))
+    return "\n".join(x for x in parts if isinstance(x, str))
+
+
+def _unit_documents(root, p):
+    """Normalized absolute paths of a unit's ANALYSIS, request records and handoff:
+    reading or writing any of them is working on the unit."""
+    slug = p.stem[len("ANALYSIS_"):]
+    docs = {p, ai_path(root, "audit", f"HANDOFF_{slug}.md")}
+    for r in requests_naming(root, p.name):
+        docs.add(r)
+        docs.add(ai_path(root, "audit", f"HANDOFF_{r.stem[len('REQUEST_'):]}.md"))
+    return {_norm_rel(d.resolve().as_posix()) for d in docs}
+
+
+def constraints_hook_context(payload, root=None, docs_name=None):
+    """The context to recall before this edit, or None (FS6): an edit tool, outside
+    a subagent, on a file of a project whose open L3 code unit binds it (or the
+    unit's own ANALYSIS, about to name a path a P row binds -- UC6), by a session
+    that worked on that unit and last declared L3."""
+    if payload.get("tool_name") not in VERDICT_EDIT_TOOLS or payload.get("agent_id"):
+        return None
+    tool_input = payload.get("tool_input") or {}
+    target = tool_input.get("file_path") or tool_input.get("notebook_path")
+    transcript = payload.get("transcript_path")
+    if not isinstance(target, str) or not target or not transcript:
+        return None
+    root = hook_project(target, root, docs_name)
+    if root is None or not ai_path(root, "solutions").is_dir():
+        return None
+    found = file_constraints(root, target)
+    rel = project_relative(root, target)
+    named = _path_tokens(_hook_new_text(tool_input), False)
+    if named and rel and rel.startswith(_norm_rel(f"{docs_dir()}/solutions/ANALYSIS_")):
+        for p, meta, text in open_code_units(root):
+            if _norm_rel(f"{docs_dir()}/solutions/{p.name}") != rel:
+                continue
+            items = parse_constraints(text)
+            bound = [c for c in items if c["kind"] == "P"
+                     and not c["released"] and c["bindings"] & named]
+            if bound and not any(f[0] == p for f in found):
+                found.append((p, meta, bound, unread_sections(text, items)))
+    if not found:
+        return None
+    work = transcript_work(transcript)
+    if not work or not work["assistant"] or work["sidechain"] or work["level"] != "3":
+        return None
+    # One budget for the whole recall, whatever the number of units; a P line and
+    # its evidence line are kept together or left out together.
+    out, budget = [], CONSTRAINTS_HOOK_LINES
+    for p, meta, items, unread in found:
+        if not (_unit_documents(root, p) & work["touched"]):
+            continue
+        home = f"solutions/{p.name}"
+        unit = meta.get("id") or p.stem
+        out.append(_clip(f"[sdlc constraints] {unit} — {home}"))
+        shown = 0
+        for c in items:
+            chunk = constraint_lines(home, [c], False)
+            if len(chunk) > budget:
+                break
+            out.extend(chunk)
+            budget -= len(chunk)
+            shown += 1
+        if shown < len(items):
+            out.append(_clip(f"More: sdlc_check.py constraints --unit {unit}"))
+        out.append(_clip(constraints_sentence(unread)))
+    return "\n".join(out) if out else None
+
+
+def cmd_constraints_hook(args):
+    """PreToolUse hook: print a context-only JSON or nothing. Always 0 -- exit 2
+    would block the edit, and the wired command adds `; exit 0` for validators
+    that cannot run this at all (T2)."""
+    try:
+        payload = read_hook_payload()
+        if payload is None:
+            return 0
+        root = Path(args.root).resolve() if args.root else None
+        context = constraints_hook_context(payload, root, getattr(args, "docs_dir", None))
+        if context:
+            print(json.dumps({"hookSpecificOutput": {
+                "hookEventName": "PreToolUse",
+                "additionalContext": context}}, ensure_ascii=False))
+    except Exception:
+        pass
+    return 0
+
+
+def cmd_constraints(root, args):
+    if args.unit:
+        found = unit_constraints(root, args.unit)
+        if not found:
+            print(f"[ERROR] unknown unit '{args.unit}': give an id such as F-001 "
+                  "or an ANALYSIS file name")
+            return 1
+        groups = [(p, meta, items, unread, True) for p, meta, items, unread in found]
+    else:
+        groups = [(p, meta, items, unread, False)
+                  for p, meta, items, unread in file_constraints(root, args.file)]
+    for p, meta, items, unread, grouped in groups:
+        home = f"solutions/{p.name}"
+        print(_clip(f"{meta.get('id') or p.stem} — {home}"))
+        for line in constraint_lines(home, items, grouped):
+            print(line)
+        print(_clip(constraints_sentence(unread)))
+    return 0
+
+
 # --------------------------------------------------------------------- plan
 # Subagent Execution (Feature A). Zero-execution surface: this section and
 # everything it calls MUST NOT spawn a process (no subprocess/os.system/eval/
@@ -2977,6 +3536,10 @@ def cmd_benefit(root):
     rows, unparsed = parse_review_log(read_text(log))
     not_due = [r for r in rows if _is_not_due(r["verdict"])]
     rows = [r for r in rows if not _is_not_due(r["verdict"])]
+    # F-085 FS10: a `post-merge` row is the owner's report of a defect that got
+    # past every review -- not a review, so it stays out of every review figure.
+    post_merge = [r for r in rows if r["tier"].lower().startswith("post-merge")]
+    rows = [r for r in rows if not r["tier"].lower().startswith("post-merge")]
     # `tier` carries the MOMENT in Standalone (design / closure) and the
     # reviewer WEIGHT in Hybrid (deep / light / code / guide / vision). A
     # Hybrid row is a real review whose moment this column does not state, so
@@ -3001,11 +3564,14 @@ def cmd_benefit(root):
                     unstated_code += n
     classified = moments["design"] + moments["closure"]
     print("rows parsed: %d   rows unparsed: %d%s"
-          % (len(rows) + len(not_due), len(unparsed),
+          % (len(rows) + len(not_due) + len(post_merge), len(unparsed),
              ("  -> " + "; ".join("line %d: %s" % u for u in unparsed[:5]))
              if unparsed else ""))
     print("reviews ruled not due (logged, counted in no figure below): %d"
           % len(not_due))
+    if post_merge:
+        print("defects reported after merge (tier post-merge, not reviews, "
+              "counted in no figure below): %d" % len(post_merge))
     print("reviews with a stated moment: %d   moment not stated by `tier`: %d%s"
           % (len(classified), sum(unstated.values()),
              ("  (" + ", ".join("%s x%d" % (t, n) for t, n
@@ -3498,6 +4064,16 @@ def main(argv=None):
                              "or an unread named guide (fail-open, always exit 0)")
     vp.add_argument("--hook", action="store_true", help="read the hook JSON payload from stdin")
 
+    cp = sub.add_parser("constraints", parents=[common],
+                        help="print the constraints an ANALYSIS states in extractable "
+                             "form: a unit's view, or those bound to a file")
+    cg = cp.add_mutually_exclusive_group(required=True)
+    cg.add_argument("--unit", help="unit id (e.g. F-001) or ANALYSIS file name")
+    cg.add_argument("--file", help="file path: constraints of the open L3 code units bound to it")
+    cg.add_argument("--hook", action="store_true",
+                    help="PreToolUse hook: read the payload from stdin, print context only "
+                         "(fail-open, always exit 0)")
+
     sub.add_parser("benefit", parents=[common],
                    help="report what the review gates caught (and what the "
                         "doctrine costs to read) -- a report, never a gate: "
@@ -3521,6 +4097,16 @@ def main(argv=None):
 
     args = ap.parse_args(argv)
 
+    # F-085: the edit hooks resolve their root and docs root from the edited file
+    # (the hook runs in whatever directory the session moved to), so they are
+    # dispatched before the working-directory resolution below.
+    if args.cmd == "constraints" and args.hook:
+        return cmd_constraints_hook(args)
+    if args.cmd == "verdict":
+        return cmd_verdict(args)
+    if args.cmd == "gate":
+        return cmd_gate(args)
+
     # Resolve the documentation root ONCE, before any command runs, so every
     # surface -- paths, messages, generated headers, the gate's exempt prefix --
     # names the same thing.
@@ -3539,19 +4125,11 @@ def main(argv=None):
             # and says so rather than exiting non-zero.
             print(f"[note] {exc}")
             discovered, name = None, DEFAULT_DOCS_DIR
-        elif args.cmd == "verdict":
-            # F-076: a PreToolUse check that cannot tell which root governs refuses
-            # nothing and says nothing -- its stdout is read as the hook's decision.
-            return 0
         else:
             print(f"[ERROR] {exc}")
             return 1
     set_docs_dir(name)
 
-    if args.cmd == "gate":
-        return cmd_gate(args)
-    if args.cmd == "verdict":
-        return cmd_verdict(args)
     if args.cmd == "orient":
         return cmd_orient(args)
     if args.cmd == "remind":
@@ -3570,6 +4148,8 @@ def main(argv=None):
         return cmd_mark(root, args.paths, args.note)
     if args.cmd == "benefit":
         return cmd_benefit(root)
+    if args.cmd == "constraints":
+        return cmd_constraints(root, args)
     if args.cmd == "migrate":
         return cmd_migrate(root, args)
     if args.cmd == "plan":