@codyswann/lisa 4.59.0 → 4.59.1

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

@@ -491,7 +491,11 @@ Before the claim mutation, apply `claim-time-guards` — **Value before claim**,
 1. **`two-failed-attempts` valve.** Count `[lisa-build-attempt]` markers on the issue from the read bundle's comments (match on the marker, never the title), applying both filters from `claim-time-guards`: count a marker only when it carries `measures=work` (a marker with no `measures=` counts as `work`), and only when its `createdAt` is **after the issue most recently gained the ready label**. The ready-lane entry comes from the read bundle's `LabeledEvent` stream, which is already fetched — no extra call. If that history is `unknown`, count every `measures=work` marker regardless of age and say so in the comment. With two or more surviving markers, do **not** claim: relabel to the configured blocked role (`gh issue edit <number> --repo <org>/<repo> --remove-label "$READY" --add-label "$BLOCKED"`, resolved from `github.labels.build.blocked` per `config-resolution`), post the operator-readable comment naming both attempts, and **stop the cycle** at Phase 3e. Every non-success terminal outcome recorded in 3c/3d also appends a fresh `<!-- [lisa-build-attempt] n=<N> outcome=<outcome> measures=<work|machine> -->` marker so the next cycle can count it — `measures=machine` when the run was terminated by a signal or its outcome was `recovery-required`, `measures=work` when the build ran and did not satisfy the issue.
 2. **`already-implemented` check.** Probe for this issue's own key — `git log --all --grep "<org>/<repo>#<number>"` and `gh pr list --repo <org>/<repo> --state all --search "<org>/<repo>#<number>" --json number,state,mergedAt,url`. On a hit, claim as normal but route 3c to **verify-and-close** instead of `lisa-implement`: verify what shipped against the issue's acceptance criteria, post evidence via `lisa-github-evidence` naming the shipping PR/commit, then run the ordinary 3d transition and 3d.1 rollup. A partial hit implements only the remaining gap. An unreadable history degrades to "no hit" and the ordinary path proceeds — the guard never blocks the claim. This is not `DUPLICATE_ALREADY_FIXED` (a *different* canonical issue) and not `claim-archaeology` (a *different* ancestor issue); it is this issue's own work already having shipped without a transition.
 
+Immediately before claiming, re-read native state. If it is closed, skip it without
+relabeling or dispatching; an unreadable state holds the candidate.
+
 ```bash
+gh issue view <number> --repo <org>/<repo> --json state -q '.state' # must be OPEN
 gh issue edit <number> --repo <org>/<repo> --remove-label "$READY" --add-label "$CLAIMED"
 # Assign to the authenticated user ONLY when the issue is currently unassigned (attributable claim;
 # do not pile a second assignee onto an issue that already has an owner):
@@ -536,7 +540,7 @@ The lifecycle run returns one of the following outcomes; resume this scanner wit
 
 - **Success** — the build flow completed and a PR exists; evidence posted. The PR may already be **merged** or still **open** (auto-merge enabled, awaiting checks/merge). "Success" means the build work is sound — it does **not** assert the change reached an environment. The env transition in 3d gates on the PR actually being merged; an open PR does not advance the issue to a `done` env status.
 - **Blocked by github-verify pre-flight gate** — the pre-flight gate (github-agent workflow step 2) relabels the issue to `status:blocked` (or removes `$CLAIMED` and reassigns to the original author). This is correct and expected — let it stand. Record and move on.
-- **Duplicate already fixed** — `lisa-ticket-triage` returned `DUPLICATE_ALREADY_FIXED` with a canonical issue reference and empirical base-branch evidence. Post the triage finding, ensure the native `duplicates <canonical>` relationship exists when GitHub exposes it (otherwise leave an explicit cross-reference comment/body link), remove `$CLAIMED`, add the terminal `$DONE` label, close the issue with `gh issue close --reason "not planned"`, and do not open a PR. If the canonical fix is merged but not yet on the production branch, the close comment must say the production error can recur until the canonical issue promotes and that recurrence is tracked by the canonical issue; do not reopen this duplicate for that recurrence.
+- **Duplicate already fixed** — `lisa-ticket-triage` returned `DUPLICATE_ALREADY_FIXED` with a canonical issue reference and empirical base-branch evidence. Follow 3c.1 to link the duplicate, remove lifecycle roles, and close it as not planned without adding a done label or opening a PR. If the canonical fix is merged but not yet on the production branch, the close comment must say the production error can recur until the canonical issue promotes and that recurrence is tracked by the canonical issue; do not reopen this duplicate for that recurrence.
 - **Blocked by ticket-triage ambiguities** — triage posts findings and the lifecycle stops. The issue stays in `$CLAIMED`. Surface to human; do not auto-relabel. Record under "Errors".
 - **Errored** — exception, missing config, etc. Leave the issue in `$CLAIMED` for human investigation. Record under "Errors".
 
@@ -547,12 +551,12 @@ Run this only when the returned triage verdict is exactly `DUPLICATE_ALREADY_FIX
 1. Verify the structured result includes a canonical issue reference, the canonical PR/commit, and empirical evidence that the canonical fix is present on the base branch. If any piece is missing, treat the outcome as Held instead of closing.
 2. Post or preserve the triage-finding comment that explains why this issue is a duplicate and names the canonical issue.
 3. Ensure a native `duplicates <canonical>` link exists when GitHub exposes issue relationships; if this installation cannot create that relationship, leave an explicit issue cross-reference comment/body link and record the limitation in the summary.
