From 59c7d287fb4ee65deac6581a25d4097d282889b9 Mon Sep 17 00:00:00 2001
From: abrichr <richard.abrich@mldsai.com>
Date: Mon, 19 Oct 2026 13:50:34 -0400
Subject: [PATCH 1/2] flow (proposal): classify common local edits from the
 recording

Draft for the founder; not for merging until decided
(docs/design/LOCAL_EDIT_CLASSIFICATION.md).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../docs/design/LOCAL_EDIT_CLASSIFICATION.md  | 102 ++++++
 .../backends/playwright_backend.py            |  22 ++
 .../flow/openadapt_flow/compiler/compile.py   |  24 ++
 .../openadapt_flow/compiler/local_edit.py     | 252 ++++++++++++++
 packages/flow/openadapt_flow/ir.py            |  26 ++
 packages/flow/openadapt_flow/policy.py        |   7 +-
 packages/flow/openadapt_flow/risk.py          |  30 ++
 .../flow/openadapt_flow/runtime/replayer.py   |  60 ++++
 .../tests/test_local_edit_classification.py   | 317 ++++++++++++++++++
 9 files changed, 838 insertions(+), 2 deletions(-)
 create mode 100644 packages/flow/docs/design/LOCAL_EDIT_CLASSIFICATION.md
 create mode 100644 packages/flow/openadapt_flow/compiler/local_edit.py
 create mode 100644 packages/flow/tests/test_local_edit_classification.py

diff --git a/packages/flow/docs/design/LOCAL_EDIT_CLASSIFICATION.md b/packages/flow/docs/design/LOCAL_EDIT_CLASSIFICATION.md
new file mode 100644
index 000000000..036956b04
--- /dev/null
+++ b/packages/flow/docs/design/LOCAL_EDIT_CLASSIFICATION.md
@@ -0,0 +1,102 @@
+# Classifying local edits without a person (proposal)
+
+Status: proposal. Not merged; the founder decides.
+
+## The problem
+
+A compiled program flags every special key and every unlabelled or
+navigation-shaped click for review (`risk_review_required`), because its
+risk can't be proven from the step alone. The run gate then refuses the
+bundle until a person classifies each one. On the OpenEMR referral that is 12
+steps (blocker section A in the referral admission list):
+
+- 8 `Control+a` presses, each in a text field right before typing into it;
+- 4 `Enter` presses, each right after typing an option's label into a
+  dropdown;
+
+plus, under `clinical-write`, the same keys fail `prohibit_vacuous_postconditions`
+because a key has no outcome check (section B), and the Contact tab click is
+unarmed (section C).
+
+These are the same few patterns in every form-filling program, on every app.
+A person approving each one, per bundle, is busywork that trains people to
+approve without reading.
+
+## The proposal
+
+The compiler classifies three local-edit patterns itself, and only when the
+recording shows the action stayed local. Each classified step gets an
+automatic outcome check that halts the run if, at run time, the action did
+anything else.
+
+| Pattern | Evidence the compiler needs (all of it) | Outcome check added to the step |
+| --- | --- | --- |
+| Select-all before typing: `Control+a` / `Meta+a` | The previous step clicked a single text field (structural role `textbox`, `searchbox` or `spinbutton`); the next step types into it; URL, title and page count unchanged across the key; no write request during the key (when the recording has network capture) | `local_edit`: after the key, the focused element is still that field, and URL, title and page count are unchanged. The next step's typed-input read-back then checks the field's whole value. |
+| Confirm a typed option: `Enter` | The previous steps clicked a dropdown (role `combobox` or `listbox`) and typed an option's label (a parameter or a literal); URL, title and page count unchanged; no write request during the key (network capture **required**: `Enter` is a submission key) | `local_edit` as above, plus `field_value`: the focused dropdown shows the typed label (the run's parameter value). |
+| In-form tab: a click on a tab | Role `tab`, or a `button` whose recorded click changed only the visible panel: URL, title and page count unchanged, no write request (network capture required), and the next step acts in the same frame | `local_edit` (URL, title and page count unchanged; focus need not stay). |
+
+What stays the same:
+
+- **The risk rule.** A step whose evidence is missing or mixed (a URL change,
+  a write request in the window, no network capture for a submission key, a
+  key that isn't one of these, a field role the compiler can't read) keeps
+  `risk_review_required` and goes to a person, exactly as today.
+- **Write-shaped context still wins.** A key or click whose retained text
+  names a consequential write (`submit`, `save`, `delete`, ...) classifies
+  irreversible before any of this runs.
+- **Explicit `risk_overrides` still win.**
+- **D, the duplicate-prevention (idempotency) key on the save, is untouched.**
+  That is a business decision.
+
+What the run gate sees: the classified step is reversible, reviewed by the
+compiler with recorded evidence (`risk_explanation` names the pattern and the
+evidence), and has an outcome check, so `require_reviewed_action_risk`,
+`prohibit_vacuous_postconditions` and `max_unverified_steps` pass for it. A
+tab click classified this way is in-form navigation that writes nothing, so it
+isn't consequential and isn't entity navigation; `prohibit_unarmed_clicks`
+under `clinical-write` still applies to it, so it still needs an identity
+check unless that policy exempts `local_edit` clicks (an open question below).
+
+## Why this is safe enough
+
+- The classification is backed by what the demonstration did, not by the
+  label. A key that submitted the form in the recording (a POST, a URL change)
+  is never classified.
+- The outcome check runs every time. If the same key does something else at
+  run time (the app changed, a different field had focus), the step fails its
+  postcondition and the run halts at that step. The halt comes after the key
+  was pressed, which is the residual risk: a key that, at run time only,
+  commits something. For the three patterns that requires the app to have
+  changed the field's behavior since the recording, and the first write it
+  makes is still caught by the save's record check or by the next step's
+  checks.
+- Evidence is sealed in the bundle (the step's explanation and postconditions
+  are part of the content digest), so a later edit to a classification
+  changes the digest and needs a new admission.
+
+## Open questions for the founder
+
+1. Accept the residual risk above for these three patterns?
+2. Should `clinical-write`'s `prohibit_unarmed_clicks` exempt a `local_edit`
+   tab click (it writes nothing and stays in the form), or must a person or the
+   compiler still arm it with an identity check? Today it must be armed.
+3. Without network capture, `Control+a` is classified on the structural and
+   URL evidence alone (select-all in a focused text field isn't a submission
+   key). `Enter` and tab clicks need network capture. Is that the right line?
+
+## Implementation sketch
+
+- `openadapt_flow.risk.local_edit_classifications(steps, events, network)`:
+  the three rules, returning `{step_id: (explanation, evidence)}`.
+- `compile_recording` applies them after the per-step inference and before
+  `risk_overrides`, and adds the outcome checks.
+- Two postcondition kinds: `local_edit` (structural: focus and URL, title,
+  page count) and `field_value` (the focused dropdown's label equals a run
+  parameter). Both are evaluated by the runtime like the existing structural
+  kinds, and both refuse rather than pass when the backend can't observe them
+  (unlike `url_changed`, which passes unverified).
+- Qualification's draft classification reads the same evidence, so a
+  compiled `local_edit` step drafts as `reversible` instead of `unknown`.
+- Tests: each pattern classifies with full evidence; each missing piece of
+  evidence leaves the step for a person; each outcome check halts when the
+  action did something else (focus moved, URL changed, wrong option).
diff --git a/packages/flow/openadapt_flow/backends/playwright_backend.py b/packages/flow/openadapt_flow/backends/playwright_backend.py
index a9bad239c..ed7589a1b 100644
--- a/packages/flow/openadapt_flow/backends/playwright_backend.py
+++ b/packages/flow/openadapt_flow/backends/playwright_backend.py
@@ -1665,6 +1665,28 @@ def focused_text_value(self) -> Optional[str]:
 
         return self._focused_element_eval(_EDITABLE_VALUE_JS)
 
