pi-dev-team 0.2.0

package/scripts/lib/session_log/classify.py

@@ -0,0 +1,231 @@
+"""Text/name classification vocabulary shared by both session-log
+extractors (issue #2043, epic #2040) — the "shared classification core" ADR
+0036 deliberately left as an open question, decided here.
+
+ADR 0036 / issue #2043's own symbol list names 14 symbols. Two of them —
+`_is_transcript_path` / `_is_subagent_transcript` — already landed in
+`session_log.discovery` in slice #2042, because they are used only by
+enumeration/path logic that belongs there; this module does not duplicate
+them (grouping them under classify.py in the ADR's original text predates
+that split). `_AGENT_TRANSCRIPT_RE` is the same story: it's used only inside
+`discovery.is_transcript_path`, so it also lives in `discovery.py`, not
+here. That leaves 12 symbols for this module, reconciled below.
+
+Per-symbol reconciliation (measured by diffing the two forked copies
+directly against the live tree, not from memory):
+
+| symbol                    | similarity | chosen behavior / source                                   |
+|----------------------------|-----------|--------------------------------------------------------------|
+| `_VERIFY_RE`               | 1.00      | byte-identical constant — moved verbatim                     |
+| `_CORRECTION_RE`           | 1.00      | byte-identical constant — moved verbatim                     |
+| `_PERMISSION_RE`           | 1.00      | byte-identical constant — moved verbatim                     |
+| `_OLDSTRING_RE`            | 1.00      | byte-identical constant — moved verbatim                     |
+| `_COMMIT_RE`/`_BYPASS_RE`  | 1.00      | ADR 0036 names these two regexes; neither exists as a literal|
+|                            |           | symbol in the current tree (#2036 replaced a regex-based     |
+|                            |           | commit/bypass detector with an argv-shaped one — the same    |
+|                            |           | staleness class as the `_is_transcript_path` note above). The|
+|                            |           | modern equivalent — `_statement_break_newlines`,              |
+|                            |           | `_bash_segments`, `_is_git_commit_argv`,                      |
+|                            |           | `_GIT_GLOBAL_OPTS_WITH_ARG`, `_COMMIT_BYPASS_TOKENS` — is     |
+|                            |           | byte-identical between the two copies (confirmed by direct   |
+|                            |           | diff) and lands here instead, under its current names.       |
+| `_strip_ns`                | ~1.00     | logic identical; session_extract.py's docstring kept (more   |
+|                            |           | detailed — extract_session_report.py's copy had none)        |
+| `_text_of`                 | 0.98      | logic identical; docstring wording merged (session_extract's |
+|                            |           | "digest" -> generic "output", correct for both callers)      |
+| `_safe_name`               | 1.00      | byte-identical — moved verbatim, with its `_SAFE_NAME_RE`/    |
+|                            |           | `_UNSAFE_NAME` dependencies                                   |
+| `_basename`                | logic     | **the highest-stakes symbol**: ADR 0036 / issue #2043 flags   |
+|                            | 1.00,     | this as carrying #1991's Windows-path privacy fix that the    |
+|                            | docstring | #1994 port allegedly dropped. Direct diff of the CURRENT tree |
+|                            | differs   | (not git archaeology) shows both copies already compute      |
+|                            |           | `re.split(r"[\\/]", path_str)[-1] or path_str` — identical    |
+|                            |           | logic, byte-identical behavior. The historical gap was closed |
+|                            |           | in a later commit (subagent-transcript-count fixes #1995/     |
+|                            |           | #2017) before this refactor started. session_extract.py's     |
+|                            |           | docstring (which names the #1994 history) is kept as the      |
+|                            |           | canonical one; pinned by the corpus's Windows-path fixture    |
+|                            |           | (`C:\\Users\\SENTINEL_USER\\...` in                            |
+|                            |           | `tests/fixtures/session_log/projects/.../99999999….jsonl`)    |
+|                            |           | via the golden harness AND this module's own unit test.       |
+| `_AGENT_TRANSCRIPT_RE`     | n/a       | already unified in `discovery.py` (#2042) — not duplicated    |
+|                            |           | here; see module docstring above                              |
+| `_HARNESS_ATTRIBUTIONS`    | 1.00      | byte-identical constant — moved verbatim                      |
+
+Golden diffs: none. This slice is behavior-preserving, same as #2042 — every
+moved symbol is either byte-identical or logic-identical between the two
+forked copies, so the golden harness stays byte-for-byte unchanged (verified
+below in the test suite).
+"""
+
+from __future__ import annotations
+
+import re
+import shlex
+
+# --- verification / classification vocabularies (counted, never emitted) ---
+VERIFY_RE = re.compile(
+    r"\b(npm (run )?(test|lint|build)|pytest|bats|eslint|tsc|go test|cargo "
+    r"(test|build)|mvn|gradle|make( |$)|vitest|jest|ruff|mypy|shellcheck)\b"
+)
+CORRECTION_RE = re.compile(
+    r"\b(no|actually|revert|undo|not what i (asked|wanted)|that's wrong|"
+    r"that is wrong|wrong|stop|don't|do not)\b"
+)
+PERMISSION_RE = re.compile(r"permission|denied|not allowed|blocked by", re.IGNORECASE)
+OLDSTRING_RE = re.compile(r"old_string|not found|no match|string to replace", re.IGNORECASE)
+
+# Gate signal (#111): a `git commit`, and whether it bypassed the pre-commit
+# review gate (--no-verify, or a bare -n). #2036: the review-corroboration
+# gate itself moved from `git commit` time to `gh pr create` time in #1886 —
+# `hooks/telemetry.py` now keys its bypass signal off `PR_GATE_BYPASS_REASON`
+# on a `gh pr create` invocation, an unrelated mechanism this no longer
+# mirrors. This signal stays commit-time on purpose: it measures how often a
+# commit itself skips local review, which is a real and different question
+# from whether a PR was opened without one.
+#
+# Detection is argv-shaped, not a substring search over the whole command —
+# see bash_segments()/is_git_commit_argv() below. A prior version searched
+# `\bgit\s+commit\b` and `--no-verify|(^|\s)-n(\s|$)` against the raw string,
+# which matched inside unrelated flags in a compound command (`grep -n`,
+# `ls -n`) and even inside an unrelated string (`echo "git commit"`).
+GIT_GLOBAL_OPTS_WITH_ARG = {"-C", "-c", "--git-dir", "--work-tree", "--namespace"}
+COMMIT_BYPASS_TOKENS = {"--no-verify", "-n"}
+
+# Every string that becomes a digest/report KEY passes safe_name: these
+# arrive from transcript files this code does not author, and the privacy
+# contract of both extractors is names-only.
+SAFE_NAME_RE = re.compile(r"^[A-Za-z0-9._:-]{1,64}$")
+UNSAFE_NAME = "other"
+
+# `attributionAgent` values naming a harness ROLE rather than an agent. Every
+# real Workflow-dispatched transcript carries "workflow-subagent"; unfiltered
+# they become phantom agents while the agent that actually ran stays in
+# never_observed_agents — the #1990 symptom itself.
+HARNESS_ATTRIBUTIONS = frozenset({"workflow-subagent", "claude"})
+
+
+def statement_break_newlines(cmd: str) -> str:
+    """Replace a bare (unquoted) newline with ';' so a tokenizer sees a
+    statement boundary there — a newline embedded inside a quoted argument
+    (e.g. a multi-line commit message) is left untouched."""
+    out = []
+    in_single = in_double = False
+    i, n = 0, len(cmd)
+    while i < n:
+        ch = cmd[i]
+        if ch == "'" and not in_double:
+            in_single = not in_single
+            out.append(ch)
+        elif ch == '"' and not in_single:
+            in_double = not in_double
+            out.append(ch)
+        elif ch == "\\" and in_double and i + 1 < n:
+            out.append(ch)
+            out.append(cmd[i + 1])
+            i += 1
+        elif ch == "\n" and not in_single and not in_double:
+            out.append(";")
+        else:
+            out.append(ch)
+        i += 1
+    return "".join(out)
+
+
+def bash_segments(cmd: str) -> list[list[str]]:
+    """Split `cmd` into argv-shaped segments at top-level shell operators
+    (&&, ||, ;, |, and bare newlines), respecting quoting throughout — a
+    quoted operator or newline inside a commit message never splits the
+    command, and a quoted flag never crosses a segment boundary."""
+    lex = shlex.shlex(statement_break_newlines(cmd), posix=True, punctuation_chars="&|;")
+    lex.whitespace_split = True
+    try:
+        tokens = list(lex)
+    except ValueError:
+        # Malformed shell syntax (e.g. an unbalanced quote) — cannot be
+        # segmented reliably. Fall back to a single opaque whitespace-split
+        # segment rather than losing the signal outright.
+        return [cmd.split()]
+    segments: list[list[str]] = []
+    current: list[str] = []
+    for tok in tokens:
+        if tok in ("&&", "||", ";", "|", "&"):
+            if current:
+                segments.append(current)
+            current = []
+        else:
+            current.append(tok)
+    if current:
+        segments.append(current)
+    return segments
+
+
+def is_git_commit_argv(tokens: list[str]) -> bool:
+    """True if `tokens` invokes `git ... commit ...` — walks past git's
+    global options (including ones taking a separate argument, e.g. `-C`)
+    to find the subcommand, so `git -C path commit` is recognized."""
+    if not tokens or tokens[0] != "git":
+        return False
+    i = 1
+    while i < len(tokens):
+        tok = tokens[i]
+        if tok in GIT_GLOBAL_OPTS_WITH_ARG:
+            i += 2
+            continue
+        if tok.startswith("-"):
+            i += 1
+            continue
+        return tok == "commit"
+    return False
+
+
+def strip_ns(name: str) -> str:
+    """Drop known plugin namespace prefixes so invoked names match the
+    registry (registry entries are bare dir/file stems). `dev-team:plan` ->
+    `plan`; `agentic-dev-team:plan` -> `plan`; other names pass through."""
+    for prefix in ("agentic-dev-team:", "dev-team:"):
+        if name.startswith(prefix):
+            return name[len(prefix) :]
+    return name
+
+
+def text_of(content) -> str:
+    """Flatten a message ``content`` (str or list of blocks) to plain text.
+    Used only for keyword CLASSIFICATION; never emitted into either
+    extractor's output."""
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        parts = []
+        for block in content:
+            if isinstance(block, dict):
+                if isinstance(block.get("text"), str):
+                    parts.append(block["text"])
+                elif isinstance(block.get("content"), str):
+                    parts.append(block["content"])
+        return " ".join(parts)
+    return ""
+
+
+def safe_name(value: str) -> str:
+    """Reduce an input-derived string to something safe to emit as a key."""
+    # fullmatch, not match: `$` also matches immediately BEFORE a single
+    # trailing newline, so `.match()` admitted "name\n" through the allowlist
+    # and split the key space (#1994 review).
+    return value if SAFE_NAME_RE.fullmatch(value) else UNSAFE_NAME
+
+
+def basename(path_str: str) -> str:
+    """Last component of a path recorded on ANY platform.
+
+    `os.path.basename` splits on `/` only, so a Windows-form path comes back
+    whole — an absolute path, username included, in a field both extractors'
+    docstrings promise is a basename. Reachable whenever Windows-written
+    transcripts are read under WSL, a devcontainer, or a bind-mounted
+    `~/.claude`. #1991 fixed this in the shipped extractor first; #1994's
+    port to session_extract.py initially left it behind (the same defect
+    class crossing the fork twice) but a later fix closed the gap — both
+    copies compute the same `re.split` before this module unified them (see
+    module docstring's reconciliation table).
+    """
+    return re.split(r"[\\/]", path_str)[-1] or path_str