-4. Resolve terminal `$DONE` exactly as in Phase 3d. For a single-env repo, `$DONE` is terminal; for env-keyed config, only the production/final value is terminal.
-5. Apply `$DONE` and retire every competing lifecycle role the issue currently carries — not just `$CLAIMED` — per the `leaf-only-lifecycle` rule's "Exactly one lifecycle role survives closure". Then close the issue as duplicate/not-planned:
+4. Resolve the configured lifecycle role set, including every environment's done value.
+5. Remove every lifecycle role the issue currently carries. Add no done label: this duplicate is being declined, and the canonical issue records delivery. Close as duplicate/not-planned:
 
 ```bash
 gh issue view <number> --repo <org>/<repo> --json labels -q '[.labels[].name] | join(" ")'
-gh issue edit <number> --repo <org>/<repo> --add-label "$DONE" <one --remove-label "<role>" per competing role the issue CURRENTLY carries>
+gh issue edit <number> --repo <org>/<repo> <one --remove-label "<role>" per lifecycle role the issue CURRENTLY carries; skip when none>
 gh issue close <number> --repo <org>/<repo> --reason "not planned"
 ```
 
@@ -562,7 +566,7 @@ gh issue close <number> --repo <org>/<repo> --reason "not planned"
 gh issue view <number> --repo <org>/<repo> --json state,stateReason,labels
 ```
 
-It must read `state: CLOSED` with `stateReason: NOT_PLANNED`, carry `$DONE`, and carry **no** other lifecycle role. Anything else is an Error naming what is still present. Post the closeout comment only after that passes:
+It must read `state: CLOSED` with `stateReason: NOT_PLANNED` and carry **no** lifecycle role, including `$DONE`. Anything else is an Error naming what is still present. Post the closeout comment only after that passes:
 
 ```bash
 gh issue comment <number> --repo <org>/<repo> --body "[claude-build-intake] Closed as duplicate of <canonical>. Canonical fix: <PR-or-commit>. Evidence: <base-branch-proof>."

package/plugins/src/base/skills/lisa-repair-intake/SKILL.md

@@ -683,7 +683,8 @@ LISA_BLOCKER_NODE
    invoke `resolveBlockerEdges` as shown above; never create a second resolver in the host.
    It returns `dissolve` / `keep` / `escalate` per edge.
    **Dissolve the edge in the SAME write that records the ruling, then read the relation back and
-   confirm it is gone.** Only when every edge dissolves → move `blocked → claimed`, then run the
+   confirm it is gone.** Only when the parsed edge set is non-empty and the resolver returns
+   `proceed: true` with every edge dissolved → move `blocked → claimed`, then run the
    same agent-dispatch + post-agent `claimed → done` sequence as the stalled-`claimed` path above
    (one-cycle recovery). If the agent re-blocks, move back to `blocked` — a valid outcome.
 
@@ -773,22 +774,16 @@ native-open / active / unresolved:
 4. Post a compact `[lisa-repair-intake]` note only when the native close-out changed state or when
    an actionable setup error must be surfaced. Do not spam already-closed terminal items.
 
-### Lifecycle label contradicts native state — walk BOTH directions
+### Lifecycle label contradicts native state — walk every direction
 
-A lifecycle label can lie in two ways, and historically only one of them had an owner:
+Use the existing detector to check native state and closure reason together.
+`directionsWalked` reports all three repair directions:
 
-| label | native state | owned by |
+| Label | Native state | Repair |
 |---|---|---|
-| terminal `done` role | still open / active | the `Build terminal-open` section above |
-| non-terminal role (`ready`, `claimed`, `blocked`, or any other `status:` member) | closed / completed | **nothing, until now** |
-
-A pass that walks one direction leaves the other accumulating silently. Measured on the Linear TUN
-board: **TUN-556 and TUN-503 both carry a terminal `status:done` while still natively open in
-`On Dev`** — invisible to intake and indistinguishable from handled, exactly like a bot-applied
-`status:in-progress` on GitHub.
-
-Resolve both directions in one pass with the shipped detector, which always reports
-`directionsWalked` covering both, so a "clean" verdict is an assertion that both were examined.
+| Terminal `done` role | Open / active | Follow `Build terminal-open` above |
+| Non-terminal lifecycle role | Closed as `COMPLETED` or reason absent | Advance to the configured terminal role |
+| Non-terminal lifecycle role | Closed as `NOT_PLANNED` | Remove the stale role and add nothing |
 
 **Build the classifier input inside this cycle. Never consume a temp file another skill wrote.**
 repair-intake runs as its own cycle, so borrowing `lisa-github-build-intake`'s scratch file fails