+    def focused_element_matches(self, selector: str) -> Optional[bool]:
+        """Whether the focused element (through frames) matches ``selector``.
+
+        None when it can't be read. Used by the ``local_edit`` postcondition.
+        """
+
+        result = self._focused_element_call(
+            "(el, sel) => { try { return el.matches(sel); } catch (e) { return null; } }",
+            arg=selector,
+            with_arg=True,
+        )
+        return result if isinstance(result, bool) else None
+
+    def focused_select_label(self) -> Optional[str]:
+        """The focused ``<select>``'s selected option label, or None."""
+
+        return self._focused_element_eval(
+            "(el) => { if (!el || el.tagName !== 'SELECT') return null; "
+            "const opt = el.selectedOptions && el.selectedOptions[0]; "
+            "return opt ? (opt.label || opt.textContent || '') : null; }"
+        )
+
     def focused_field_label(self) -> Optional[str]:
         """Return the focused field's best available human label, or None.
 
diff --git a/packages/flow/openadapt_flow/compiler/compile.py b/packages/flow/openadapt_flow/compiler/compile.py
index 5a953566a..c534053ca 100644
--- a/packages/flow/openadapt_flow/compiler/compile.py
+++ b/packages/flow/openadapt_flow/compiler/compile.py
@@ -2880,6 +2880,30 @@ def cached_lines(i: int, suffix: str, png: bytes) -> list[OcrLine]:
             f"confirms the dialog opened by {opener_id}; this click saves"
         )
 
+    # Local edits the recording proves stayed local (select-all before
+    # typing, Enter on a typed dropdown option, an in-form tab): classified
+    # without a person, each with an outcome check that halts the run if the
+    # action does anything else at run time. Missing or mixed evidence leaves
+    # the step for a person. Explicit risk_overrides below still win.
+    # docs/design/LOCAL_EDIT_CLASSIFICATION.md
+    from openadapt_flow.compiler.local_edit import local_edits
+    from openadapt_flow.network_capture import NETWORK_FILE
+
+    network_lines = None
+    if (recording / NETWORK_FILE).is_file():
+        from openadapt_flow import network_capture as _nc
+
+        try:
+            network_lines = _nc.load(recording)
+        except Exception:  # noqa: BLE001 - unreadable capture proves nothing
+            network_lines = None
+    for edit in local_edits(steps, events, network_lines):
+        edited = by_step_id[edit.step_id]
+        edited.risk = "reversible"
+        edited.risk_explanation = edit.explanation
+        edited.risk_review_required = False
+        edited.expect = list(edited.expect) + list(edit.postconditions)
+
     if risk_overrides:
         by_id = {step.id: step for step in steps}
         resolved_overrides: dict[str, tuple[str, str]] = {}
diff --git a/packages/flow/openadapt_flow/compiler/local_edit.py b/packages/flow/openadapt_flow/compiler/local_edit.py
new file mode 100644
index 000000000..b48858e7e
--- /dev/null
+++ b/packages/flow/openadapt_flow/compiler/local_edit.py
@@ -0,0 +1,252 @@
+"""Classify the common local-edit patterns from what the recording shows.
+
+Proposal: docs/design/LOCAL_EDIT_CLASSIFICATION.md. A compiled program flags
+every special key and every unlabelled or navigation-shaped click for a
+person's review, because the step alone can't prove its risk. Three patterns
+recur in every form-filling program, and the recording can prove them local:
+
+- ``select_all``: Control+A (or Meta+A) in a text field, right before typing
+  into it;
+- ``confirm_option``: Enter right after typing an option's label into a
+  dropdown;
+- ``in_form_tab``: a click on a tab of the same form.
+
+A step is classified only when every piece of evidence holds: the field's
+structural role, the steps around it, URL, title and page count unchanged
+across the action, and no write request in its window (network capture is
+required for Enter and for tab clicks, since either can submit). Anything
+missing or mixed leaves the step for a person. A classified step gets an
+outcome check (``local_edit``, and ``field_value`` for a dropdown) that halts
+the run when, at run time, the action did anything else.
+
+Model-free and deterministic.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Literal, Optional, Sequence
+
+from openadapt_flow.ir import ActionKind, Postcondition, PostconditionKind, Step
+from openadapt_flow.risk import LOCAL_EDIT_PREFIX, is_local_edit
+
+__all__ = ["LOCAL_EDIT_PREFIX", "LocalEdit", "is_local_edit", "local_edits"]
+TEXT_ROLES = frozenset({"textbox", "searchbox", "spinbutton"})
+CHOICE_ROLES = frozenset({"combobox", "listbox"})
+_READ_METHODS = frozenset({"GET", "HEAD", "OPTIONS"})
+
+Pattern = Literal["select_all", "confirm_option", "in_form_tab"]
+
+
+@dataclass(frozen=True)
+class LocalEdit:
+    step_id: str
+    pattern: Pattern
+    explanation: str
+    postconditions: list[Postcondition] = field(default_factory=list)
+
+
+def _event_index(step: Step) -> Optional[int]:
+    prefix, _, number = step.id.rpartition("_")
+    return int(number) if prefix == "step" and number.isdigit() else None
+
+
+def _key_chord(step: Step) -> str:
+    parts = [p.strip().lower() for p in (step.key or "").split("+") if p.strip()]
+    parts += [m.lower() for m in step.modifiers]
+    return "+".join(sorted(set(parts)))
+
+
+def _structural(step: Optional[Step]) -> Any:
+    if step is None or step.anchor is None:
+        return None
+    return step.anchor.structural
+
+
+def _unchanged(event: dict[str, Any]) -> bool:
+    """URL, title and page count were recorded on both sides and didn't change."""
+
+    for before, after in (
+        ("url_before", "url_after"),
+        ("title_before", "title_after"),
+        ("pages_before", "pages_after"),
+    ):
+        if event.get(before) is None or event.get(after) is None:
+            return False
+        if event[before] != event[after]:
+            return False
+    return True
+
+
+def _no_write(
+    events: Sequence[dict[str, Any]],
+    i: int,
+    network: Optional[Sequence[dict[str, Any]]],
+) -> Optional[bool]:
+    """No write request in the action's window, or None without capture.
+
+    The window is from the previous event to the next one, as wide as the
+    API proposal uses for a step's reads: a request the action caused can
+    finish just after its event was stamped.
+    """
+
+    if network is None:
+        return None
+    lo = float(events[i - 1]["t"]) if i > 0 else float("-inf")
+    hi = float(events[i + 1]["t"]) if i + 1 < len(events) else float("inf")
+    for line in network:
+        method = str(line.get("method") or "").upper()
+        if method in _READ_METHODS:
+            continue
+        try:
+            t = float(line["t"])
+        except (KeyError, TypeError, ValueError):
+            return False
+        if lo < t <= hi:
+            return False
+    return True
+
+
+def local_edits(
+    steps: Sequence[Step],
+    events: Sequence[dict[str, Any]],
+    network: Optional[Sequence[dict[str, Any]]] = None,
+) -> list[LocalEdit]:
+    """The steps the recording proves are local edits, with their checks.
+
+    ``network`` is the recording's captured requests (``network.jsonl``
+    lines), or None when the recording has no capture.
+    """
+
+    found: list[LocalEdit] = []
+    for k, step in enumerate(steps):
+        if step.risk == "irreversible" or step.effects or step.api_binding:
+            continue
+        i = _event_index(step)
+        if i is None or i >= len(events):
+            continue
+        event = events[i]
+        if not _unchanged(event):
+            continue
+        prev = steps[k - 1] if k > 0 else None
+        nxt = steps[k + 1] if k + 1 < len(steps) else None
+        no_write = _no_write(events, i, network)
+        if step.action is ActionKind.KEY:
+            chord = _key_chord(step)
+            target = _structural(prev)
+            if (
+                chord in {"a+control", "a+meta"}
+                and prev is not None
+                and prev.action is ActionKind.CLICK
+                and target is not None
+                and target.selector
+                and (target.role or "").lower() in TEXT_ROLES
+                and nxt is not None
+                and nxt.action is ActionKind.TYPE
+                and no_write is not False
+            ):
+                found.append(
+                    LocalEdit(
+                        step.id,
+                        "select_all",
+                        f"{LOCAL_EDIT_PREFIX} selects the text of the field "
+                        f"{prev.id} clicked, before {nxt.id} types into it; "
+                        "URL, title and page count unchanged in the recording"
+                        + ("; no write request" if no_write else ""),
+                        [
+                            Postcondition(
+                                kind=PostconditionKind.LOCAL_EDIT,
+                                field_selector=target.selector,
+                            )
+                        ],
+                    )
+                )
+                continue
+            before_prev = steps[k - 2] if k > 1 else None
+            choice = _structural(before_prev)
+            typed_param = (
+                events[_event_index(prev)].get("param")
+                if prev is not None
+                and _event_index(prev) is not None
+                and _event_index(prev) < len(events)  # type: ignore[operator]
+                else None
+            )
+            if (
+                chord == "enter"
+                and prev is not None
+                and prev.action is ActionKind.TYPE
+                and before_prev is not None
+                and before_prev.action is ActionKind.CLICK
+                and choice is not None
+                and choice.selector
+                and (choice.role or "").lower() in CHOICE_ROLES
+                and isinstance(typed_param, str)
+                and typed_param
+                and no_write is True
+            ):
+                found.append(
+                    LocalEdit(
+                        step.id,
+                        "confirm_option",
+                        f"{LOCAL_EDIT_PREFIX} confirms the option typed into the "
+                        f"dropdown {before_prev.id} clicked; URL, title and page "
+                        "count unchanged and no write request in the recording",
+                        [
+                            Postcondition(
+                                kind=PostconditionKind.LOCAL_EDIT,
+                                field_selector=choice.selector,
+                            ),
+                            Postcondition(
+                                kind=PostconditionKind.FIELD_VALUE,
+                                param=typed_param,
+                            ),
+                        ],
+                    )
+                )
+            continue
+        if step.action is ActionKind.CLICK:
+            target = _structural(step)
+            role = (target.role or "").lower() if target is not None else ""
+            # The next step that acts on a target (a scroll or wait between
+            # them has none) must be in the same frame: the form is still
+            # there.
+            acting = next(
+                (
+                    later
+                    for later in steps[k + 1 : k + 4]
+                    if later.action not in {ActionKind.SCROLL, ActionKind.WAIT}
+                ),
+                None,
+            )
+            nxt = acting
+            same_frame = (
+                target is not None
+                and acting is not None
+                and _structural(acting) is not None
+                and list(_structural(acting).frame_path) == list(target.frame_path)
+            )
+            if (
+                target is not None
+                and role in {"tab", "button"}
+                and no_write is True
+                and same_frame
+                and (role == "tab" or not step.expect or _region_only(step))
+            ):
+                found.append(
+                    LocalEdit(
+                        step.id,
+                        "in_form_tab",
+                        f"{LOCAL_EDIT_PREFIX} switches the panel of the same form "
+                        f"({role}); URL, title and page count unchanged, no write "
+                        f"request, and {nxt.id if nxt else 'the next step'} acts in "
+                        "the same frame in the recording",
+                        [Postcondition(kind=PostconditionKind.LOCAL_EDIT)],
+                    )
+                )
+    return found
+
+
+def _region_only(step: Step) -> bool:
+    """The click's only mined check is a region change (a panel switch)."""
+
+    return all(p.kind is PostconditionKind.REGION_STABLE for p in step.expect)
diff --git a/packages/flow/openadapt_flow/ir.py b/packages/flow/openadapt_flow/ir.py
index 1dcce099a..cc7f74a05 100644
--- a/packages/flow/openadapt_flow/ir.py
+++ b/packages/flow/openadapt_flow/ir.py
@@ -465,6 +465,14 @@ class PostconditionKind(str, Enum):
     URL_CHANGED = "url_changed"  # page URL differs from the step's start
     TITLE_CHANGED = "title_changed"  # page title differs from the step's start
     NEW_TAB_OPENED = "new_tab_opened"  # browser page count increased
+    # A compiler-classified local edit (docs/design/LOCAL_EDIT_CLASSIFICATION.md):
+    # URL, title and page count are unchanged from the step's start and, when
+    # ``field_selector`` is set, focus is still in that field. Unlike the
+    # *_changed kinds, an unobservable property fails the check.
+    LOCAL_EDIT = "local_edit"
+    # The focused dropdown shows the run's value of ``param`` (its selected
+    # option's label, whitespace-squashed and case-insensitive).
+    FIELD_VALUE = "field_value"
 
 
 class Postcondition(BaseModel):
@@ -482,6 +490,24 @@ class Postcondition(BaseModel):
             " near, not exactly at, the recorded region)"
         ),
     )