package/scripts/lib/session_log/corrections.py

@@ -0,0 +1,194 @@
+"""Deterministic cause-data classification for correction turns (issue
+#2013, part of epic #2008).
+
+The corpus carries thousands of user corrections and no cause data: a
+correction is the most direct signal the harness did the wrong thing, and
+until now it was recorded as a bare count. This module attaches three
+closed-vocabulary labels to each correction turn `signals.
+detect_correction_turn` already detects:
+
+  what       what kind of output was corrected -- `WHAT_VALUES` below.
+  component  which component produced it -- `"main-loop"` or a specific
+             agent/skill name.
+  shape      what kind of correction it was -- `SHAPE_VALUES` below.
+
+Deterministic-first (CLAUDE.md's "deterministic tools over inference"
+rule, and this issue's own "must be cheap" constraint): every label comes
+from pattern-matching over tool-call shape and correction-turn keywords,
+the same style `classify.CORRECTION_RE` already uses to DETECT a
+correction turn in the first place. No model call is ever made here. When
+`shape` can't be resolved confidently, it's reported as `"ambiguous"`
+with `confidence: "low"` rather than guessed -- the inference share is a
+queryable statistic (`accuracy.correction_causes.ambiguous_share` in
+`session_report.py`), never hidden.
+
+Privacy: only the four labels below are ever emitted to a digest. The
+correction TEXT (`classify_shape`'s `text` argument) is read in memory
+only, exactly like `classify.CORRECTION_RE`'s own detection pass -- never
+written to output. See `redact.py`'s module docstring for the choke-point
+this stays inside; this module composes on top of it, it does not open a
+new privacy surface.
+"""
+
+from __future__ import annotations
+
+import re
+
+from . import classify
+from .signals import EDIT_TOOLS
+
+#: what-was-corrected vocabulary (issue #2013).
+WHAT_VALUES = (
+    "code-edit",
+    "plan",
+    "review-finding",
+    "tool-choice",
+    "factual-claim",
+    "other",
+)
+
+#: correction-shape vocabulary (issue #2013). "ambiguous" is the honest
+#: fallback when no shape pattern below matches -- see module docstring.
+SHAPE_VALUES = (
+    "reverted",
+    "redirected",
+    "narrowed-scope",
+    "flagged-wrong",
+    "not-what-asked",
+    "ambiguous",
+)
+
+#: `component` value when no skill/agent is the currently-active dispatch
+#: (`signals.accumulate_skill_agent_signals`'s `active["last"]`, `None`).
+MAIN_LOOP_LABEL = "main-loop"
+
+
+def is_review_agent_name(name: str | None) -> bool:
+    """Whether a (already namespace-stripped) agent name follows this
+    repo's own review-agent naming convention: `<domain>-review`,
+    `<domain>-reviewer` (`quality-reviewer`, `spec-reviewer`), or
+    `plan-review-<facet>` (`plan-review-acceptance`, ...). Checked against
+    every review agent under `plugins/dev-team/agents/` at the time this
+    was written -- a naming-convention check, not a registry lookup, so it
+    needs no registry threaded through the classifier."""
+    if not name:
+        return False
+    return name.endswith(("-review", "-reviewer")) or name.startswith("plan-review-")
+
+
+def new_context() -> dict:
+    """Per-thread rolling "what" state. `what` is `None` until the first
+    assistant turn is observed (`classify_correction` falls back to
+    `"other"` for a correction with no preceding assistant turn at all --
+    a real, if unusual, transcript shape, not a guess). Reset once per
+    transcript file, same lifecycle as `signals.new_thread()`."""
+    return {"what": None}
+
+
+def observe_assistant_turn(rec: dict, content) -> dict | None:
+    """Recompute the rolling "what" context from ONE assistant record.
+
+    Returns `None` for a non-assistant record -- the caller should keep
+    its existing context unchanged, since `detect_correction_turn` only
+    ever fires on a `"user"` record and "what" answers "what did the
+    IMMEDIATELY PRECEDING assistant turn do" (issue #2013's own framing).
+    This is why the result REPLACES the context wholesale rather than
+    updating it in place, unlike the sticky `active` skill/agent pointer
+    `component` is built from below: a later text-only turn must
+    overwrite an earlier tool call's classification, not merely
+    supplement it.
+    """
+    if rec.get("type") != "assistant":
+        return None
+    if not isinstance(content, list):
+        has_text = isinstance(content, str) and bool(content.strip())
+        return {"what": "factual-claim" if has_text else "other"}
+
+    candidates: set[str] = set()
+    saw_tool_use = False
+    for block in content:
+        if not isinstance(block, dict) or block.get("type") != "tool_use":
+            continue
+        saw_tool_use = True
+        name = block.get("name", "?")
+        inp = block.get("input", {}) if isinstance(block.get("input"), dict) else {}
+        if name in EDIT_TOOLS:
+            candidates.add("code-edit")
+        elif name == "Skill":
+            skill_name = classify.strip_ns(str(inp.get("skill") or inp.get("name") or ""))
+            if skill_name == "plan":
+                candidates.add("plan")
+        elif name in ("Agent", "Task"):
+            agent_name = classify.strip_ns(str(inp.get("subagent_type") or ""))
+            if is_review_agent_name(agent_name):
+                candidates.add("review-finding")
+        elif name == "Bash":
+            candidates.add("tool-choice")
+
+    if not saw_tool_use:
+        return {"what": "factual-claim"}
+    for label in ("code-edit", "plan", "review-finding", "tool-choice"):
+        if label in candidates:
+            return {"what": label}
+    return {"what": "other"}
+
+
+# Priority-ordered, most-specific-first: the FIRST pattern that matches the
+# correction turn's own (lowercased) text wins. Every alternative here is a
+# refinement of `classify.CORRECTION_RE`'s own keyword set (the same
+# keyword-matching approach that already detects a correction turn), not a
+# new detection mechanism -- a correction turn that matched CORRECTION_RE
+# only via its bare "no" alternative (no "wrong"/"actually"/"revert"/...
+# alongside it) matches none of these and correctly falls through to
+# "ambiguous": that's a real, non-trivial subset of correction turns whose
+# shape genuinely can't be told apart by keyword alone.
+_SHAPE_PATTERNS: tuple[tuple[str, re.Pattern], ...] = (
+    ("reverted", re.compile(r"\b(revert|undo|roll\s*back|put\s+(it\s+)?back)\b")),
+    ("not-what-asked", re.compile(r"not what i (asked|wanted|meant)")),
+    ("flagged-wrong", re.compile(r"\b(that'?s wrong|that is wrong|incorrect|wrong)\b")),
+    (
+        "narrowed-scope",
+        re.compile(
+            r"\b(just|only|too (much|broad|big)|narrow(er)?|smaller scope|"
+            r"don'?t need|no need)\b"
+        ),
+    ),
+    ("redirected", re.compile(r"\b(actually|instead|rather|stop|don'?t|do not)\b")),
+)
+
+
+def classify_shape(text: str) -> tuple[str, str]:
+    """Correction SHAPE from the correction turn's own text (read in
+    memory only -- see module docstring). Returns `(shape, confidence)`;
+    `confidence` is `"low"` exactly when `shape == "ambiguous"` -- shape is
+    the one genuinely fuzzy dimension of this classifier (`what` and
+    `component` are read off structural facts -- tool names, dispatch
+    state -- not inferred from text, so they carry no comparable
+    ambiguity)."""
+    lowered = text.lower()
+    for label, pattern in _SHAPE_PATTERNS:
+        if pattern.search(lowered):
+            return label, "high"
+    return "ambiguous", "low"
+
+
+def classify_correction(turn_context: dict, dispatch: tuple[str, str] | None, text: str) -> dict:
+    """The full cause-data record for one correction turn.
+
+    `turn_context`: the rolling "what" state (`new_context`/
+    `observe_assistant_turn`'s last non-`None` result).
+    `dispatch`: the currently-active `(kind, name)` skill/agent dispatch
+    (`signals.accumulate_skill_agent_signals`'s `active["last"]`), or
+    `None` when nothing has been dispatched yet in this thread.
+    `text`: the correction turn's own flattened text
+    (`classify.text_of(content)`) -- read in memory only, never returned.
+
+    Returns `{"what", "component", "shape", "confidence"}` -- the only
+    four values a caller should emit; never the raw text, dispatch name
+    provenance details, or tool-call sequence itself beyond what these
+    four labels already encode.
+    """
+    what = (turn_context or {}).get("what") or "other"
+    component = dispatch[1] if dispatch else MAIN_LOOP_LABEL
+    shape, confidence = classify_shape(text)
+    return {"what": what, "component": component, "shape": shape, "confidence": confidence}