@@ -801,6 +796,9 @@ silent-clean verdict this section promises cannot happen.
 TRUST_DIR=$(mktemp -d)
 trap 'rm -rf "$TRUST_DIR"' EXIT
 
+# REST, not `gh issue view`: this payload carries `state_reason`, and the reason is
+# what separates the two closed directions. A read that drops it makes a NOT_PLANNED
+# closure indistinguishable from a completion at the exact moment one of them WRITES.
 gh api "repos/<org>/<repo>/issues/<n>" > "$TRUST_DIR/issue.json"
 
 # --paginate emits ONE ARRAY PER PAGE; --slurp + `add` flattens all of them so a
@@ -835,14 +833,18 @@ The `excluded` array reports what was held back; surface it, do not repair it.
 1. **`terminal-label-open-state`** → hand to the `Build terminal-open → native close` section above.
    Do not restate its rules; the terminality test lives there (intermediate env rungs like
    `status:on-dev` / `status:on-stg` are **not** terminal).
-2. **`open-label-closed-state`** → the previously unowned direction. The item is natively closed or
-   completed while still wearing a non-terminal lifecycle role. Advance the label to the env-resolved
-   terminal `done` role and post one idempotent `[lisa-repair-intake]` note. This is a write on
-   **Lisa's own** lifecycle surface, not a contest with another writer.
+2. **`open-label-closed-state`** → the previously unowned direction. The item is natively closed as
+   **completed** while still wearing a non-terminal lifecycle role. Advance the label to the
+   env-resolved terminal `done` role and post one idempotent `[lisa-repair-intake]` note. This is a
+   write on **Lisa's own** lifecycle surface, not a contest with another writer.
    Apply the leaf/container check from the **Lifecycle ownership guard** section *before* this
    branch: repair-intake owns container repair, so a natively-closed `ready` **leaf** is skipped
    here and left to the build lane rather than claimed by this pass.
-3. **Vendor caveat — Linear.** On Linear the lifecycle surface is the native workflow **state**, not a
+3. **`open-label-abandoned-state`** → closed as **`NOT_PLANNED`**. Remove the stale
+   non-terminal role and add nothing: declined work has not shipped. Post one idempotent
+   `[lisa-repair-intake]` note naming the closure reason. This removal also applies to closed
+   ready leaves, before the ordinary ready-leaf skip; it never claims or dispatches them.
+4. **Vendor caveat — Linear.** On Linear the lifecycle surface is the native workflow **state**, not a
    `status:*` label (see `config-resolution`). A `status:*` label there is leftover cruft that no
    repair direction reads, which is precisely why TUN-556 and TUN-503 rotted. Treat Linear's native
    state as authoritative and remove the contradicting stale label; never move the state to match a
@@ -1417,8 +1419,9 @@ It MAY:
   terminal `done`.
 - Reconcile a **container** wrongly carrying the build-ready `ready` role (a leaf-only-invariant
   violation) by rolling it up from its children and removing the `ready`, with a
-  `[lisa-repair-intake]` audit note. This is the one `ready`-touching exception (see MUST NOT) and
-  applies only to containers, never to leaves.
+  `[lisa-repair-intake]` audit note.
+- Remove stale lifecycle labels from a natively closed `NOT_PLANNED` item, including a ready
+  leaf. Add no done label and do not claim or dispatch it.
 - Move a PRD with fully terminal generated work to `shipped` and close/archive the source artifact
   where the source vendor supports native close-out, per `prd-lifecycle-rollup`.
 - Repair missing native GitHub child links by replaying the same-repo, idempotent `addSubIssue`
@@ -1439,9 +1442,8 @@ It MUST NOT:
   (empty parent token / `Top-level work:` entries) may become PRD children.
 - Apply a build `done` value other than via the env-resolution rules, or close a native item at
   any value other than the true terminal `done` (see `leaf-only-lifecycle`).
-- Touch `ready` **leaves** (that is `lisa-intake`'s lane). A container carrying `ready` is the
-  documented exception above — repair-intake reconciles it because `ready` on a parent is an
-  invariant violation, not the human "claim this leaf" signal intake owns.
+- Touch `ready` **leaves** except to remove stale labels from a natively closed `NOT_PLANNED`
+  item as above. Open ready leaves remain `lisa-intake`'s lane.
 - Move a GitHub issue that already carries a configured lifecycle label back to `ready` merely
   because some other label looks stale. Official lifecycle labels remain authoritative.