+    #: LOCAL_EDIT: the structural selector of the field focus must stay in.
+    field_selector: Optional[str] = None
+    #: FIELD_VALUE: the run parameter whose value the field must show.
+    param: Optional[str] = Field(
+        default=None, pattern=r"^[A-Za-z_][A-Za-z0-9_]{0,127}$"
+    )
+
+    @model_serializer(mode="wrap")
+    def _serialize_compatible(self, handler: Any) -> dict[str, Any]:
+        """Leave the local-edit fields out when unset, so every existing
+        postcondition (and bundle digest) serializes exactly as before."""
+
+        data: dict[str, Any] = handler(self)
+        if self.field_selector is None:
+            data.pop("field_selector", None)
+        if self.param is None:
+            data.pop("param", None)
+        return data
 
 
 IdentitySignalKeyValue = Literal[
diff --git a/packages/flow/openadapt_flow/policy.py b/packages/flow/openadapt_flow/policy.py
index 454b469ae..04ff1e620 100644
--- a/packages/flow/openadapt_flow/policy.py
+++ b/packages/flow/openadapt_flow/policy.py
@@ -29,7 +29,7 @@
 from pydantic import BaseModel, ConfigDict, Field
 
 from openadapt_flow.ir import ActionKind, Step, Workflow
-from openadapt_flow.risk import classify_step_risk, step_text
+from openadapt_flow.risk import classify_step_risk, is_local_edit, step_text
 from openadapt_flow.traversal import iter_workflow_steps
 from openadapt_flow.verification import declared_effect_is_independent_read
 
@@ -486,7 +486,10 @@ def step_tags(
         tags.add("identity_applicable")
     if act in _CLICK_ACTIONS and effective_risk == "reversible":
         tags.add("navigation")
-        if is_identity_applicable(step):
+        # A click the compiler classified as an in-form local edit (its
+        # runtime check sealed in the step) stays in the same form: it is
+        # not navigation to an entity.
+        if is_identity_applicable(step) and not is_local_edit(step):
             tags.add("entity_navigation")
     return tags
 
diff --git a/packages/flow/openadapt_flow/risk.py b/packages/flow/openadapt_flow/risk.py
index b57c05cda..04c472650 100644
--- a/packages/flow/openadapt_flow/risk.py
+++ b/packages/flow/openadapt_flow/risk.py
@@ -63,6 +63,24 @@
 _RULE_ID_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._:-]{0,63}$")
 
 
+#: ``risk_explanation`` prefix of a local edit the compiler classified from
+#: recorded evidence (openadapt_flow.compiler.local_edit).
+LOCAL_EDIT_PREFIX = "local edit:"
+
+
+def is_local_edit(step: Step) -> bool:
+    """A step the compiler classified as a local edit, with its check sealed.
+
+    Both halves are part of the sealed bundle: the explanation, and the
+    ``local_edit`` postcondition the runtime checks after the action.
+    """
+
+    return bool(
+        (step.risk_explanation or "").startswith(LOCAL_EDIT_PREFIX)
+        and any(p.kind is PostconditionKind.LOCAL_EDIT for p in step.expect)
+    )
+
+
 @dataclass(frozen=True)
 class RiskInference:
     """Compile-time classification plus its qualification disposition."""
@@ -702,6 +720,12 @@ def infer_step_risk(
                 "submission/deletion key has retained consequential-write context",
                 (action_evidence, f"write_keyword:{write_keyword}"),
             )
+        if is_local_edit(step):
+            return RiskInference(
+                "reversible",
+                (step.risk_explanation or LOCAL_EDIT_PREFIX)[:512],
+                (action_evidence, "pattern:local_edit"),
+            )
         configured = _application_rule_inference(step, rules)
         if configured is not None:
             return configured
@@ -737,6 +761,12 @@ def infer_step_risk(
             "retained action context names a consequential state change",
             (action_evidence, f"write_keyword:{write_keyword}"),
         )
+    if is_local_edit(step) and step.action is ActionKind.CLICK:
+        return RiskInference(
+            "reversible",
+            (step.risk_explanation or LOCAL_EDIT_PREFIX)[:512],
+            (action_evidence, "pattern:local_edit"),
+        )
     configured = _application_rule_inference(step, rules)
     if configured is not None:
         return configured
diff --git a/packages/flow/openadapt_flow/runtime/replayer.py b/packages/flow/openadapt_flow/runtime/replayer.py
index 51e407a43..795c16015 100644
--- a/packages/flow/openadapt_flow/runtime/replayer.py
+++ b/packages/flow/openadapt_flow/runtime/replayer.py
@@ -5177,6 +5177,16 @@ def _revalidate_retained_postconditions(
     ) -> None:
         """Re-evaluate an exact retained postcondition contract or refuse."""
 
+        # A local-edit check is relative to its step's start (focus, URL,
+        # title, page count) and can't be re-run after a restart. These steps
+        # had no postcondition at all before they were classified, so leaving
+        # the check out of resume revalidation keeps it exactly as strict.
+        conditions = [
+            condition
+            for condition in conditions
+            if condition.kind
+            not in {PostconditionKind.LOCAL_EDIT, PostconditionKind.FIELD_VALUE}
+        ]
         if not conditions:
             return
         non_replayable = [
@@ -15841,10 +15851,56 @@ def _expected_state_text(pc: Any) -> Optional[str]:
             return "the content recorded in the highlighted region is present"
         return None
 
+    def _local_edit_held(self, pc: Any, start_state: dict[str, Any]) -> bool:
+        """A compiler-classified local edit stayed local (fail closed).
+
+        URL, title and page count must be observable and unchanged from the
+        step's start, and focus must still be in ``pc.field_selector`` when
+        one is set. Anything unobservable fails the check: the classification
+        rests on this evidence (docs/design/LOCAL_EDIT_CLASSIFICATION.md).
+        """
+
+        for key in ("url", "page_title", "page_count"):
+            if self._structural_changed(key, start_state) is not False:
+                return False
+        if pc.field_selector:
+            reader = getattr(self.backend, "focused_element_matches", None)
+            if not callable(reader):
+                return False
+            try:
+                return reader(pc.field_selector) is True
+            except Exception:  # noqa: BLE001 - unobservable is a failure
+                return False
+        return True
+
+    def _field_value_shown(self, pc: Any) -> bool:
+        """The focused dropdown shows this run's value of ``pc.param``."""
+
+        params = getattr(self, "_current_params", None) or {}
+        if not pc.param or pc.param not in params:
+            return False
+        reader = getattr(self.backend, "focused_select_label", None)
+        if not callable(reader):
+            return False
+        try:
+            shown = reader()
+        except Exception:  # noqa: BLE001 - unobservable is a failure
+            return False
+
+        def squash(value: str) -> str:
+            return " ".join(value.split()).casefold()
+
+        expected = runtime_param_text(params[pc.param])
+        return isinstance(shown, str) and squash(shown) == squash(expected)
+
     @staticmethod
     def _describe_postcondition(pc: Any) -> str:
         """Human-readable one-liner for a postcondition (for error messages)."""
         kind = pc.kind.value if hasattr(pc.kind, "value") else pc.kind
+        if kind == "local_edit":
+            return "local_edit (URL, title, page count and focus unchanged)"
+        if kind == "field_value":
+            return f"field_value (the focused field shows {{{pc.param}}})"
         if kind in ("text_present", "text_absent"):
             return f"{kind} {pc.text!r}"
         if kind in ("url_changed", "title_changed", "new_tab_opened"):
@@ -15891,6 +15947,10 @@ def _postcondition_passes(
     ) -> bool:
         """Evaluate a single postcondition against a frame."""
         kind = pc.kind.value if hasattr(pc.kind, "value") else pc.kind
+        if kind == "local_edit":
+            return self._local_edit_held(pc, start_state or {})
+        if kind == "field_value":
+            return self._field_value_shown(pc)
         if kind in ("url_changed", "title_changed", "new_tab_opened"):
             key = {
                 "url_changed": "url",
diff --git a/packages/flow/tests/test_local_edit_classification.py b/packages/flow/tests/test_local_edit_classification.py
new file mode 100644
index 000000000..24c61879c
--- /dev/null
+++ b/packages/flow/tests/test_local_edit_classification.py
@@ -0,0 +1,317 @@
+"""Local edits classified from the recording (docs/design/LOCAL_EDIT_CLASSIFICATION.md).
+
+Each pattern classifies only with all of its evidence; each missing piece
+leaves the step for a person; each outcome check fails when the action did
+anything else at run time. Synthetic events only.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+import pytest
+
+from openadapt_flow.compiler.local_edit import local_edits
+from openadapt_flow.ir import (
+    ActionKind,
+    Anchor,
+    Postcondition,
+    PostconditionKind,
+    Step,
+    StructuralLocator,
+    Workflow,
+)
+from openadapt_flow.policy import step_tags
+from openadapt_flow.risk import infer_step_risk, is_local_edit
+
+FRAME = ["div > iframe"]
+URL = "http://app/form"
+
+
+def _click(i: int, selector: Optional[str], role: str, name: str = "Field") -> Step:
+    return Step(
+        id=f"step_{i:03d}",
+        intent=f"click {name}",
+        action=ActionKind.CLICK,
+        anchor=Anchor(
+            template=f"templates/{i}.png",
+            region=(0, 0, 10, 10),
+            click_point=(5, 5),
+            structural=StructuralLocator(
+                selector=selector, frame_path=list(FRAME), role=role, name=name
+            ),
+        ),
+        risk_review_required=False,
+    )
+
+
+def _key(i: int, key: str) -> Step:
+    return Step(
+        id=f"step_{i:03d}",
+        intent=f"press {key}",
+        action=ActionKind.KEY,
+        key=key,
+        risk_review_required=True,
+        risk_explanation="special key may navigate, edit, or invoke an application shortcut",
+    )
+
+
+def _type(i: int, param: str) -> Step:
+    return Step(
+        id=f"step_{i:03d}",
+        intent="type a value",
+        action=ActionKind.TYPE,
+        text="{" + param + "}",
+    )
+
+
+def _event(i: int, **changes: Any) -> dict[str, Any]:
+    event = {
+        "i": i,
+        "t": float(i),
+        "url_before": URL,
+        "url_after": URL,
+        "title_before": "Form",
+        "title_after": "Form",
+        "pages_before": 1,
+        "pages_after": 1,
+    }
+    event.update(changes)
+    return event
+
+
+def _events(n: int, **at: dict[str, Any]) -> list[dict[str, Any]]:
+    return [_event(i, **at.get(f"e{i}", {})) for i in range(n)]
+
+
+def _ids(edits) -> dict[str, str]:
+    return {e.step_id: e.pattern for e in edits}
+
+
+# -- select-all before typing ---------------------------------------------------------
+
+
+def test_select_all_in_a_text_field_before_typing_is_a_local_edit():
+    steps = [_click(0, "#lname", "textbox"), _key(1, "Control+a"), _type(2, "lname")]
+    (edit,) = local_edits(steps, _events(3), network=[])
+    assert edit.step_id == "step_001" and edit.pattern == "select_all"
+    (check,) = edit.postconditions
+    assert check.kind is PostconditionKind.LOCAL_EDIT
+    assert check.field_selector == "#lname"
+
+
+@pytest.mark.parametrize(
+    "steps, events, network, why",
+    [
+        (
+            [_click(0, "#lname", "button"), _key(1, "Control+a"), _type(2, "lname")],
+            _events(3),
+            [],
+            "not a text field",
+        ),
+        (
+            [
+                _click(0, "#lname", "textbox"),
+                _key(1, "Control+a"),
+                _click(2, "#x", "textbox"),
+            ],
+            _events(3),
+            [],
+            "nothing is typed next",
+        ),
+        (
+            [_click(0, "#lname", "textbox"), _key(1, "Control+a"), _type(2, "lname")],
+            _events(3, e1={"url_after": URL + "?next"}),
+            [],
+            "the URL changed",
+        ),
+        (
+            [_click(0, "#lname", "textbox"), _key(1, "Control+a"), _type(2, "lname")],
+            _events(3),
+            [{"method": "POST", "t": 1.2, "url": URL}],
+            "a write request in the window",
+        ),
+        (
+            [_click(0, None, "textbox"), _key(1, "Control+a"), _type(2, "lname")],
+            _events(3),
+            [],
+            "no field selector to keep focus in",
+        ),
+    ],
+)
+def test_select_all_without_its_evidence_stays_with_a_person(
+    steps, events, network, why
+):
+    assert local_edits(steps, events, network=network) == [], why
+
+
+def test_select_all_needs_no_network_capture():
+    steps = [_click(0, "#lname", "textbox"), _key(1, "Control+a"), _type(2, "lname")]
+    assert _ids(local_edits(steps, _events(3), network=None)) == {
+        "step_001": "select_all"
+    }
+
+
+# -- Enter on a typed dropdown option ---------------------------------------------------
+
+
+def _dropdown(network: Optional[list] = None, **changes):
+    steps = [_click(0, "#state", "combobox"), _type(1, "state"), _key(2, "Enter")]
+    events = _events(3, e1={"param": "state"}, **changes)
+    return local_edits(steps, events, network=[] if network is None else network)
+
+
+def test_enter_after_typing_a_dropdown_option_is_a_local_edit():
+    (edit,) = _dropdown()
+    assert edit.step_id == "step_002" and edit.pattern == "confirm_option"
+    kinds = [p.kind for p in edit.postconditions]
+    assert kinds == [PostconditionKind.LOCAL_EDIT, PostconditionKind.FIELD_VALUE]
+    assert edit.postconditions[1].param == "state"
+
+
+def test_enter_needs_network_capture_and_no_write():
+    steps = [_click(0, "#state", "combobox"), _type(1, "state"), _key(2, "Enter")]
+    events = _events(3, e1={"param": "state"})
+    assert local_edits(steps, events, network=None) == []
+    assert _dropdown(network=[{"method": "POST", "t": 2.5, "url": URL}]) == []
+    assert _dropdown(e2={"title_after": "Saved"}) == []
+
+
+def test_enter_in_a_text_field_stays_with_a_person():
+    steps = [_click(0, "#q", "textbox"), _type(1, "q"), _key(2, "Enter")]
+    events = _events(3, e1={"param": "q"})
+    assert local_edits(steps, events, network=[]) == []
+
+
+# -- in-form tabs -------------------------------------------------------------------------
+
+
+def test_a_tab_of_the_same_form_is_a_local_edit():
+    steps = [_click(0, None, "button", "Contact"), _click(1, "#street", "textbox")]
+    (edit,) = local_edits(steps, _events(2), network=[])
+    assert edit.pattern == "in_form_tab"
+    assert [p.kind for p in edit.postconditions] == [PostconditionKind.LOCAL_EDIT]
+
+
+def test_a_tab_click_needs_capture_the_same_frame_and_no_write():
+    steps = [_click(0, None, "tab", "Contact"), _click(1, "#street", "textbox")]
+    assert local_edits(steps, _events(2), network=None) == []
+    assert local_edits(steps, _events(2), network=[{"method": "POST", "t": 0.5}]) == []
+    other = _click(1, "#street", "textbox")
+    other.anchor.structural.frame_path = ["div > iframe:nth-of-type(2)"]
+    assert local_edits([steps[0], other], _events(2), network=[]) == []
+
+
+def test_a_write_shaped_click_is_never_a_local_edit():
+    save = _click(0, None, "button", "Save")
+    save.risk = "irreversible"
+    steps = [save, _click(1, "#street", "textbox")]
+    assert local_edits(steps, _events(2), network=[]) == []
+
+
+# -- risk, tags and the outcome checks ------------------------------------------------------
+
+
+def _classified_key() -> Step:
+    step = _key(1, "Control+a")
+    step.risk_review_required = False
+    step.risk_explanation = "local edit: selects the text of the field"
+    step.expect = [
+        Postcondition(kind=PostconditionKind.LOCAL_EDIT, field_selector="#a")
+    ]
+    return step
+
+
+def test_the_risk_reinference_reads_a_sealed_local_edit():
+    step = _classified_key()
+    assert is_local_edit(step)
+    inference = infer_step_risk(step)
+    assert inference.risk == "reversible" and not inference.requires_review
+    # Without its runtime check the explanation alone proves nothing.
+    step.expect = []
+    assert infer_step_risk(step).requires_review
+
+
+def test_a_local_edit_tab_is_not_entity_navigation():
+    tab = _click(0, None, "button", "Contact")
+    tab.anchor.ocr_text = "Contact"
+    wf = Workflow(name="w", steps=[tab])
+    assert "entity_navigation" in step_tags(
+        tab, wf, require_current_certification=False
+    )
+    tab.risk_explanation = "local edit: switches the panel of the same form"
+    tab.expect = [Postcondition(kind=PostconditionKind.LOCAL_EDIT)]
+    assert "entity_navigation" not in step_tags(
+        tab, wf, require_current_certification=False
+    )
+
+
+def test_unset_local_edit_fields_serialize_as_before():
+    pc = Postcondition(kind=PostconditionKind.TEXT_PRESENT, text="Saved")
+    assert set(pc.model_dump()) == {
+        "kind",
+        "text",
+        "region",
+        "phash",
+        "phash_tolerance",
+        "timeout_s",
+        "template",
+    }
+
+
+class _Backend:
+    def __init__(self, *, url=URL, focused=True, label="Massachusetts") -> None:
+        self.url, self.page_title, self.page_count = url, "Form", 1
+        self._focused, self._label = focused, label
+
+    def focused_element_matches(self, selector):
+        return self._focused
+
+    def focused_select_label(self):
+        return self._label
+
+
+def _replayer(backend):
+    from openadapt_flow.runtime.replayer import Replayer
+    from tests.test_replayer import FakeVision
+
+    replayer = Replayer(backend, vision=FakeVision())
+    replayer._current_params = {"state": "Massachusetts"}
+    return replayer
+
+
+START = {"url": URL, "page_title": "Form", "page_count": 1}
+
+
+@pytest.mark.parametrize(
+    "backend, passes",
+    [
+        (_Backend(), True),
+        (_Backend(url=URL + "?saved"), False),
+        (_Backend(focused=False), False),
+        (_Backend(focused=None), False),
+    ],
+)
+def test_the_local_edit_check_fails_when_the_action_did_anything_else(backend, passes):
+    pc = Postcondition(kind=PostconditionKind.LOCAL_EDIT, field_selector="#a")
+    assert _replayer(backend)._postcondition_passes(pc, b"", None, START) is passes
+
+
+def test_the_local_edit_check_fails_closed_when_it_cant_observe():
+    pc = Postcondition(kind=PostconditionKind.LOCAL_EDIT)
+    assert _replayer(_Backend())._postcondition_passes(pc, b"", None, {}) is False
+
+
+@pytest.mark.parametrize(
+    "label, passes",
+    [
+        ("Massachusetts", True),
+        ("  massachusetts ", True),
+        ("Maine", False),
+        (None, False),
+    ],
+)
+def test_the_field_value_check_reads_the_dropdown(label, passes):
+    pc = Postcondition(kind=PostconditionKind.FIELD_VALUE, param="state")
+    replayer = _replayer(_Backend(label=label))
+    assert replayer._postcondition_passes(pc, b"", None, START) is passes

From 2a5cc1fbcdf51cbfd660235c1cd5baf2f9055aa9 Mon Sep 17 00:00:00 2001
From: abrichr <richard.abrich@mldsai.com>
Date: Mon, 19 Oct 2026 19:13:19 -0400
Subject: [PATCH 2/2] flow: classify local edits only on strict evidence; add
 Enter in a field and a dialog's dismiss

Every pattern now needs network capture showing no write in the step's window,
URL, title and page count unchanged, and equal record-store snapshots when
the recorder took them. Control+a no longer classifies without capture.

New patterns: confirm_entry (Enter after typing into a text field; the
field_value check reads the text field's exact value) and dismiss_dialog
(an informational dialog's dismiss, e.g. MockMed's What's New 'Continue to
tasks'; checks the page is unchanged and the label is gone). A dismiss is
reconsidered only when 'continue' or 'next' are its only write words and its
risk is still the per-step keyword inference, so effect mining no longer
attaches a placeholder record_written to it (#1377).

Fixes the CI crash on a structural target with no frame_path and the mypy
index error.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 CAPABILITIES.md                               |   1 +
 llms-full.txt                                 | 185 ++++++++-
 .../docs/design/LOCAL_EDIT_CLASSIFICATION.md  | 131 ++++---
 .../openadapt_flow/compiler/local_edit.py     | 354 ++++++++++++------
 packages/flow/openadapt_flow/risk.py          |  35 ++
 .../flow/openadapt_flow/runtime/replayer.py   |  31 +-
 .../tests/test_local_edit_classification.py   | 247 +++++++++++-
 7 files changed, 785 insertions(+), 199 deletions(-)

diff --git a/CAPABILITIES.md b/CAPABILITIES.md
index c42ee9af9..415000e81 100644
--- a/CAPABILITIES.md
+++ b/CAPABILITIES.md
@@ -124,6 +124,7 @@ improvising or retrying when something is off.
 | Capability | Status | Evidence | Where |
 | --- | --- | --- | --- |
 | Compile one or more demonstrations into a deterministic program | Released | Real app (OpenEMR referral, 62 timed runs) | `openadapt-flow record`, `compile`; [packages/flow](packages/flow/README.md) |
+| Classify common local edits without a person (select-all, Enter in a field or dropdown, an in-form tab, an informational dialog's dismiss), only when the recording's network capture shows no write and a runtime check confirms only the expected change | In review ([#1366](https://github.com/OpenAdaptAI/OpenAdapt/pull/1366)) | Synthetic; OpenEMR referral recording re-admitted offline (violations 12 to 1 under `permissive`) | [LOCAL_EDIT_CLASSIFICATION.md](packages/flow/docs/design/LOCAL_EDIT_CLASSIFICATION.md), `compiler/local_edit.py` |
 | Right-record check before any write (structure, then OCR, then pixels) | Released | Real app and synthetic | [RESOLUTION_LADDER.md](packages/flow/docs/RESOLUTION_LADDER.md), `runtime/identity.py` |
 | Read the saved record back from the system of record (API, database, FHIR, separate session) | Released | Real app (OpenEMR 12 of 12 fields) | [VERIFICATION.md](packages/flow/docs/VERIFICATION.md), `runtime/effects/` |
 | Read values out of an app as a workflow step (READ), with a records format, a signed review queue and export to CSV or a database | On main ([#1229](https://github.com/OpenAdaptAI/OpenAdapt/pull/1229), [#1215](https://github.com/OpenAdaptAI/OpenAdapt/pull/1215), [#1218](https://github.com/OpenAdaptAI/OpenAdapt/pull/1218)–[#1224](https://github.com/OpenAdaptAI/OpenAdapt/pull/1224)) | Synthetic (mock desktop apps) | `openadapt_flow/interchange/` |
diff --git a/llms-full.txt b/llms-full.txt
index 7f4752fa6..5a0686033 100644
--- a/llms-full.txt
+++ b/llms-full.txt
@@ -416,9 +416,10 @@ shipping in the next release; a pull request number means it is being merged.
    review, campaign, canary, rollback), agent-demonstrated fixes for a halted
    run, and fleet drift patches shared with no patient data are released.
    Self-repair, where an agent proposes a fix and Flow probes it up to the save
-   without saving, is on main; fixes of up to three new steps are in review.
-9. **Is a safety layer underneath any agent.** An agent's MCP calls, a guarded
-   save around any agent's write
+   without saving, is on main, and so are fixes of up to three new steps.
+9. **Is a safety layer underneath any agent.** An agent's MCP calls, a task
+   ledger that keeps a long job's rules, items, questions and checked saves on
+   the server ([#1332](https://github.com/OpenAdaptAI/OpenAdapt/pull/1332)), a guarded save around any agent's write
    ([#1258](https://github.com/OpenAdaptAI/OpenAdapt/pull/1258)), `verify-run`
    to judge any executor's write from the system of record, and Agent Skills and
    a CLI for coding agents. Released except where a PR is named.
@@ -480,6 +481,7 @@ improvising or retrying when something is off.
 | Capability | Status | Evidence | Where |
 | --- | --- | --- | --- |
 | Compile one or more demonstrations into a deterministic program | Released | Real app (OpenEMR referral, 62 timed runs) | `openadapt-flow record`, `compile`; [packages/flow](https://github.com/OpenAdaptAI/OpenAdapt/blob/main/packages/flow/README.md) |
+| Classify common local edits without a person (select-all, Enter in a field or dropdown, an in-form tab, an informational dialog's dismiss), only when the recording's network capture shows no write and a runtime check confirms only the expected change | In review ([#1366](https://github.com/OpenAdaptAI/OpenAdapt/pull/1366)) | Synthetic; OpenEMR referral recording re-admitted offline (violations 12 to 1 under `permissive`) | [LOCAL_EDIT_CLASSIFICATION.md](https://github.com/OpenAdaptAI/OpenAdapt/blob/main/packages/flow/docs/design/LOCAL_EDIT_CLASSIFICATION.md), `compiler/local_edit.py` |
 | Right-record check before any write (structure, then OCR, then pixels) | Released | Real app and synthetic | [RESOLUTION_LADDER.md](https://github.com/OpenAdaptAI/OpenAdapt/blob/main/packages/flow/docs/RESOLUTION_LADDER.md), `runtime/identity.py` |
 | Read the saved record back from the system of record (API, database, FHIR, separate session) | Released | Real app (OpenEMR 12 of 12 fields) | [VERIFICATION.md](https://github.com/OpenAdaptAI/OpenAdapt/blob/main/packages/flow/docs/VERIFICATION.md), `runtime/effects/` |
 | Read values out of an app as a workflow step (READ), with a records format, a signed review queue and export to CSV or a database | On main ([#1229](https://github.com/OpenAdaptAI/OpenAdapt/pull/1229), [#1215](https://github.com/OpenAdaptAI/OpenAdapt/pull/1215), [#1218](https://github.com/OpenAdaptAI/OpenAdapt/pull/1218)–[#1224](https://github.com/OpenAdaptAI/OpenAdapt/pull/1224)) | Synthetic (mock desktop apps) | `openadapt_flow/interchange/` |
@@ -574,6 +576,7 @@ improvising or retrying when something is off.
 | Code as action: the run-1 agent acts through one terminal tool (structure first, actions by role and name, a sandboxed read-only shell, screenshots on request); every action is a structured step checked against the compiled program | In review ([#1305](https://github.com/OpenAdaptAI/OpenAdapt/pull/1305)) | Real app (local OpenEMR) and synthetic | `ClaudeAgent(vision="code")`, `CODE_AS_ACTION.md` ([#1305](https://github.com/OpenAdaptAI/OpenAdapt/pull/1305)) |
 | Admit a draft by a person, an admitter key, or an agent under a person-signed policy, including self-admission when the policy allows it | Released | Unit tests | [JIT_ADMISSION.md](https://github.com/OpenAdaptAI/OpenAdapt/blob/main/packages/flow/docs/JIT_ADMISSION.md) |
 | MCP server: your agent decides what to enter, OpenAdapt makes the entry and checks it | Released | Synthetic sandbox | `openadapt-agent`, [packages/agent](https://github.com/OpenAdaptAI/OpenAdapt/blob/main/packages/agent/README.md) |
+| Task ledger per job: rules locked when the job opens and enforced on every run, item status set only from OpenAdapt's own results, and yes-or-no questions a person answers on the phone or in Desktop, including when a run stops | In review ([#1332](https://github.com/OpenAdaptAI/OpenAdapt/pull/1332)) | Synthetic (30-item MockMed worklist, scripted agent, no model calls) | MCP tools `open_job`, `get_job`, `add_items`, `record_evidence`, `ask_user`, `get_answer`, `change_constraint`, `close_job`; [Track a long job](https://github.com/OpenAdaptAI/OpenAdapt/blob/main/packages/agent/README.md#track-a-long-job) |
 | Compile an agent's first verified run from a prompt (`compile-agent`), and a code-as-action authoring agent | In review ([#1277](https://github.com/OpenAdaptAI/OpenAdapt/pull/1277), [#1305](https://github.com/OpenAdaptAI/OpenAdapt/pull/1305)); the agent harness behind it runs on every backend, on main ([#1283](https://github.com/OpenAdaptAI/OpenAdapt/pull/1283)) | Synthetic | `compile-agent` |
 | Score harness optimizers (Harness², Meta-Harness) on GUI tasks with the record read-back as the reward, with full trace export | On main ([#1299](https://github.com/OpenAdaptAI/OpenAdapt/pull/1299), [#1300](https://github.com/OpenAdaptAI/OpenAdapt/pull/1300), [#1301](https://github.com/OpenAdaptAI/OpenAdapt/pull/1301)) | Synthetic (scripted proposer) | `integrations/harness2/` |
 | One scoreboard comparing the agent alone with OpenAdapt across tasks (correctness by read-back, cost, time, items per hour) | In progress ([#1303](https://github.com/OpenAdaptAI/OpenAdapt/pull/1303)) | Synthetic and local OpenEMR and openIMIS test copies | `benchmark/scoreboard/` |
@@ -591,19 +594,112 @@ improvising or retrying when something is off.
 
 ## Every command, by capability
 
-Each `openadapt-flow` command, grouped by the capability it serves. A test
-fails when a command is added without being listed here.
-
-- **Record and build a program:** `record`, `demo-record`, `compile`, `induce`, `disambiguate`, `for-each`, `compose`, `process`, `intake`, `visualize`, `pull`, `variants`, `route`, `compile-agent`.
-- **Check and admit:** `lint`, `scaffold-verifier`, `check`, `api`, `bind-record-checks`, `certify`, `qualify`, `propose-qualification`, `known-ids`, `jit`, `admit`, `approver-grant`.
-- **Run and answer:** `run`, `replay`, `resume`, `approve`, `item-approval`, `triage`, `business-decisions`, `explain`, `console`, `deferred`.
-- **Judge any executor's write:** `verify-run`, `serve-reward` (scores agent training episodes by reading the system of record).
-- **Repair and learn from halts:** `teach`, `teach-branch`, `repair`, `fleet`, `undo` (the undo steps a person approves after a stop).
-- **Give agents the program:** `emit-skill`, `emit-mcp`, `serve-execute`.
-- **Proof:** `seal`, `local-seal`, `countersign`, `attach-seal`.
-- **Run on premises:** `service`, `no-outbound`.
-- **Share safely with OpenAdapt Cloud:** `sanitize`, `review-sanitized`, `approve-sanitized`, `materialize-approved`, `push`, `validate-hosted`, `report-break`, `report-run`, `connect`, `login`, `connector`.
-- **Try it and measure it:** `demo`, `tutorial`, `bench`, `benchmark`.
+Each `openadapt-flow` command, grouped by the capability it serves. Each
+command has one file under
+[`packages/flow/docs/commands/`](https://github.com/OpenAdaptAI/OpenAdapt/blob/main/packages/flow/docs/commands/): to add a
+command, add `<group>/<verb>.md` and run `python scripts/build_command_map.py`.
+A test fails when a command has no file or this list is out of date.
+
+<!-- BEGIN generated by scripts/build_command_map.py -->
+
+**Record and build a program:**
+
+- `compile-agent`
+- `compile`
+- `compose`
+- `demo-record`
+- `disambiguate`
+- `for-each`
+- `induce`
+- `intake`
+- `process`
+- `pull`
+- `record`
+- `route`
+- `variants`
+- `visualize`
+
+**Check and admit:**
+
+- `admit`
+- `api`
+- `approver-grant`
+- `bind-record-checks`
+- `certify`
+- `check`
+- `jit`
+- `known-ids`
+- `lint`
+- `propose-qualification`
+- `qualify`
+- `scaffold-verifier`
+
+**Run and answer:**
+
+- `approve`
+- `business-decisions`
+- `console`
+- `deferred`
+- `explain`
+- `item-approval`
+- `replay`
+- `resume`
+- `run`
+- `triage`
+
+**Judge any executor's write:**
+
+- `serve-reward`: Scores agent training episodes by reading the system of record.
+- `verify-run`
+
+**Repair and learn from halts:**
+
+- `fleet`
+- `repair`
+- `teach-branch`
+- `teach`
+- `undo`: The undo steps a person approves after a stop.
+
+**Give agents the program:**
+
+- `emit-mcp`
+- `emit-skill`
+- `serve-execute`
+
+**Proof:**
+
+- `attach-seal`
+- `countersign`
+- `local-seal`
+- `seal`
+
+**Run on premises:**
+
+- `no-outbound`
+- `service`
+
+**Share safely with OpenAdapt Cloud:**
+
+- `approve-sanitized`
+- `connect`
+- `connector`
+- `login`
+- `materialize-approved`
+- `push`
+- `report-break`
+- `report-run`
+- `review-sanitized`
+- `sanitize`
+- `validate-hosted`
+
+**Try it and measure it:**
+
+- `bench`
+- `benchmark`
+- `demo`
+- `tutorial`
+
+<!-- END generated by scripts/build_command_map.py -->
 
 ## Measured results
 
@@ -1128,6 +1224,30 @@ halts with a named reason when the confirmation is missing
 before and after numbers are in
 [`benchmark/known_ids/KNOWN_IDS.md`](https://github.com/OpenAdaptAI/OpenAdapt/blob/main/packages/flow/docs/../benchmark/known_ids/KNOWN_IDS.md).
 
+Before a step stops on a look-alike identifier, the replayer takes extra looks
+that change nothing
+([`openadapt_flow/runtime/identity_looks.py`](https://github.com/OpenAdaptAI/OpenAdapt/blob/main/packages/flow/docs/../openadapt_flow/runtime/identity_looks.py)):
+the same read on two fresh screenshots, the 2x re-read, the known-ID list when
+one is configured, and, where the surface allows it, a select-and-copy of the
+identifier's text box (`runtime.identity_copy_look`). OCR looks can't settle
+the record on their own, because a look-alike twin can read the same on every
+frame and at every size. Only two looks can: the known-ID list, and a copied
+identifier that equals a run parameter in the identity band. A look that names
+another record stops the run. Each look is recorded on the step's identity
+check.
+
+The copy look has limits. It needs a surface where selecting the identifier
+and copying it changes nothing, and a clipboard that reaches the machine Flow
+runs on (RDP or Citrix clipboard redirection). It drags across only the one
+text box that holds the identifier, and the run stops if the screen changes
+anywhere else during the look. A canvas with no selectable text has no copy
+look. A recording's own identifier is OCR text and can be a misread (the RDP
+kiosk recorded `A1001` as `Alo01`), so in a workflow that always opens the
+recorded record, the copy can stop a run but never confirm one. It confirms
+only a record chosen by a run parameter. Governed and qualification runs never
+take it. The check just before the click takes no input; it reuses the copy
+only when the identifier's pixels are unchanged since the look.
+
 Permissive `replay` may proceed on an unreadable reversible target and reports
 that condition. Governed `run` requires an affirmative live verdict for every
 identity-required admitted step; mismatch, unreadable, or abstain halts before
@@ -1156,6 +1276,39 @@ irreversible, and qualification requires its record check. An icon-only click
 that only navigates after data entry is therefore over-classified until an
 operator reclassifies it.
 
+On a pixel surface an icon-only click carries no text that names its control.
+When the recorder can move the pointer without clicking
+(`Recorder(capture_hover=True)` on a backend with `hover`), it rests the
+pointer on each click target first and keeps that frame. For a click with no
+other identity evidence, the compiler stores what changed near the target, such
+as the control's highlight or tooltip, as the step's hover evidence
+([`openadapt_flow/runtime/hover_evidence.py`](https://github.com/OpenAdaptAI/OpenAdapt/blob/main/packages/flow/docs/../openadapt_flow/runtime/hover_evidence.py)).
+At replay, on the pixel rungs, the runtime rests the pointer on the resolved
+target, waits the same 0.8 s, and compares. A different response, or a
+response where the recording saw none, stops the run before the click. A
+missing response, or one that can't be compared (another render with no
+readable text), is recorded on the step and changes nothing. A tooltip that
+opens later than the wait looks like a different response and stops the run.
+Controls that don't answer the pointer, such as most text fields, get no
+evidence this way. The browser, remote-display (Citrix and RDP client window)
+and FreeRDP backends can hover. The Aardwolf RDP transport and the native
+Windows, macOS and Linux backends can't move the pointer without a button
+yet, so they take no hover look.
+
+A pixel step is checked on one frame and clicked a moment later. Consequential
+identity-gated clicks were already bound to the exact checked frame. Every
+other pixel click now gets a check-to-click guard (`Replayer._pixel_recheck`):
+right before the click, the runtime takes a fresh frame and compares the
+target region, the identity region and the hover response with the frame the
+step was checked on. If one changed (a dialog opened, the list re-sorted), it
+doesn't click. It re-resolves the target and re-runs the identity check on
+the fresh frame, with no input, and clicks only when the next frame matches
+that one. After two re-observations that still see a change, or when the
+target or its identity can't be confirmed again, it refuses the click. Each
+change is recorded on the step (`StepResult.check_to_click`). A change smaller
+than 4 pixels, or under 24 levels per channel, doesn't count. Structured
+targets are bound by element tokens instead and aren't rechecked.
+
 A consequential click must be tied to a record before Flow delivers it. Inside
 a table row, the row is that record. An icon-only Save that floats beside a
 form (openIMIS's claim Save has no text, accessible name, or tooltip) has no
diff --git a/packages/flow/docs/design/LOCAL_EDIT_CLASSIFICATION.md b/packages/flow/docs/design/LOCAL_EDIT_CLASSIFICATION.md
index 036956b04..4b94b33fc 100644
--- a/packages/flow/docs/design/LOCAL_EDIT_CLASSIFICATION.md
+++ b/packages/flow/docs/design/LOCAL_EDIT_CLASSIFICATION.md
@@ -1,6 +1,9 @@
-# Classifying local edits without a person (proposal)
+# Classifying local edits without a person
 
-Status: proposal. Not merged; the founder decides.
+Status: approved by the founder on 2026-10-19, with a strict rule: the
+compiler classifies a step only when the recording shows no mutating request
+sent for it **and** a runtime check confirms only the expected local change.
+Anything else goes to a person.
 
 ## The problem
 
@@ -22,18 +25,38 @@ These are the same few patterns in every form-filling program, on every app.
 A person approving each one, per bundle, is busywork that trains people to
 approve without reading.
 
-## The proposal
+## The rule
 
-The compiler classifies three local-edit patterns itself, and only when the
-recording shows the action stayed local. Each classified step gets an
-automatic outcome check that halts the run if, at run time, the action did
-anything else.
+The compiler classifies five local-edit patterns itself. Every pattern needs
+all of this evidence from the recording:
 
-| Pattern | Evidence the compiler needs (all of it) | Outcome check added to the step |
+- network capture (`record --capture-network`), with no request other than
+  `GET`, `HEAD` or `OPTIONS` between the previous event and the next one;
+- URL, title and page count recorded on both sides of the action, and
+  unchanged;
+- when the recorder snapshotted the record store around the step, the two
+  snapshots equal.
+
+A recording without network capture classifies nothing.
+
+| Pattern | Step evidence | Outcome check added to the step |
 | --- | --- | --- |
-| Select-all before typing: `Control+a` / `Meta+a` | The previous step clicked a single text field (structural role `textbox`, `searchbox` or `spinbutton`); the next step types into it; URL, title and page count unchanged across the key; no write request during the key (when the recording has network capture) | `local_edit`: after the key, the focused element is still that field, and URL, title and page count are unchanged. The next step's typed-input read-back then checks the field's whole value. |
-| Confirm a typed option: `Enter` | The previous steps clicked a dropdown (role `combobox` or `listbox`) and typed an option's label (a parameter or a literal); URL, title and page count unchanged; no write request during the key (network capture **required**: `Enter` is a submission key) | `local_edit` as above, plus `field_value`: the focused dropdown shows the typed label (the run's parameter value). |
-| In-form tab: a click on a tab | Role `tab`, or a `button` whose recorded click changed only the visible panel: URL, title and page count unchanged, no write request (network capture required), and the next step acts in the same frame | `local_edit` (URL, title and page count unchanged; focus need not stay). |
+| `select_all`: `Control+a` / `Meta+a` | The previous step clicked a text field (role `textbox`, `searchbox` or `spinbutton`, with a selector); the next step types into it | `local_edit`: focus is still on that field; URL, title and page count unchanged. The next step's typed-input read-back then checks the field's whole value. |
+| `confirm_option`: `Enter` in a dropdown | The steps before clicked a dropdown (role `combobox` or `listbox`) and typed a parameter's value | `local_edit` on the dropdown, plus `field_value`: the focused dropdown shows this run's value |
+| `confirm_entry`: `Enter` in a text field | The steps before clicked a text field and typed a parameter's value | `local_edit` on the field, plus `field_value`: the focused field's value equals this run's value exactly |
+| `in_form_tab`: a tab click | Role `tab`, or a `button` whose only mined check is a region change; the next acting step is in the same frame | `local_edit` (URL, title and page count unchanged; focus may move) |
+| `dismiss_dialog`: an informational dialog's dismiss | A `button` or `link` labelled only "Continue", "Continue to ...", "Next", "Close", "OK", "Got it", "Dismiss", "Not now", "Maybe later" or "Skip for now" | `local_edit`, plus `text_absent` of the label: the dialog is gone |
+
+`continue` and `next` are write words for the risk inference, so a dismiss
+labelled with them starts irreversible. It is reconsidered only when those
+are its only write words and its risk is still the per-step keyword
+inference. A click that a later rule made irreversible (the click that
+confirms a dialog, an icon-only click presumed to save) is never
+reconsidered. Because a classified dismiss is reversible, effect mining no
+longer attaches a placeholder `record_written` to it (#1377).
+
+The runtime checks fail closed: a backend that can't read focus, the field
+value, the URL, the title or the page count fails the step.
 
 What stays the same:
 
@@ -43,7 +66,8 @@ What stays the same:
   `risk_review_required` and goes to a person, exactly as today.
 - **Write-shaped context still wins.** A key or click whose retained text
   names a consequential write (`submit`, `save`, `delete`, ...) classifies
-  irreversible before any of this runs.
+  irreversible before any of this runs. The one exception is a dismiss whose
+  only write words are `continue` or `next`, with the full evidence above.
 - **Explicit `risk_overrides` still win.**
 - **D, the duplicate-prevention (idempotency) key on the save, is untouched.**
   That is a business decision.
@@ -55,18 +79,18 @@ evidence), and has an outcome check, so `require_reviewed_action_risk`,
 tab click classified this way is in-form navigation that writes nothing, so it
 isn't consequential and isn't entity navigation; `prohibit_unarmed_clicks`
 under `clinical-write` still applies to it, so it still needs an identity
-check unless that policy exempts `local_edit` clicks (an open question below).
+check (decision 2 below).
 
 ## Why this is safe enough
 
 - The classification is backed by what the demonstration did, not by the
-  label. A key that submitted the form in the recording (a POST, a URL change)
-  is never classified.
+  label. A step that sent a write request in the recording, changed the URL,
+  title or page count, or changed the record store is never classified.
 - The outcome check runs every time. If the same key does something else at
   run time (the app changed, a different field had focus), the step fails its
   postcondition and the run halts at that step. The halt comes after the key
   was pressed, which is the residual risk: a key that, at run time only,
-  commits something. For the three patterns that requires the app to have
+  commits something. For these patterns that requires the app to have
   changed the field's behavior since the recording, and the first write it
   makes is still caught by the save's record check or by the next step's
   checks.
@@ -74,29 +98,52 @@ check unless that policy exempts `local_edit` clicks (an open question below).
   are part of the content digest), so a later edit to a classification
   changes the digest and needs a new admission.
 
-## Open questions for the founder
-
-1. Accept the residual risk above for these three patterns?
-2. Should `clinical-write`'s `prohibit_unarmed_clicks` exempt a `local_edit`
-   tab click (it writes nothing and stays in the form), or must a person or the
-   compiler still arm it with an identity check? Today it must be armed.
-3. Without network capture, `Control+a` is classified on the structural and
-   URL evidence alone (select-all in a focused text field isn't a submission
-   key). `Enter` and tab clicks need network capture. Is that the right line?
-
-## Implementation sketch
-
-- `openadapt_flow.risk.local_edit_classifications(steps, events, network)`:
-  the three rules, returning `{step_id: (explanation, evidence)}`.
-- `compile_recording` applies them after the per-step inference and before
-  `risk_overrides`, and adds the outcome checks.
-- Two postcondition kinds: `local_edit` (structural: focus and URL, title,
-  page count) and `field_value` (the focused dropdown's label equals a run
-  parameter). Both are evaluated by the runtime like the existing structural
-  kinds, and both refuse rather than pass when the backend can't observe them
-  (unlike `url_changed`, which passes unverified).
-- Qualification's draft classification reads the same evidence, so a
-  compiled `local_edit` step drafts as `reversible` instead of `unknown`.
-- Tests: each pattern classifies with full evidence; each missing piece of
-  evidence leaves the step for a person; each outcome check halts when the
-  action did something else (focus moved, URL changed, wrong option).
+## Decisions
+
+1. The residual risk above is accepted for these patterns (founder,
+   2026-10-19).
+2. `clinical-write`'s `prohibit_unarmed_clicks` still applies to a classified
+   tab click. On the OpenEMR referral, the Contact tab (`step_015`) still needs
+   an identity check or a person.
+3. Network capture is required for every pattern, `Control+a` included.
+
+## Implementation
+
+- `openadapt_flow.compiler.local_edit.local_edits(steps, events, network)`
+  returns the classified steps with their explanation and checks.
+- `compile_recording` applies them after the per-step risk inference and the
+  confirmation-dialog pairing, and before `risk_overrides`, which still win.
+  Effect mining runs after both.
+- `openadapt_flow.risk.is_local_edit` and `is_sealed_dismiss` let the run
+  gate's risk re-inference read a classified step from what the bundle seals:
+  the explanation and its runtime checks.
+- Postcondition kinds `local_edit` and `field_value`, evaluated by the
+  replayer (`_local_edit_held`, `_field_value_shown`).
+- Tests: `tests/test_local_edit_classification.py`. Each pattern has a
+  positive case and a case where a write request was sent, which must
+  refuse.
+
+## OpenEMR referral, re-admitted on this branch
+
+Run gate on the recorded referral with the API step admitted
+(`--identity subject_name=lname`), compared with `main`:
+
+| Policy | Violations on `main` | With local edits |
+| --- | --- | --- |
+| `permissive` | 12 | 1 |
+| `clinical-write` | 32 | 9 |
+
+What remains:
+
+- `step_007` (`Control+a`): OpenEMR's background
+  `POST /library/ajax/execute_background_services.php` landed in its window,
+  so the strict rule leaves it for a person. Under `clinical-write` it also
+  has no outcome check.
+- `step_015` (the Contact tab): classified, but unarmed under
+  `clinical-write`'s `prohibit_unarmed_clicks`.
+- `step_039` (Create New Patient): unarmed, no identity contract and no
+  record check on its GUI path.
+- `step_039` and `step_040`: no duplicate-prevention (idempotency) key. That
+  stays a person's choice.
+- Encryption at rest, under the default and regulated profiles: seal the
+  bundle.
diff --git a/packages/flow/openadapt_flow/compiler/local_edit.py b/packages/flow/openadapt_flow/compiler/local_edit.py
index b48858e7e..446f82543 100644
--- a/packages/flow/openadapt_flow/compiler/local_edit.py
+++ b/packages/flow/openadapt_flow/compiler/local_edit.py
@@ -2,40 +2,54 @@
 
 Proposal: docs/design/LOCAL_EDIT_CLASSIFICATION.md. A compiled program flags
 every special key and every unlabelled or navigation-shaped click for a
-person's review, because the step alone can't prove its risk. Three patterns
+person's review, because the step alone can't prove its risk. A few patterns
 recur in every form-filling program, and the recording can prove them local:
 
 - ``select_all``: Control+A (or Meta+A) in a text field, right before typing
   into it;
 - ``confirm_option``: Enter right after typing an option's label into a
   dropdown;
-- ``in_form_tab``: a click on a tab of the same form.
+- ``confirm_entry``: Enter right after typing into a text field;
+- ``in_form_tab``: a click on a tab of the same form;
+- ``dismiss_dialog``: the dismiss of an informational dialog ("Continue to
+  tasks", "Got it", "Close").
 
 A step is classified only when every piece of evidence holds: the field's
 structural role, the steps around it, URL, title and page count unchanged
-across the action, and no write request in its window (network capture is
-required for Enter and for tab clicks, since either can submit). Anything
+across the action, the record store unchanged when the recorder snapshotted
+it, and network capture showing no write request in its window. Anything
 missing or mixed leaves the step for a person. A classified step gets an
-outcome check (``local_edit``, and ``field_value`` for a dropdown) that halts
-the run when, at run time, the action did anything else.
+outcome check (``local_edit``, plus ``field_value`` after Enter, or the
+dismissed label gone after a dismiss) that halts the run when, at run time,
+the action did anything else.
 
 Model-free and deterministic.
 """
 
 from __future__ import annotations
 
+import re
 from dataclasses import dataclass, field
 from typing import Any, Literal, Optional, Sequence
 
 from openadapt_flow.ir import ActionKind, Postcondition, PostconditionKind, Step
-from openadapt_flow.risk import LOCAL_EDIT_PREFIX, is_local_edit
+from openadapt_flow.risk import (
+    DISMISS_PREFIX,
+    LOCAL_EDIT_PREFIX,
+    infer_step_risk,
+    is_local_edit,
+    only_weak_write_words,
+    step_text,
+)
 
 __all__ = ["LOCAL_EDIT_PREFIX", "LocalEdit", "is_local_edit", "local_edits"]
 TEXT_ROLES = frozenset({"textbox", "searchbox", "spinbutton"})
 CHOICE_ROLES = frozenset({"combobox", "listbox"})
 _READ_METHODS = frozenset({"GET", "HEAD", "OPTIONS"})
 
-Pattern = Literal["select_all", "confirm_option", "in_form_tab"]
+Pattern = Literal[
+    "select_all", "confirm_option", "confirm_entry", "in_form_tab", "dismiss_dialog"
+]
 
 
 @dataclass(frozen=True)
@@ -107,6 +121,73 @@ def _no_write(
     return True
 
 
+#: A dismiss control's label: it closes an informational dialog. ``continue``
+#: and ``next`` are write words for the risk inference; only these two may be
+#: reconsidered, and only with the full evidence below.
+_DISMISS_LABEL = re.compile(
+    r"^\s*(?:continue(?:\s+to\s+\w+(?:\s+\w+)?)?|next|close|ok(?:ay)?|got\s+it|"
+    r"dismiss|not\s+now|maybe\s+later|skip\s+for\s+now)\s*$",
+    re.IGNORECASE,
+)
+
+
+def _store_unchanged(event: dict[str, Any]) -> Optional[bool]:
+    """The record store snapshots around the step, when the recorder took them.
+
+    True when both were taken and are equal, False when they differ (or only
+    one was taken), None when neither was taken.
+    """
+
+    from openadapt_flow.compiler.effect_mining import SOR_AFTER_KEY, SOR_BEFORE_KEY
+
+    before, after = event.get(SOR_BEFORE_KEY), event.get(SOR_AFTER_KEY)
+    if before is None and after is None:
+        return None
+    return before is not None and before == after
+
+
+def _weak_write_dismiss(step: Step) -> bool:
+    """An irreversible click that is irreversible only for "continue" or "next".
+
+    Its risk must still be the per-step keyword inference, unchanged: a step a
+    later rule made irreversible (the click that confirms a dialog, an
+    icon-only click presumed to save) is never reconsidered, and any other
+    write word in its context still wins.
+    """
+
+    if step.action is not ActionKind.CLICK:
+        return False
+    if not _DISMISS_LABEL.match(_label(step) or ""):
+        return False
+    if not only_weak_write_words(step_text(step)):
+        return False
+    inference = infer_step_risk(step)
+    return (
+        inference.risk == "irreversible"
+        and inference.explanation == step.risk_explanation
+        and any(e.startswith("write_keyword:") for e in inference.evidence)
+    )
+
+
+def _typed_param(
+    events: Sequence[dict[str, Any]], step: Optional[Step]
+) -> Optional[str]:
+    if step is None or step.action is not ActionKind.TYPE:
+        return None
+    i = _event_index(step)
+    if i is None or i >= len(events):
+        return None
+    value = events[i].get("param") or step.param
+    return value if isinstance(value, str) and value else None
+
+
+def _frame(step: Optional[Step]) -> Optional[list[str]]:
+    target = _structural(step)
+    if target is None:
+        return None
+    return list(target.frame_path or [])
+
+
 def local_edits(
     steps: Sequence[Step],
     events: Sequence[dict[str, Any]],
@@ -115,12 +196,22 @@ def local_edits(
     """The steps the recording proves are local edits, with their checks.
 
     ``network`` is the recording's captured requests (``network.jsonl``
-    lines), or None when the recording has no capture.
+    lines), or None when the recording has no capture. Every pattern needs
+    both halves of the evidence:
+
+    - the recording shows no mutating request in the step's window (network
+      capture is required), URL, title and page count unchanged, and, when
+      the recorder snapshotted the record store, the store unchanged;
+    - a check that the step made only the expected local change, which the
+      runtime runs every time (focus and field value, or the page unchanged
+      and the dialog gone).
+
+    Anything short of that is left for a person.
     """
 
     found: list[LocalEdit] = []
     for k, step in enumerate(steps):
-        if step.risk == "irreversible" or step.effects or step.api_binding:
+        if step.effects or step.api_binding:
             continue
         i = _event_index(step)
         if i is None or i >= len(events):
@@ -128,122 +219,141 @@ def local_edits(
         event = events[i]
         if not _unchanged(event):
             continue
+        if _no_write(events, i, network) is not True:
+            continue
+        if _store_unchanged(event) is False:
+            continue
+        if step.risk == "irreversible" and not _weak_write_dismiss(step):
+            continue
         prev = steps[k - 1] if k > 0 else None
+        before_prev = steps[k - 2] if k > 1 else None
         nxt = steps[k + 1] if k + 1 < len(steps) else None
-        no_write = _no_write(events, i, network)
-        if step.action is ActionKind.KEY:
-            chord = _key_chord(step)
-            target = _structural(prev)
-            if (
-                chord in {"a+control", "a+meta"}
-                and prev is not None
-                and prev.action is ActionKind.CLICK
-                and target is not None
-                and target.selector
-                and (target.role or "").lower() in TEXT_ROLES
-                and nxt is not None
-                and nxt.action is ActionKind.TYPE
-                and no_write is not False
-            ):
-                found.append(
-                    LocalEdit(
-                        step.id,
-                        "select_all",
-                        f"{LOCAL_EDIT_PREFIX} selects the text of the field "
-                        f"{prev.id} clicked, before {nxt.id} types into it; "
-                        "URL, title and page count unchanged in the recording"
-                        + ("; no write request" if no_write else ""),
-                        [
-                            Postcondition(
-                                kind=PostconditionKind.LOCAL_EDIT,
-                                field_selector=target.selector,
-                            )
-                        ],
-                    )
-                )
-                continue
-            before_prev = steps[k - 2] if k > 1 else None
-            choice = _structural(before_prev)
-            typed_param = (
-                events[_event_index(prev)].get("param")
-                if prev is not None
-                and _event_index(prev) is not None
-                and _event_index(prev) < len(events)  # type: ignore[operator]
-                else None
-            )
-            if (
-                chord == "enter"
-                and prev is not None
-                and prev.action is ActionKind.TYPE
-                and before_prev is not None
-                and before_prev.action is ActionKind.CLICK
-                and choice is not None
-                and choice.selector
-                and (choice.role or "").lower() in CHOICE_ROLES
-                and isinstance(typed_param, str)
-                and typed_param
-                and no_write is True
-            ):
-                found.append(
-                    LocalEdit(
-                        step.id,
-                        "confirm_option",
-                        f"{LOCAL_EDIT_PREFIX} confirms the option typed into the "
-                        f"dropdown {before_prev.id} clicked; URL, title and page "
-                        "count unchanged and no write request in the recording",
-                        [
-                            Postcondition(
-                                kind=PostconditionKind.LOCAL_EDIT,
-                                field_selector=choice.selector,
-                            ),
-                            Postcondition(
-                                kind=PostconditionKind.FIELD_VALUE,
-                                param=typed_param,
-                            ),
-                        ],
-                    )
+        edit = (
+            _key_edit(step, prev, before_prev, nxt, events)
+            if step.action is ActionKind.KEY
+            else _click_edit(step, steps, k)
+            if step.action is ActionKind.CLICK
+            else None
+        )
+        if edit is not None:
+            found.append(edit)
+    return found
+
+
+_EVIDENCE = "URL, title and page count unchanged and no write request in the recording"
+
+
+def _key_edit(
+    step: Step,
+    prev: Optional[Step],
+    before_prev: Optional[Step],
+    nxt: Optional[Step],
+    events: Sequence[dict[str, Any]],
+) -> Optional[LocalEdit]:
+    chord = _key_chord(step)
+    clicked = _structural(prev)
+    if (
+        chord in {"a+control", "a+meta"}
+        and prev is not None
+        and prev.action is ActionKind.CLICK
+        and clicked is not None
+        and clicked.selector
+        and (clicked.role or "").lower() in TEXT_ROLES
+        and nxt is not None
+        and nxt.action is ActionKind.TYPE
+    ):
+        # The next step's exact typed-input read-back checks the field's
+        # whole value; this one checks focus stayed in the field.
+        return LocalEdit(
+            step.id,
+            "select_all",
+            f"{LOCAL_EDIT_PREFIX} selects the text of the field {prev.id} "
+            f"clicked, before {nxt.id} types into it; {_EVIDENCE}",
+            [
+                Postcondition(
+                    kind=PostconditionKind.LOCAL_EDIT,
+                    field_selector=clicked.selector,
                 )
-            continue
-        if step.action is ActionKind.CLICK:
-            target = _structural(step)
-            role = (target.role or "").lower() if target is not None else ""
-            # The next step that acts on a target (a scroll or wait between
-            # them has none) must be in the same frame: the form is still
-            # there.
-            acting = next(
-                (
-                    later
-                    for later in steps[k + 1 : k + 4]
-                    if later.action not in {ActionKind.SCROLL, ActionKind.WAIT}
+            ],
+        )
+    field = _structural(before_prev)
+    typed = _typed_param(events, prev)
+    role = (field.role or "").lower() if field is not None else ""
+    if (
+        chord == "enter"
+        and typed is not None
+        and before_prev is not None
+        and before_prev.action is ActionKind.CLICK
+        and field is not None
+        and field.selector
+        and role in (CHOICE_ROLES | TEXT_ROLES)
+    ):
+        kind = "dropdown" if role in CHOICE_ROLES else "field"
+        return LocalEdit(
+            step.id,
+            "confirm_option" if role in CHOICE_ROLES else "confirm_entry",
+            f"{LOCAL_EDIT_PREFIX} confirms the value typed into the {kind} "
+            f"{before_prev.id} clicked; {_EVIDENCE}",
+            [
+                Postcondition(
+                    kind=PostconditionKind.LOCAL_EDIT, field_selector=field.selector
                 ),
-                None,
-            )
-            nxt = acting
-            same_frame = (
-                target is not None
-                and acting is not None
-                and _structural(acting) is not None
-                and list(_structural(acting).frame_path) == list(target.frame_path)
-            )
-            if (
-                target is not None
-                and role in {"tab", "button"}
-                and no_write is True
-                and same_frame
-                and (role == "tab" or not step.expect or _region_only(step))
-            ):
-                found.append(
-                    LocalEdit(
-                        step.id,
-                        "in_form_tab",
-                        f"{LOCAL_EDIT_PREFIX} switches the panel of the same form "
-                        f"({role}); URL, title and page count unchanged, no write "
-                        f"request, and {nxt.id if nxt else 'the next step'} acts in "
-                        "the same frame in the recording",
-                        [Postcondition(kind=PostconditionKind.LOCAL_EDIT)],
-                    )
-                )
-    return found
+                Postcondition(kind=PostconditionKind.FIELD_VALUE, param=typed),
+            ],
+        )
+    return None
+
+
+def _label(step: Step) -> Optional[str]:
+    target = _structural(step)
+    if target is not None and target.name:
+        return str(target.name)
+    return step.anchor.ocr_text if step.anchor is not None else None
+
+
+def _click_edit(step: Step, steps: Sequence[Step], k: int) -> Optional[LocalEdit]:
+    target = _structural(step)
+    if target is None:
+        return None
+    role = (target.role or "").lower()
+    label = _label(step) or ""
+    if role in {"button", "link"} and _DISMISS_LABEL.match(label):
+        # An informational dialog's dismiss (MockMed's What's New "Continue
+        # to tasks"): the page stays, and the control is gone afterwards.
+        return LocalEdit(
+            step.id,
+            "dismiss_dialog",
+            f"{DISMISS_PREFIX} ({label.strip()!r}); {_EVIDENCE}",
+            [
+                Postcondition(kind=PostconditionKind.LOCAL_EDIT),
+                Postcondition(kind=PostconditionKind.TEXT_ABSENT, text=label.strip()),
+            ],
+        )
+    # The next step that acts on a target (a scroll or wait between them has
+    # none) must be in the same frame: the form is still there.
+    acting = next(
+        (
+            later
+            for later in steps[k + 1 : k + 4]
+            if later.action not in {ActionKind.SCROLL, ActionKind.WAIT}
+        ),
+        None,
+    )
+    if (
+        role in {"tab", "button"}
+        and acting is not None
+        and _frame(acting) is not None
+        and _frame(acting) == _frame(step)
+        and (role == "tab" or not step.expect or _region_only(step))
+    ):
+        return LocalEdit(
+            step.id,
+            "in_form_tab",
+            f"{LOCAL_EDIT_PREFIX} switches the panel of the same form ({role}), "
+            f"and {acting.id} acts in the same frame; {_EVIDENCE}",
+            [Postcondition(kind=PostconditionKind.LOCAL_EDIT)],
+        )
+    return None
 
 
 def _region_only(step: Step) -> bool:
diff --git a/packages/flow/openadapt_flow/risk.py b/packages/flow/openadapt_flow/risk.py
index 04c472650..f3b72f4be 100644
--- a/packages/flow/openadapt_flow/risk.py
+++ b/packages/flow/openadapt_flow/risk.py
@@ -81,6 +81,31 @@ def is_local_edit(step: Step) -> bool:
     )
 
 
+#: The dismiss of an informational dialog. Its label may carry the one pair
+#: of write words ("continue", "next") a dismiss commonly uses; any other
+#: write word keeps the step irreversible.
+DISMISS_PREFIX = LOCAL_EDIT_PREFIX + " dismisses an informational dialog"
+_WEAK_WRITE_RE = re.compile(r"^(?:continue(?:s|d|ing)?|next)$", re.IGNORECASE)
+
+
+def only_weak_write_words(text: str) -> bool:
+    """Every write word in ``text`` is "continue" or "next" (or there is none)."""
+
+    return all(_WEAK_WRITE_RE.match(m.group(0)) for m in _WRITE_RE.finditer(text))
+
+
+def is_sealed_dismiss(step: Step) -> bool:
+    """A local-edit dismiss whose checks (page unchanged, label gone) are sealed."""
+
+    return bool(
+        is_local_edit(step)
+        and (step.risk_explanation or "").startswith(DISMISS_PREFIX)
+        and any(p.kind is PostconditionKind.TEXT_ABSENT and p.text for p in step.expect)
+        and only_weak_write_words(step_text(step))
+        and _matched_token(_FILE_WRITE_RE, step_text(step)) is None
+    )
+
+
 @dataclass(frozen=True)
 class RiskInference:
     """Compile-time classification plus its qualification disposition."""
@@ -751,6 +776,16 @@ def infer_step_risk(
             ),
             requires_review=True,
         )
+    if (
+        write_keyword is not None
+        and step.action is ActionKind.CLICK
+        and is_sealed_dismiss(step)
+    ):
+        return RiskInference(
+            "reversible",
+            (step.risk_explanation or LOCAL_EDIT_PREFIX)[:512],
+            (action_evidence, "pattern:local_edit"),
+        )
     if write_keyword is not None and step.action in {
         ActionKind.CLICK,
         ActionKind.DOUBLE_CLICK,
diff --git a/packages/flow/openadapt_flow/runtime/replayer.py b/packages/flow/openadapt_flow/runtime/replayer.py
index de6cfcc8b..e18ca7827 100644
--- a/packages/flow/openadapt_flow/runtime/replayer.py
+++ b/packages/flow/openadapt_flow/runtime/replayer.py
@@ -16986,24 +16986,35 @@ def _local_edit_held(self, pc: Any, start_state: dict[str, Any]) -> bool:
         return True
 
     def _field_value_shown(self, pc: Any) -> bool:
-        """The focused dropdown shows this run's value of ``pc.param``."""
+        """The focused field shows this run's value of ``pc.param``.
+
+        A dropdown's selected label matches up to spacing and case; a text
+        field's value must match exactly. Unobservable is a failure.
+        """
 
         params = getattr(self, "_current_params", None) or {}
         if not pc.param or pc.param not in params:
             return False
-        reader = getattr(self.backend, "focused_select_label", None)
-        if not callable(reader):
-            return False
-        try:
-            shown = reader()
-        except Exception:  # noqa: BLE001 - unobservable is a failure
-            return False
+        expected = runtime_param_text(params[pc.param])
+
+        def read(name: str) -> Optional[str]:
+            reader = getattr(self.backend, name, None)
+            if not callable(reader):
+                return None
+            try:
+                value = reader()
+            except Exception:  # noqa: BLE001 - unobservable is a failure
+                return None
+            return value if isinstance(value, str) else None
 
         def squash(value: str) -> str:
             return " ".join(value.split()).casefold()
 
-        expected = runtime_param_text(params[pc.param])
-        return isinstance(shown, str) and squash(shown) == squash(expected)
+        label = read("focused_select_label")
+        if label is not None:
+            return squash(label) == squash(expected)
+        value = read("focused_text_value")
+        return value is not None and value == expected
 
     @staticmethod
     def _describe_postcondition(pc: Any) -> str:
diff --git a/packages/flow/tests/test_local_edit_classification.py b/packages/flow/tests/test_local_edit_classification.py
index 24c61879c..755e63e2c 100644
--- a/packages/flow/tests/test_local_edit_classification.py
+++ b/packages/flow/tests/test_local_edit_classification.py
@@ -145,11 +145,23 @@ def test_select_all_without_its_evidence_stays_with_a_person(
     assert local_edits(steps, events, network=network) == [], why
 
 
-def test_select_all_needs_no_network_capture():
+def test_select_all_needs_network_capture():
     steps = [_click(0, "#lname", "textbox"), _key(1, "Control+a"), _type(2, "lname")]
-    assert _ids(local_edits(steps, _events(3), network=None)) == {
-        "step_001": "select_all"
-    }
+    assert local_edits(steps, _events(3), network=None) == []
+
+
+def test_select_all_with_a_write_request_sent_stays_with_a_person():
+    steps = [_click(0, "#lname", "textbox"), _key(1, "Control+a"), _type(2, "lname")]
+    sent = [{"method": "PUT", "t": 1.5, "url": URL + "/draft"}]
+    assert local_edits(steps, _events(3), network=sent) == []
+
+
+def test_a_changed_record_store_stays_with_a_person():
+    steps = [_click(0, "#lname", "textbox"), _key(1, "Control+a"), _type(2, "lname")]
+    events = _events(3, e1={"sor_before": {"n": 1}, "sor_after": {"n": 2}})
+    assert local_edits(steps, events, network=[]) == []
+    same = _events(3, e1={"sor_before": {"n": 1}, "sor_after": {"n": 1}})
+    assert _ids(local_edits(steps, same, network=[])) == {"step_001": "select_all"}
 
 
 # -- Enter on a typed dropdown option ---------------------------------------------------
@@ -177,10 +189,30 @@ def test_enter_needs_network_capture_and_no_write():
     assert _dropdown(e2={"title_after": "Saved"}) == []
 
 
-def test_enter_in_a_text_field_stays_with_a_person():
+def _entry(network: Optional[list] = None, **changes):
     steps = [_click(0, "#q", "textbox"), _type(1, "q"), _key(2, "Enter")]
-    events = _events(3, e1={"param": "q"})
-    assert local_edits(steps, events, network=[]) == []
+    events = _events(3, e1={"param": "q"}, **changes)
+    return local_edits(steps, events, network=[] if network is None else network)
+
+
+def test_enter_after_typing_into_a_text_field_is_a_local_edit():
+    (edit,) = _entry()
+    assert edit.step_id == "step_002" and edit.pattern == "confirm_entry"
+    kinds = [p.kind for p in edit.postconditions]
+    assert kinds == [PostconditionKind.LOCAL_EDIT, PostconditionKind.FIELD_VALUE]
+    assert edit.postconditions[0].field_selector == "#q"
+    assert edit.postconditions[1].param == "q"
+
+
+def test_enter_in_a_text_field_with_a_write_request_sent_stays_with_a_person():
+    assert _entry(network=[{"method": "POST", "t": 2.4, "url": URL}]) == []
+    steps = [_click(0, "#q", "textbox"), _type(1, "q"), _key(2, "Enter")]
+    assert local_edits(steps, _events(3, e1={"param": "q"}), network=None) == []
+
+
+def test_enter_after_a_literal_or_nothing_typed_stays_with_a_person():
+    steps = [_click(0, "#q", "textbox"), _key(1, "Enter")]
+    assert local_edits(steps, _events(2), network=[]) == []
 
 
 # -- in-form tabs -------------------------------------------------------------------------
@@ -202,6 +234,24 @@ def test_a_tab_click_needs_capture_the_same_frame_and_no_write():
     assert local_edits([steps[0], other], _events(2), network=[]) == []
 
 
+def test_a_tab_role_click_in_the_same_frame_is_a_local_edit():
+    steps = [
+        _click(0, "#tab-contact", "tab", "Contact"),
+        _click(1, "#street", "textbox"),
+    ]
+    (edit,) = local_edits(steps, _events(2), network=[])
+    assert edit.pattern == "in_form_tab"
+
+
+def test_a_tab_click_with_a_write_request_sent_stays_with_a_person():
+    steps = [
+        _click(0, "#tab-contact", "tab", "Contact"),
+        _click(1, "#street", "textbox"),
+    ]
+    sent = [{"method": "PATCH", "t": 0.8, "url": URL + "/autosave"}]
+    assert local_edits(steps, _events(2), network=sent) == []
+
+
 def test_a_write_shaped_click_is_never_a_local_edit():
     save = _click(0, None, "button", "Save")
     save.risk = "irreversible"
@@ -209,6 +259,71 @@ def test_a_write_shaped_click_is_never_a_local_edit():
     assert local_edits(steps, _events(2), network=[]) == []
 
 
+# -- the dismiss of an informational dialog (#1377) ------------------------------------------
+
+
+def _infer(step: Step) -> Step:
+    inference = infer_step_risk(step)
+    step.risk = inference.risk
+    step.risk_explanation = inference.explanation
+    step.risk_review_required = inference.requires_review
+    return step
+
+
+def _whats_new() -> list[Step]:
+    # MockMed's What's New notice: "Continue to tasks" closes it, the page stays.
+    dismiss = _infer(_click(0, "#notice-continue", "button", "Continue to tasks"))
+    assert dismiss.risk == "irreversible"  # "continue" is a write word
+    return [dismiss, _click(1, "#task-search", "textbox", "Search tasks")]
+
+
+def test_dismissing_an_informational_dialog_is_a_local_edit():
+    (edit,) = local_edits(_whats_new(), _events(2), network=[])
+    assert edit.step_id == "step_000" and edit.pattern == "dismiss_dialog"
+    local, gone = edit.postconditions
+    assert local.kind is PostconditionKind.LOCAL_EDIT and local.field_selector is None
+    assert gone.kind is PostconditionKind.TEXT_ABSENT
+    assert gone.text == "Continue to tasks"
+
+
+def test_a_dismiss_with_a_write_request_sent_stays_with_a_person():
+    sent = [{"method": "POST", "t": 0.4, "url": URL + "/notices/seen"}]
+    assert local_edits(_whats_new(), _events(2), network=sent) == []
+    assert local_edits(_whats_new(), _events(2), network=None) == []
+    moved = _events(2, e0={"url_after": URL + "/tasks"})
+    assert local_edits(_whats_new(), moved, network=[]) == []
+
+
+@pytest.mark.parametrize(
+    "name", ["Continue to checkout", "Continue and save", "Next: submit", "Save"]
+)
+def test_a_dismiss_shaped_label_with_another_write_word_stays_irreversible(name):
+    steps = [_infer(_click(0, "#b", "button", name)), _click(1, "#x", "textbox")]
+    assert steps[0].risk == "irreversible"
+    assert local_edits(steps, _events(2), network=[]) == []
+
+
+def test_the_click_that_confirms_a_dialog_is_never_reconsidered():
+    ok = _infer(_click(0, "#ok", "button", "OK"))
+    ok.risk = "irreversible"
+    ok.risk_explanation = "confirms the dialog opened by step_000; this click saves"
+    steps = [ok, _click(1, "#x", "textbox")]
+    assert local_edits(steps, _events(2), network=[]) == []
+
+
+def test_the_risk_reinference_reads_a_sealed_dismiss():
+    steps = _whats_new()
+    (edit,) = local_edits(steps, _events(2), network=[])
+    dismiss = steps[0]
+    dismiss.risk_explanation = edit.explanation
+    dismiss.expect = list(edit.postconditions)
+    inference = infer_step_risk(dismiss)
+    assert inference.risk == "reversible" and not inference.requires_review
+    # Without the label-gone check the write word wins again.
+    dismiss.expect = [edit.postconditions[0]]
+    assert infer_step_risk(dismiss).risk == "irreversible"
+
+
 # -- risk, tags and the outcome checks ------------------------------------------------------
 
 
@@ -260,9 +375,11 @@ def test_unset_local_edit_fields_serialize_as_before():
 
 
 class _Backend:
-    def __init__(self, *, url=URL, focused=True, label="Massachusetts") -> None:
+    def __init__(
+        self, *, url=URL, focused=True, label="Massachusetts", text=None
+    ) -> None:
         self.url, self.page_title, self.page_count = url, "Form", 1
-        self._focused, self._label = focused, label
+        self._focused, self._label, self._text = focused, label, text
 
     def focused_element_matches(self, selector):
         return self._focused
@@ -270,6 +387,9 @@ def focused_element_matches(self, selector):
     def focused_select_label(self):
         return self._label
 
+    def focused_text_value(self):
+        return self._text
+
 
 def _replayer(backend):
     from openadapt_flow.runtime.replayer import Replayer
@@ -315,3 +435,112 @@ def test_the_field_value_check_reads_the_dropdown(label, passes):
     pc = Postcondition(kind=PostconditionKind.FIELD_VALUE, param="state")
     replayer = _replayer(_Backend(label=label))
     assert replayer._postcondition_passes(pc, b"", None, START) is passes
+
+
+@pytest.mark.parametrize(
+    "text, passes",
+    [
+        ("Massachusetts", True),
+        ("massachusetts", False),
+        ("Massachusetts ", False),
+        (None, False),
+    ],
+)
+def test_the_field_value_check_reads_a_text_field_exactly(text, passes):
+    pc = Postcondition(kind=PostconditionKind.FIELD_VALUE, param="state")
+    replayer = _replayer(_Backend(label=None, text=text))
+    assert replayer._postcondition_passes(pc, b"", None, START) is passes
+
+
+# -- compiled end to end: the What's New dismiss gets no record_written (#1377) ---------------
+
+
+def _whats_new_recording(tmp_path, *, dismiss_post_t: Optional[float]):
+    import json
+
+    from openadapt_flow.compiler.effect_mining import SOR_AFTER_KEY, SOR_BEFORE_KEY
+
+    page = {
+        "url_before": URL,
+        "url_after": URL,
+        "title_before": "MockMed",
+        "title_after": "MockMed",
+        "pages_before": 1,
+        "pages_after": 1,
+    }
+    chart = [{"id": "e1", "type": "Encounter", "patient_id": "p1"}]
+    events = [
+        {
+            "i": 0,
+            "kind": "click",
+            "x": 129,
+            "y": 236,
+            "t": 1.0,
+            "structural": {
+                "selector": "#notice-continue",
+                "role": "button",
+                "name": "Continue to tasks",
+            },
+            SOR_BEFORE_KEY: [],
+            SOR_AFTER_KEY: [],
+            **page,
+        },
+        {
+            "i": 1,
+            "kind": "click",
+            "x": 300,
+            "y": 400,
+            "t": 3.0,
+            "structural": {
+                "selector": "#save",
+                "role": "button",
+                "name": "Save encounter",
+            },
+            SOR_BEFORE_KEY: [],
+            SOR_AFTER_KEY: chart,
+            **page,
+        },
+    ]
+    rec = tmp_path / "recording"
+    (rec / "frames").mkdir(parents=True)
+    from PIL import Image
+
+    for i in range(len(events)):
+        for side in ("before", "after"):
+            Image.new("RGB", (1280, 800), "white").save(
+                rec / "frames" / f"{i:04d}_{side}.png"
+            )
+    (rec / "events.jsonl").write_text("".join(json.dumps(e) + "\n" for e in events))
+    (rec / "meta.json").write_text(json.dumps({"params": {}}))
+    lines = [{"method": "POST", "url": URL + "/api/encounters", "t": 3.2, "seq": 1}]
+    if dismiss_post_t is not None:
+        lines.insert(
+            0,
+            {"method": "POST", "url": URL + "/api/seen", "t": dismiss_post_t, "seq": 0},
+        )
+    header = {"schema": "openadapt.network-capture/1", "exchanges": len(lines)}
+    (rec / "network.jsonl").write_text(
+        "".join(json.dumps(x) + "\n" for x in [header, *lines])
+    )
+    return rec
+
+
+def test_a_compiled_whats_new_dismiss_gets_no_record_written(tmp_path):
+    from openadapt_flow.compiler.compile import compile_recording
+    from openadapt_flow.runtime.effects import EffectKind
+
+    rec = _whats_new_recording(tmp_path, dismiss_post_t=None)
+    wf = compile_recording(rec, tmp_path / "bundle", name="notice", mine_effects=True)
+    dismiss, save = wf.steps
+    assert dismiss.risk == "reversible" and not dismiss.risk_review_required
+    assert is_local_edit(dismiss) and dismiss.effects == []
+    assert EffectKind.RECORD_WRITTEN in [e.kind for e in save.effects]
+
+
+def test_a_compiled_dismiss_that_sent_a_write_keeps_its_risk(tmp_path):
+    from openadapt_flow.compiler.compile import compile_recording
+
+    rec = _whats_new_recording(tmp_path, dismiss_post_t=1.1)
+    wf = compile_recording(rec, tmp_path / "bundle", name="notice", mine_effects=True)
+    dismiss = wf.steps[0]
+    assert dismiss.risk == "irreversible" and not is_local_edit(dismiss)