@codyswann/lisa 2.263.0 → 2.264.0

package/plugins/src/base/rules/reference/claim-evidence-mapping.md

@@ -80,12 +80,12 @@ defines the names; it stores nothing:
 | `required_evidence_kinds` | the evidence kind(s) that reach that boundary, from the `verification` artifact-type set |
 
 A claim whose `required_evidence_kinds` has no captured, reaching artifact is **Not established** —
-the concept is named here and defined fully, with its evidence templates, in **BCE-3 (#1837)**; do
-not assume that section is present in this branch. Artifact identity — what makes two captured
-artifacts the same or different — is pinned in **BCE-4 (#1838)**, and the conservative default
-bucket for a security-sensitive claim is set in **BCE-5 (#1839)**. Each is named here as the field
-BCE-2's schema will carry; none is defined by this contract. Each ships with that ticket — do not
-assume its section is present in this branch.
+defined in full, with its evidence templates, in the section below. Artifact identity — what makes
+two captured artifacts the same or different — is defined in the *Artifact identity* section below
+(shipped by BCE-4, #1838). The conservative default bucket for a security-sensitive claim is set in
+**BCE-5 (#1839)** — named here as a field BCE-2's schema carries, not defined by this contract, and
+it ships with that ticket. Where such a sibling surface is not installed in a given branch, name what
+you can and continue.
 
 ### Worked example
 
@@ -114,13 +114,139 @@ Claim: "The service is deployed and healthy."
                       response from the target environment.
 ```
 
+## Artifact identity — what the evidence was collected against
+
+A claim reaches only as far as its evidence's *kind*; it applies only to the *artifact* that evidence
+was collected against. **Artifact identity is what makes two captured artifacts the same or
+different**: one repository, at one commit, in one environment, at one moment. Evidence that does not
+say which artifact it observed is not evidence about anything in particular — it silently transfers
+to whatever ships next, which is exactly how an auto-merge race ships code no verification ever
+touched.
+
+Identity is carried in two places, and they must agree:
+
+| Where | Field | What it pins |
+|---|---|---|
+| `artifact` (once per verdict) | `repository` | the `owner/repo` the run observed |
+| | `base_sha` | the base the change was measured against |
+| | `head_sha` | **the commit the verification actually observed** — required for a v2 pass |
+| | `build_id` | the build/run the evidence came from, where one exists |
+| | `environment` | where it ran (local, preview, staging, production) |
+| | `observed_at` | when the run observed it (ISO-8601 UTC) |
+| `evidence[]` (per artifact) | `artifact_head_sha` | the `head_sha` in force **when that artifact was captured** |
+| | `sha256` | content digest of the committed evidence file |
+| | `captured_at` | when that artifact was captured (ISO-8601 UTC) |
+
+`head_sha` pins the *build*; `sha256` pins the *bytes*. Together they answer both identity questions:
+"which artifact was this collected against" and "is this still the artifact that was collected". The
+`sha256` + commit-ref discipline is the same one Lisa's upstream-evidence manifest already uses — it
+is cited as prior art here, not reinvented.
+
+### Two identity failures, both loud
+
+- **`artifact_mismatch`** — an `evidence[]` entry whose `artifact_head_sha` differs from the verdict's
+  `artifact.head_sha`. The evidence describes a different build than the one the verdict claims. The
+  identity check fails **loudly, naming both SHAs** (the evidence's and the verdict's) so an operator
+  can see which build each half is talking about.
+- **`evidence_digest_mismatch`** — on read, recompute the `sha256` of each committed evidence file. If
+  the bytes no longer match the recorded digest, the artifact has changed since it was recorded: the
+  check fails, it names the evidence id, and blocks completion. A digest that cannot be recomputed
+  (file absent) is the same failure.
+
+Neither failure is ever summarized as "verification failed". Name the field, the ids, and both SHAs —
+a person who does not code reads this at the gate (`factory-model` rule 5). Both checks are
+**advisory-first**: reported to the operator but non-blocking until
+`verification.gate.enforceBoundaries` is `true` in `.lisa.config.json` — the same ratchet flag the
+boundary checks and the Stop-hook gate ride.
+
+### The merge race — one definition, two guards
+
+"The artifact that shipped" is already defined once, in `lisa-drive-pr-to-merge`: the **ancestry**
+check (is the verified commit an ancestor of the merged base branch, and is the merge commit's parent
+that verified head rather than a stale one) **plus** the **deploy-run** check (a deploy/release run
+actually fired for the merge SHA or an including descendant). Cite that definition; never write a
+second one. Identity reconciliation is the same definition read from the evidence side:
+
+- Evidence collected on a **pre-merge head** is valid for the merge commit **only when that head is a
+  parent of the merge** — i.e. it satisfies that skill's ancestry check against the merged head. If a
+  late commit raced past the merge, the merged head is not the verified one and the evidence does not
+  transfer.
+- Ancestry alone is never enough. That skill's rule stands unchanged here: **never report shipped on
+  ancestry alone** — the deploy-run check must also pass before completion is declared.
+- On mismatch (`artifact.head_sha` ≠ the reconciled merge SHA), completion is not declared. Flag the
+  mismatch naming both SHAs and **re-run verification against the merged head**; the re-run's verdict
+  is what may declare completion.
+
+Two guards, one definition — so they cannot disagree about what shipped.
+
+## The "Not established" section — required, never omitted
+
+Every report that asserts something was verified also states, in the same breath, **what it did not
+establish**. This is one section, it is **required**, and it is **never omitted and never blank** —
+on the evidence comment, in the committed `evidence/<ticket>/verdict.json`, and in the
+`verification-status.json` verdict BCE-2's gate reads.
+
+**Where it appears and what it says**
+
+| Surface | Shape |
+|---|---|
+| Evidence comment (tracker + PR `## Evidence` section) | a `## Not established` heading, one plain-language bullet per item |
+| `evidence/<ticket>/verdict.json` | `not_established: []` plus `not_established_reviewed: true` |
+| `.lisa/verification-status.json` (schema v2) | per-claim `not_established[]` plus the top-level `not_established_reviewed` flag |
+
+**The empty case is not the omitted case.** A verification that genuinely left nothing unproved still
+renders the heading, with the single line:
+
+```text
+## Not established
+
+None outstanding — reviewed
+```
+
+An absent heading, or a heading with nothing under it, is a defect — it is indistinguishable from
+never having asked the question. The list may be empty; the section may not be blank.
+
+**Machine-readable semantics (as shipped by BCE-2, #1836).** `not_established` is the list — it may
+be empty. `not_established_reviewed` is the boolean attestation that the list was actually
+reviewed — **the flag may never be omitted**. That asymmetry is the whole mechanism: an empty list
+plus a present flag means "we looked and found nothing outstanding"; an absent flag means nobody
+looked. The Stop-hook gate treats an absent flag as a v2 contract violation, reported to stderr and
+**advisory** until `verification.gate.enforceBoundaries` is `true` in `.lisa.config.json` (the same
+ratchet flag the boundary checks ride); evidence surfaces refuse the post on the same terms.
+
+**What belongs under the heading** — written in operator voice (`factory-model` rule 5: a person who
+does not code reads this at the gate), not in engineering shorthand:
+
+- **Boundaries not exercised** — a claim's boundary that no captured artifact reached. *"The checkout
+  button was proved in the browser; the order's persisted row was never queried, so the `data`
+  boundary is not established."*
+- **Environments not tested** — where it was and was not run. *"Checked on production Chrome at
+  1440×900 only. Not checked on mobile Safari, and not checked against the staging database."*
+- **Claims consciously out of scope** — deliberately excluded behavior, named so nobody infers it.
+  *"Refunds were not touched or tested; this change covers new orders only."*
+- **Anything a green quality check might be mistaken for proving.** *"Unit tests pass for the submit
+  handler. That establishes the code-unit boundary only — it is not evidence the button works."*
+
+Each item names the thing, not a category: "not tested on mobile Safari" is usable at a gate; "some
+environments untested" is not.
+
+### Philosophical precedent for this section
+
+This generalizes `lisa-improve-harness`'s **`Known limits`** field — a required, never-empty line on
+every result record. That skill says it plainly:
+*"A record with nothing in it is invalid on its face"* — because a single-trajectory loop always has
+limits. The same is true of any verification:
+it ran somewhere, on something, once. `Known limits` (one record) and `not_established` (every claim
+in the factory) are the same discipline with the same never-empty rule; read either and you should
+recognize the other.
+
 ## Philosophical precedent
 
 This generalizes the **bounded-claim discipline** of `lisa-improve-harness`: one trajectory supports
 one trajectory's claim, and a result record may claim only what its cited evidence reaches. Here the
 same discipline is applied to every claim in the factory — a claim reaches exactly as far as the
-*kind* of evidence behind it, and no further. BCE-3 generalizes the *Not established* half of that
-discipline into a first-class report state.
+*kind* of evidence behind it, and no further. The *Not established* half of that discipline is a
+first-class report state — see the required, never-omitted section above.
 
 ## No behavior change; degrade, never block
 

package/plugins/src/base/rules/reference/verification.md

@@ -151,6 +151,32 @@ Do not invent types inline; if none fits, propose extending this table. The lega
 
 The manifest is the single source of truth for "what evidence is required": authored once in the Validation Journey, enforced at write time, replayed during `tracker-journey` (which captures each artifact **in its declared type**), and checked again before the ticket closes. There is no second list to keep in sync.
 
+### Every evidence surface names what it did NOT establish
+
+An evidence comment that lists only what passed is unreadable at a gate: a journey that skipped an edge state looks exactly like one that covered it. So every evidence comment — and the committed `evidence/<ticket>/verdict.json` — carries two extra sections, defined in full by the `claim-evidence-mapping` rule:
+
+- **Artifact identity** — what the evidence was collected against, as values rather than placeholders: the `repository`, the `head_sha` the run observed, the `environment`, and per artifact its `sha256` digest and `captured_at`. Defined in full by the `claim-evidence-mapping` rule.
+- **Not established** — a **required, never-omitted** heading listing what the verification did *not* prove: boundaries not exercised, environments not tested, behavior consciously out of scope. When nothing is outstanding it still renders, reading `None outstanding — reviewed`. It is never blank.
+
+The committed verdict carries the machine-readable half:
+
+```
+evidence/<ticket>/verdict.json
+  not_established: []            # what was NOT proved; may be empty
+  not_established_reviewed: true # attests the list was reviewed; may NEVER be omitted
+  artifact: { repository, base_sha, head_sha, build_id, environment, observed_at }
+  evidence: [ { evidence_id, kind, locator,
+                artifact_head_sha,   # the head_sha in force when THIS artifact was captured
+                sha256,              # content digest of the committed evidence file
+                captured_at } ]
+```
+
+`artifact.head_sha` pins the build the verification observed; each entry's `sha256` pins the bytes. An entry whose `artifact_head_sha` differs from `artifact.head_sha` is an `artifact_mismatch` and a recomputed digest that disagrees is an `evidence_digest_mismatch` — each fails loudly, naming both SHAs or the evidence id, and blocks completion. At completion the pinned `head_sha` is reconciled against **the merged head** using the ancestry + deploy-run definition of "what shipped" that `lisa-drive-pr-to-merge` already owns (cite it; there is no second definition): pre-merge evidence counts only when its head is a parent of the merge, and on a merge-race mismatch verification re-runs against the merged head before completion is declared.
+
+The list may be empty; the flag may not be missing. An absent `not_established_reviewed` is indistinguishable from nobody having asked the question, so the evidence-posting gate in `tracker-evidence` refuses the post, and the Stop-hook gate reports it as a v2 contract violation (advisory until `verification.gate.enforceBoundaries` is ratcheted on). This generalizes the required, never-empty `Known limits` field of `lisa-improve-harness` to every evidence surface.
+
+The boundary each artifact type reaches — and therefore which claim a captured artifact can discharge — is the `claim-evidence-mapping` rule's taxonomy; the type table above is its evidence-kind source.
+
 ### Cross-work-item evidence references are non-claiming
 
 When prose needs to point at evidence declared by another work item, use the dedicated reference form:

package/plugins/src/base/skills/lisa-github-evidence/SKILL.md

@@ -24,6 +24,16 @@ Upload captured evidence and generated templates to the GitHub PR description an
   - `comment.md` — GitHub markdown body for both the issue comment and the PR description's `## Evidence` section.
   - (Optional) `comment.txt` — kept for parity with the JIRA path; not used here.
 
+## Comment-body preflight (required)
+
+Before posting or updating anything, check the evidence body (`comment.md`, and `comment.txt` where this skill uses it):
+
+- It contains a `## Not established` heading. That heading is **never omitted and never blank** — when nothing is outstanding it still renders `None outstanding — reviewed`; otherwise it names, in plain operator language, what the verification did not prove.
+- The accompanying verdict carries `not_established_reviewed: true` (the list may be empty; the flag may never be omitted).
+- It contains a `## Artifact identity` heading carrying **values, not placeholders** — the repository, the `head_sha` the verification observed, the `environment`, and per artifact its `sha256` digest and `captured_at`. **Refuse to post** a body whose identity heading is absent or unpopulated, or whose recorded `artifact_head_sha` disagrees with the verdict's `artifact.head_sha` — report the evidence id and **both SHAs**. Definition: the `claim-evidence-mapping` rule.
+
+If either is missing, **refuse to post**: stop and report the missing Not-established review to the caller instead of publishing. Composing the body is `lisa-tracker-evidence`'s job (see its UI Evidence Checklist); this skill only refuses to publish one that omits the section. The section is defined by the `claim-evidence-mapping` rule and generalizes `lisa-improve-harness`'s required, never-empty `Known limits` field.
+
 ## Workflow
 
 1. **Resolve refs**

package/plugins/src/base/skills/lisa-jira-evidence/SKILL.md

@@ -42,6 +42,16 @@ Upload captured evidence and generated templates to GitHub PR description and JI
   - `comment.txt` — JIRA wiki markup (generated by `generate-templates.py`)
   - `comment.md` — GitHub markdown (generated by `generate-templates.py`)
 
+## Comment-body preflight (required)
+
+Before posting or updating anything, check the evidence body (`comment.md`, and `comment.txt` where this skill uses it):
+
+- It contains a `## Not established` heading. That heading is **never omitted and never blank** — when nothing is outstanding it still renders `None outstanding — reviewed`; otherwise it names, in plain operator language, what the verification did not prove.
+- The accompanying verdict carries `not_established_reviewed: true` (the list may be empty; the flag may never be omitted).
+- It contains a `## Artifact identity` heading carrying **values, not placeholders** — the repository, the `head_sha` the verification observed, the `environment`, and per artifact its `sha256` digest and `captured_at`. **Refuse to post** a body whose identity heading is absent or unpopulated, or whose recorded `artifact_head_sha` disagrees with the verdict's `artifact.head_sha` — report the evidence id and **both SHAs**. Definition: the `claim-evidence-mapping` rule.
+
+If either is missing, **refuse to post**: stop and report the missing Not-established review to the caller instead of publishing. Composing the body is `lisa-tracker-evidence`'s job (see its UI Evidence Checklist); this skill only refuses to publish one that omits the section. The section is defined by the `claim-evidence-mapping` rule and generalizes `lisa-improve-harness`'s required, never-empty `Known limits` field.
+
 ## Usage
 
 ```bash

package/plugins/src/base/skills/lisa-linear-evidence/SKILL.md

@@ -41,6 +41,16 @@ The caller must produce:
 
 If any of these are missing, stop and report.
 
+## Comment-body preflight (required)
+
+Before posting or updating anything, check the evidence body (`comment.md`, and `comment.txt` where this skill uses it):
+
+- It contains a `## Not established` heading. That heading is **never omitted and never blank** — when nothing is outstanding it still renders `None outstanding — reviewed`; otherwise it names, in plain operator language, what the verification did not prove.
+- The accompanying verdict carries `not_established_reviewed: true` (the list may be empty; the flag may never be omitted).
+- It contains a `## Artifact identity` heading carrying **values, not placeholders** — the repository, the `head_sha` the verification observed, the `environment`, and per artifact its `sha256` digest and `captured_at`. **Refuse to post** a body whose identity heading is absent or unpopulated, or whose recorded `artifact_head_sha` disagrees with the verdict's `artifact.head_sha` — report the evidence id and **both SHAs**. Definition: the `claim-evidence-mapping` rule.
+
+If either is missing, **refuse to post**: stop and report the missing Not-established review to the caller instead of publishing. Composing the body is `lisa-tracker-evidence`'s job (see its UI Evidence Checklist); this skill only refuses to publish one that omits the section. The section is defined by the `claim-evidence-mapping` rule and generalizes `lisa-improve-harness`'s required, never-empty `Known limits` field.
+
 ## Phase 1 — Resolve Linear Issue
 
 1. Parse the identifier from `$ARGUMENTS`.

package/plugins/src/base/skills/lisa-tracker-evidence/SKILL.md

@@ -28,6 +28,10 @@ See the `config-resolution` rule for configuration and dispatch table.
 - Never post evidence to a different ticket than the one named — `$ARGUMENTS` is the source of truth.
 - Never invent a verify-specific usage footer. Evidence artifact usage must flow through `lisa-usage-accounting`, preserve the canonical `## Lisa Usage` section, and surface `source: unavailable` explicitly when the runtime cannot provide trustworthy numbers.
 - **Evidence-manifest gate (leaf work units).** Before dispatching to a vendor skill that transitions the ticket, confirm `EVIDENCE_DIR` contains a non-empty artifact **of the declared type** for every typed `[EVIDENCE: <artifact-type>: <name>]` marker declared in the ticket's Validation Journey — a `screenshot` marker needs an actual image, an `http-transcript` marker needs the request + response text, a `perf-trace` marker needs measured numbers; a prose claim satisfies nothing. If any declared marker has no captured artifact, an empty one, or one whose content/extension does not match its declared type, stop and report the offending markers by name instead of posting — a leaf work unit (Bug / Task / Sub-task / Improvement) may not advance to its review/Done state with an unsatisfied manifest (see the "Per-Work-Unit Evidence Contract" in the `verification` rule). Epics / Stories / Spikes, and leaf units without a Validation Journey, are exempt.
+- **Claim↔boundary binding (S14 upgrade).** Satisfying the manifest by *type* is not enough: each `[EVIDENCE: <artifact-type>: <name>]` marker is also cited for a **claim**, and the marker's artifact type must **reach the boundary that claim declares** per the `claim-evidence-mapping` rule's taxonomy. A `browser` claim (user-visible UI behavior) is reached by `screenshot` / `recording` and never by a unit `test-run-log`; an `http-api` claim needs an `http-transcript`; a `deploy-health` claim needs a `deploy-log` and no pre-deploy artifact. On a mismatch, report the offending marker **by name** together with the claim, its boundary, and the **required evidence kinds** for that boundary — e.g. `[EVIDENCE: test-run-log: unit-suite] cited for claim AC-2 [boundary browser] — required evidence kinds: screenshot, recording`. Swapping in a marker of a reaching kind with a real captured artifact satisfies the gate. **Advisory-first:** until `verification.gate.enforceBoundaries` is `true` in `.lisa.config.json` (the same ratchet flag the Stop-hook gate reads, default `false`), a boundary mismatch is reported to the operator but does not block the post; once ratcheted on it refuses the post exactly like a missing or wrong-type artifact. Missing/empty/wrong-type artifacts keep refusing the post regardless of the flag.
+- **The "Not established" section is required.** Before posting, confirm `evidence/comment.md` (and `comment.txt` where the vendor uses it) contains a `## Not established` heading and that the verdict carries `not_established_reviewed: true`. The heading is **never omitted and never blank**: with nothing outstanding it still renders `None outstanding — reviewed`; otherwise it lists, in plain operator language, each thing the verification did not prove — boundaries not exercised, environments not tested, behavior consciously out of scope. A comment with no such heading, a heading with nothing under it, or a verdict whose `not_established_reviewed` flag is absent is **refused**: stop and report the missing Not-established review instead of posting. (The list may be empty; the flag may never be omitted.) Definition and exemplars live in the `claim-evidence-mapping` rule; this generalizes `lisa-improve-harness`'s required, never-empty `Known limits` field.
+- **Artifact identity is required, with values (S14 extension).** Before posting, confirm the comment body carries a `## Artifact identity` heading populated with **values, not placeholders**: the `repository`, the `head_sha` the verification observed, the `environment`, and for each committed artifact its `sha256` digest and `captured_at`. Then check both identity failures. **`artifact_mismatch`** — an evidence entry whose recorded `artifact_head_sha` differs from the verdict's `artifact.head_sha`: refuse the post and report the offending evidence id together with **both SHAs** (the one the artifact was captured at and the one the verdict claims), e.g. `EV-2 captured at 4f1c9ab but artifact.head_sha is 9de0c31`. **`evidence_digest_mismatch`** — recompute the `sha256` of each committed evidence file on read; if the bytes no longer match the recorded digest (or the file is absent), stop and report the evidence id by name. Never summarize either as "verification failed" — name the field, the ids, and both SHAs so a non-engineer can read it at the gate. **Advisory-first:** until `verification.gate.enforceBoundaries` is `true` in `.lisa.config.json`, an identity failure is reported to the operator but does not block the post; once ratcheted on it refuses the post exactly like a missing artifact. Definition: the `claim-evidence-mapping` rule.
+- **Merge-race reconciliation (at completion, not at post).** The evidence's pinned `head_sha` is reconciled against the merged head using the ancestry + deploy-run definition of "what shipped" that `lisa-drive-pr-to-merge` already owns — cite that skill, never re-implement or restate its checks here. Pre-merge evidence counts for the merge commit only when its head is a parent of the merge, ancestry alone never justifies reporting shipped, and on a mismatch verification re-runs against the merged head before completion is declared.
 - **Evidence references are not manifest entries.** Extract obligations using the exact `[EVIDENCE:` prefix (and the legacy local `[SCREENSHOT:` form). Exclude both the canonical `[EVIDENCE-REF: <work-item-ref> | <artifact-type>: <kebab-case-name>]` and the Lisa 2.223.0 legacy alias `[EVIDENCE-REF: <tracker-ref>: <artifact-type>: <kebab-case-name>]` from artifact lookup, missing-artifact reporting, and duplicate-name checks: either belongs to another work item and cannot satisfy this item's S14 gate. A runtime-changing leaf with references but no local claiming marker must be rejected before dispatch.
 
 ## UI Evidence Checklist (when work is UI-visible)
@@ -47,8 +51,11 @@ The checklist is tracker-agnostic — the same shape works on JIRA, GitHub Issue
 5. **"What this shows" section.** Tailor to ticket type:
    - **Bug repro:** state plainly whether the bug reproduces or not, and the most likely 1–2 reasons their retest still failed (different env, native app vs. web, stuck backend row, etc.).
    - **Feature/UX completion:** state plainly which acceptance criteria each screenshot covers, and call out any deferred or out-of-scope surface explicitly so QA/PM doesn't have to infer.
-6. **"What would help me confirm" (bug) / "How to QA" (feature) section.** Concrete actionable retest steps with the exact selection criteria (e.g., "pick a record whose Status column shows `—`, not `Processing` or `Pending Review`").
-7. **Explicit invitation to be corrected.** End with a line like *"If any of the steps I listed are different from what you expected / actually did, please tell me explicitly which step I got wrong."* Non-optional — small differences (which record, which device, exact tap order, expected behavior) change everything, and naming the door open short-circuits ticket bounce-loops.
-8. **Workflow transition** is the vendor skill's job, not yours — it'll move the ticket per the configured tracker (JIRA: Reassign to reporter for bug repro / move to the configured review status when one exists, otherwise leave it in `claimed`; GitHub: direct `claimed` → configured `done` after a successful build; Linear: equivalent state). You don't transition manually.
+6. **"Artifact identity" and "Not established" sections (both required).** Right after "What this shows":
+   - `## Artifact identity` — what the evidence was collected against, as **values, not placeholders**: the repository, the `head_sha` the verification observed, the `environment`, and per artifact its `sha256` digest and `captured_at`. A heading rendered with `<unknown>` in place of a SHA is not identity.
+   - `## Not established` — **never omitted, never blank.** List in plain language what this verification did *not* prove: boundaries not exercised (e.g. "the persisted order row was never queried"), environments not tested (e.g. "checked on desktop Chrome only — not mobile Safari"), and behavior consciously out of scope (e.g. "refunds were not touched or tested"). Name the specific thing, not a category. With nothing outstanding, the heading still renders a single line: `None outstanding — reviewed`. Never state a quality check as proof of behavior — "unit tests pass" belongs here as a limit, not above as evidence.
+7. **"What would help me confirm" (bug) / "How to QA" (feature) section.** Concrete actionable retest steps with the exact selection criteria (e.g., "pick a record whose Status column shows `—`, not `Processing` or `Pending Review`").
+8. **Explicit invitation to be corrected.** End with a line like *"If any of the steps I listed are different from what you expected / actually did, please tell me explicitly which step I got wrong."* Non-optional — small differences (which record, which device, exact tap order, expected behavior) change everything, and naming the door open short-circuits ticket bounce-loops.
+9. **Workflow transition** is the vendor skill's job, not yours — it'll move the ticket per the configured tracker (JIRA: Reassign to reporter for bug repro / move to the configured review status when one exists, otherwise leave it in `claimed`; GitHub: direct `claimed` → configured `done` after a successful build; Linear: equivalent state). You don't transition manually.
 
 **Why this format:** It (a) gives the reporter a frame-by-frame they can compare against, (b) avoids the JIRA image-collapse failure mode while still working everywhere else, (c) names the most plausible discrepancies up front so the loop short-circuits, (d) explicitly opens the door to being corrected so tickets don't bounce on assumed alignment. The same mechanics that resolve a stuck bug ticket also give QA an unambiguous handoff for a freshly-built feature.