package/scripts/lib/session_log/discovery.py

@@ -0,0 +1,108 @@
+"""Transcript path classification and enumeration (issue #2042, epic #2040).
+
+Answers one question: given a ``~/.claude/projects``-shaped tree, which
+``.jsonl`` files under it are transcripts this extraction pipeline reads, and
+which of those belong to a dispatched agent's own run rather than a
+main-thread session.
+
+Reconciliation (issue #2042):
+
+- ``is_transcript_path`` was already byte-identical between
+  ``scripts/session_extract.py`` and
+  ``plugins/dev-team/scripts/extract_session_report.py`` — moved verbatim.
+- ``is_subagent_transcript`` was semantically equivalent but structurally
+  divergent (0.22 similarity between the two copies). This module keeps the
+  shipped (``extract_session_report.py``) copy's shape: it factors out
+  ``relative_parts`` — the path's components below the root, with a
+  ``path.parts`` (not ``False``) fallback when the path isn't actually under
+  the root — and both original bodies computed exactly
+  ``"subagents" in <that>``, so behavior is unchanged.
+- ``_AGENT_TRANSCRIPT_RE`` is grouped under the classify.py 14-symbol list in
+  ADR 0036 / issue #2043, but it is used ONLY inside ``is_transcript_path``
+  above, which landed here in slice #2042 — so it lands here too rather than
+  being duplicated into classify.py. Issue #2043's commit body notes this
+  explicitly rather than silently deviating from the ADR's grouping.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+# Agent transcripts are named `agent-<id>.jsonl` (see is_transcript_path).
+AGENT_TRANSCRIPT_RE = re.compile(r"^agent-[0-9A-Za-z_-]{1,64}\.jsonl$")
+
+
+def relative_parts(root: Path, path: Path) -> tuple[str, ...]:
+    """The path's components BELOW `root`.
+
+    Every layout question here is about the tree under the root, so never ask
+    it of the absolute path: `root` defaults to `~/.claude/projects` and
+    carries the user's home directory, so a matching segment anywhere in that
+    prefix would answer for the whole tree."""
+    try:
+        return path.relative_to(root).parts
+    except ValueError:
+        return path.parts
+
+
+def is_transcript_path(root: Path, path: Path) -> bool:
+    """Whether a `.jsonl` under `root` is a transcript this extractor reads.
+
+    Decided by DEPTH, not by filename shape. A `.jsonl` sitting directly in a
+    project directory is a main-thread session whatever it is called — the
+    harness uses `<sessionId>.jsonl`, but nothing guarantees that and a
+    name-shape filter silently drops any session that differs, which is a
+    worse failure than the one it prevents.
+
+    Below `subagents/` the rule tightens, because that is the only place the
+    harness writes NON-transcript bookkeeping next to transcripts:
+    `subagents/workflows/<runId>/journal.jsonl` holds `{"type", "key",
+    "agentId"}` records with no `cwd`. Counting it as an agent run inflated the
+    run tally and, having no `cwd`, sent project labelling down a fallback that
+    leaked a path-derived slug (#1991). Agent transcripts are `agent-<id>.jsonl`.
+    """
+    try:
+        parts = path.relative_to(root).parts
+    except ValueError:
+        return False
+    if len(parts) < 2:
+        return False
+    if "subagents" in parts:
+        return bool(AGENT_TRANSCRIPT_RE.match(path.name))
+    return len(parts) == 2
+
+
+def is_subagent_transcript(root: Path, path: Path) -> bool:
+    """A dispatched agent's own run, at any nesting depth below `root`.
+
+    A plain Agent dispatch writes `<project>/<sessionId>/subagents/agent-*.jsonl`;
+    a Workflow's agents nest one level further under `subagents/workflows/<runId>/`.
+    Ask the path BELOW the root: `root` defaults to `~/.claude/projects` and
+    carries the user's home directory, so a matching segment in that prefix
+    would answer for the whole tree.
+    """
+    return "subagents" in relative_parts(root, path)
+
+
+def sorted_paths(paths) -> list[Path]:
+    """Total order over transcript paths. Sorting on `Path.name` alone is not
+    a total order once subagent transcripts (a second directory level) are in
+    the mix — sort on the full path string instead, which both extractors'
+    determinism guarantee (byte-identical output for the same inputs)
+    depends on."""
+    return sorted(paths, key=lambda p: str(p))
+
+
+def all_transcripts(root: Path) -> list[Path]:
+    """Every transcript under `root`, main-thread and subagent alike.
+
+    Globbing only `*/*.jsonl` made every dispatched agent invisible (#1990) —
+    silently, since subagent records ARE marked `isSidechain: true`; they simply
+    live in files nothing opened. Recurse rather than enumerate known depths.
+    """
+    return sorted_paths(
+        p
+        for p in root.glob("*/**/*.jsonl")
+        if p.is_file() and not p.is_symlink() and is_transcript_path(root, p)
+    )