@codyswann/lisa 2.257.2 → 2.258.1

package/plugins/lisa-agy/skills/lisa-project-ideation/SKILL.md

@@ -303,12 +303,17 @@ so a quiet ideation run and a broken one are never confused.
 | Nothing to ideate — no Practical Idea cleared the bar; nothing created — **or** every idea was suppressed by a prior decline (`rejection-detection` **Proposal rejection memory**): the summary MUST name the suppression count | `nothing-needed` |
 | The Step 5.5 **PRD-queue-pressure gate** blocked auto-ready creation — a human must drain the queue before another auto-ready PRD is added | `approval-requested` |
 | The loop itself could not run — the PRD source reader failed or the queue is misconfigured (a source-reader failure snapshot, not queue pressure) — **or** the open-and-closed rejection-memory marker search could not read the source: a memory check that could not run is a broken loop, never a silent `nothing-needed` | `recovery-required` |
+| The runbook's **Retirement condition** tripped — the trailing quiet window is empty AND this run proposed nothing AND no unresolved PRD pressure exists while no new surface has shipped — this row supersedes the `nothing-needed` row when it applies | `policy-obsolete` |
 | A degradation that still let ideation run (optional Codex automation memory unavailable, an inspiration source unreachable) | the outcome it actually reached above, with the summary **leading with the degradation** — degradation never mints a seventh token |
 
 The pressure gate is `approval-requested`, **not** `recovery-required`: the loop ran fine and
 correctly declined to add queue pressure — it is asking a human to drain the queue, not reporting a
 broken machine. `recovery-required` is reserved for the loop failing to run at all.
 
+Before invoking the run-record CLI, evaluate the **Retirement condition** first. If it applies,
+select `policy-obsolete` as the sole outcome and do not record a prior `nothing-needed` result;
+otherwise select the ordinary outcome from the table.
+
 Record **exactly one** outcome per invocation through the run-record CLI, naming this loop's runbook
 (the `--summary` is the operator-readable one-liner in the contract's exemplar voice — plain,
 specific, actionable, e.g. `Reviewed evidence; no practical idea cleared the bar — nothing to
@@ -328,6 +333,43 @@ If `${CLAUDE_PLUGIN_ROOT}` is unset, resolve the plugin scripts directory direct
 abort** (per `automation-runbook-contract`): note the recording failure in the run output and finish
 the run — a recording failure is a degradation to report, never a reason to block the loop.
 
+**Retirement evaluation (every run).** Evaluate this loop's runbook **Retirement condition** on
+every run, exactly as the `automation-runbook-contract` rule's Retirement section defines it — this
+skill conforms to that text and never restates or diverges from it. On top of the contract's two
+conditions the runbook seeds a third **domain conjunct** — no unresolved PRD pressure exists and the
+project has shipped no new surface to ideate against — which only tightens the test and never
+replaces it: a quiet month because the queue was full is the loop working, not the loop being
+obsolete. Evaluate all three. When all three hold, record `policy-obsolete` and file **exactly ONE**
+marker-deduped teardown proposal through `lisa-tracker-write` (per `tracked-work` +
+`integration-access-layer`):
+
+- **Marker** `<!-- [lisa-automation-retire] key=exploratory-prds -->` plus a visible prose line;
+  matched on the marker, never the title; searched **open AND closed** per `rejection-detection`'s
+  **Proposal rejection memory**. Treat matches by close state: **open** suppresses another proposal;
+  **Not planned** suppresses another proposal unless new evidence postdates the rejection;
+  **Completed** means the prior approved action happened, so a later recurrence may be re-filed.
+  When an existing proposal suppresses filing, **the run still records `policy-obsolete` and files
+  nothing** — the outcome describes this run, while the ticket is filed exactly once.
+- **Labels** `status:blocked` + `human-needed`, carrying the contract's decision-ready packet. The
+  `human-needed` label marks the proposal human-owned: `lisa-repair-intake` recognizes it and never
+  re-dispatches it as stalled work.
+- **Evidence** the date-filtered search result, this run's summary, **the loop's current cadence**
+  (the baseline an operator needs to choose a longer one), and a one-line summary of recent runs
+  read from `.lisa/automations/runs/exploratory-prds.jsonl`. Fill the rest of the packet the same
+  way every time: *Work already attempted* is the searches this run ran, and *Risk of inaction* is
+  that the loop keeps consuming schedule slots and tokens for nothing.
+- **How to answer** names the three operator responses: **approve** — run
+  `/lisa:tear-down-automations exploratory-prds` and only that loop registration goes away;
+  **decline** — close the proposal as
+  **Not planned** (closing it as **Completed** leaves a later re-file open) and the loop simply
+  continues; **re-cadence** — pick a longer cadence off that evidence and re-register with
+  `/lisa:setup-automations` instead of tearing down.
+- **Operator footer**, verbatim, as on every loop-filed proposal (`rejection-detection`):
+  > To stop this from being raised again, close it as **Not planned**. Close it as **Completed** if it was fixed — a later recurrence may be re-filed as a regression.
+
+The loop **keeps running at its normal cadence** until a human acts, and never deletes its own
+registration.
+
 ## Out of scope (hard rules)
 
 - **No fabricated personas.** No evidence citation → no persona; generic roles banned without
@@ -339,8 +381,9 @@ the run — a recording failure is a degradation to report, never a reason to bl
 - **Tests, lint, typecheck, and build are not the empirical verification plan** — they are
   prerequisites; verification must observe user-facing behavior.
 - **Do not create tracker tickets or mutate the host project's code.** PRD creation (via
-  `lisa-research`) is the only write this skill performs; ticket planning (`lisa-plan`) and
-  implementation (`lisa-implement`) are separate, user-invoked flows.
+  `lisa-research`) is the only normal write this skill performs; the only tracker-ticket exception is
+  the exactly-one marker-deduped `policy-obsolete` teardown proposal described above. Ticket planning
+  (`lisa-plan`) and implementation (`lisa-implement`) are separate, user-invoked flows.
 - **Do not write PRDs to the source directly** — always go through `lisa-research` →
   `lisa-prd-source-write` so the source stays switchable.
 - **Do not add a new verification/browser-automation framework** when one already exists — reuse it.

package/plugins/lisa-agy/skills/lisa-repair-intake/SKILL.md

@@ -1000,6 +1000,7 @@ to each item* — the two never merge in the one-line summary.
 | Repair produced new work for a human to pick up — e.g. an unmergeable PR or failed deploy filed as a **build-ready fix ticket** and left `blocked` | `candidate-proposed` |
 | A repair reached an autonomy boundary needing a human (a protected-deploy approval before it can proceed) | `approval-requested` |
 | The loop itself could not run — the queue is unreadable, tracker credentials are revoked, or an open-and-closed rejection-memory / blocker-marker search is unreadable and therefore must not fall through to `nothing-needed` | `recovery-required` |
+| The runbook's **Retirement condition** tripped | `policy-obsolete` — **never reached by design for this loop** (see Retirement evaluation below) |
 
 Record **exactly one** outcome per invocation through the run-record CLI, naming this loop's runbook
 (the `--summary` is the operator-readable one-liner in the contract's exemplar voice — plain,
@@ -1019,6 +1020,13 @@ If `${CLAUDE_PLUGIN_ROOT}` is unset, resolve the plugin scripts directory direct
 abort** (per `automation-runbook-contract`): note the recording failure in the run output and finish
 the cycle — a recording failure is a degradation to report, never a reason to block the loop.
 
+**Retirement evaluation (every run).** The `intake-repair` loop is **structural to the
+factory — it does not retire.** Its runbook says so plainly instead of leaving the Retirement
+condition blank, so the `automation-runbook-contract` rule's two-part retirement test never fires
+here: this loop never records `policy-obsolete` and never files a teardown proposal. An operator who
+wants repair to stop runs `/lisa:tear-down-automations` themselves — the loop never removes its own
+registration.
+
 ## Schedule examples
 
 ```text

package/plugins/lisa-agy/skills/lisa-setup-automations/SKILL.md

@@ -187,13 +187,31 @@ One line each; expand them into the operator's voice, keep the meaning.
 
 | Loop | Intent | Sources of truth | Candidate selection | Scope/bounds | Retirement condition | Derive the other five from |
 |---|---|---|---|---|---|---|
-| **intake-repair** | Keeps the queues unstuck: work that stalled mid-flight gets diagnosed and moved again. | The PRD and build queues for this project, read through the tracker access layer. | Stuck or half-closed items — stalled in an in-progress role, terminal-labeled but still open, rollups whose children are all done — up to the `max_candidates` cap. | Only this project's configured queues; it repairs lifecycle state, never invents or closes real work. | Propose teardown when nothing has needed repair for a long quiet window AND this run found nothing. | `lisa-repair-intake/SKILL.md` |
-| **intake-prd** | Keeps PRDs moving: a PRD a human marked ready gets validated and decomposed into work items. | The configured PRD queue and its lifecycle roles, read through the source access layer. | The oldest PRD in the ready role, one per run. | Only this project's PRD queue; it never authors product intent, only validates and decomposes it. | Propose teardown when no PRD has entered the queue for a long quiet window AND this run proposed nothing. | `lisa-intake/SKILL.md` |
-| **intake-tickets** | Keeps the build queue moving: work items a human marked ready get built, reviewed, and shipped. | The configured tracker's build queue lanes plus each item's comments and linked PRs. | The oldest eligible leaf work item in the ready lane, one per run. | Only this repo's configured queue; containers with open children are repaired out, never built. | Propose teardown when no work item has entered this queue for a long quiet window AND this run proposed nothing. | `lisa-intake/SKILL.md` |
-| **monitor** | Keeps production honest: observability regressions become tracked work instead of silent decay. | The connected observability providers, each through its access layer, plus this project's `monitor.gapTiers` config. | The regressions and coverage gaps this cycle surfaced, capped per run. | Only this project's own services and dashboards; it files findings, it never changes production. | Propose teardown when the project has no connected observability surfaces AND this run found nothing. | `lisa-monitor/SKILL.md` |
-| **exploratory-prds** | Keeps the idea pipeline fed: the product's own gaps become PRDs when the PRD queue has room. | The PRD queue's pressure roles (the same ones `/lisa:queue-status` reports) and the project's own product surfaces. | One ideated PRD per run, and only when the pressure gate says the queue has capacity. | Never more than one PRD per run, and nothing at all while unresolved PRD pressure exists. | Propose teardown when the queue has been at pressure — or the project has shipped no new surface — across a long quiet window AND this run proposed nothing. | `lisa-project-ideation/SKILL.md` |
-| **exploratory-bugs** | Keeps quality visible: bugs and usability problems get found by using the product, before a customer does. | The running application through its exploratory-qa surface, plus this project's existing bug queue for dedupe. | The findings of one exploratory session, capped per run and deduped against already-filed items. | Only this project's own app; it files tickets, it never changes product code. | Propose teardown when no session has produced a finding across a long quiet window AND this run found nothing. | `lisa-exploratory-qa/SKILL.md` (the stack's own copy) |
-| **learnings-audit** | Keeps the project's knowledge true: stale, duplicated, or contradicted knowledge gets proposed for promotion, demotion, or retirement. | The learnings ledger, the rules trees, the skills, and the wiki — the project's knowledge surfaces. | The knowledge entries this audit judged stale, duplicated, or contradicted, capped per run. | It only proposes; every promote/demote/retire decision is a human-gated tracker ticket. | Propose teardown when the audit has proposed nothing across a long quiet window AND this run proposed nothing. | `lisa-learnings-audit/SKILL.md` |
+| **intake-repair** | Keeps the queues unstuck: work that stalled mid-flight gets diagnosed and moved again. | The PRD and build queues for this project, read through the tracker access layer. | Stuck or half-closed items — stalled in an in-progress role, terminal-labeled but still open, rollups whose children are all done — up to the `max_candidates` cap. | Only this project's configured queues; it repairs lifecycle state, never invents or closes real work. | **Structural to the factory — this loop does not retire.** Queues will always need unsticking, so no condition should ever stop it; say that here rather than leaving the section blank. | `lisa-repair-intake/SKILL.md` |
+| **intake-prd** | Keeps PRDs moving: a PRD a human marked ready gets validated and decomposed into work items. | The configured PRD queue and its lifecycle roles, read through the source access layer. | The oldest PRD in the ready role, one per run. | Only this project's PRD queue; it never authors product intent, only validates and decomposes it. | **Structural to the factory — this loop does not retire.** PRDs keep arriving for as long as the project is alive, so no condition should ever stop it; say that here rather than leaving the section blank. | `lisa-intake/SKILL.md` |
+| **intake-tickets** | Keeps the build queue moving: work items a human marked ready get built, reviewed, and shipped. | The configured tracker's build queue lanes plus each item's comments and linked PRs. | The oldest eligible leaf work item in the ready lane, one per run. | Only this repo's configured queue; containers with open children are repaired out, never built. | **Structural to the factory — this loop does not retire.** The build queue is how work ships, so no condition should ever stop it; say that here rather than leaving the section blank. | `lisa-intake/SKILL.md` |
+| **monitor** | Keeps production honest: observability regressions become tracked work instead of silent decay. | The connected observability providers, each through its access layer, plus this project's `monitor.gapTiers` config. | The regressions and coverage gaps this cycle surfaced, capped per run. | Only this project's own services and dashboards; it files findings, it never changes production. | Propose teardown when ALL THREE hold: a date-filtered tracker search finds nothing this loop filed within the trailing 30-day window (a small multiple of its daily cadence), AND this run found nothing, AND the project has no connected observability surfaces left — nothing to monitor. The third is a domain conjunct that only tightens the contract's two-part test: a quiet month on a healthy project is good news, not a reason to stop watching it. | `lisa-monitor/SKILL.md` |
+| **exploratory-prds** | Keeps the idea pipeline fed: the product's own gaps become PRDs when the PRD queue has room. | The PRD queue's pressure roles (the same ones `/lisa:queue-status` reports) and the project's own product surfaces. | One ideated PRD per run, and only when the pressure gate says the queue has capacity. | Never more than one PRD per run, and nothing at all while unresolved PRD pressure exists. | Propose teardown when ALL THREE hold: a date-filtered tracker search finds no PRD this loop ideated within the trailing 30-day window (a small multiple of its daily cadence), AND this run proposed nothing, AND no unresolved PRD pressure exists while the project has shipped no new surface to ideate against. The third is a domain conjunct that only tightens the contract's two-part test: a quiet month because the queue was full is the loop working, not the loop being obsolete. | `lisa-project-ideation/SKILL.md` |
+| **exploratory-bugs** | Keeps quality visible: bugs and usability problems get found by using the product, before a customer does. | The running application through its exploratory-qa surface, plus this project's existing bug queue for dedupe. | The findings of one exploratory session, capped per run and deduped against already-filed items. | Only this project's own app; it files tickets, it never changes product code. | Propose teardown when ALL THREE hold: a date-filtered tracker search finds no finding this loop filed within the trailing 30-day window (a small multiple of its daily cadence), AND this run found nothing, AND the project no longer ships an exploratory-qa command surface to explore. The third is a domain conjunct that only tightens the contract's two-part test: a quiet month on a product nobody broke is quality holding, not a reason to stop looking. | `lisa-exploratory-qa/SKILL.md` (the stack's own copy) |
+| **learnings-audit** | Keeps the project's knowledge true: stale, duplicated, or contradicted knowledge gets proposed for promotion, demotion, or retirement. | The learnings ledger, the rules trees, the skills, and the wiki — the project's knowledge surfaces. | The knowledge entries this audit judged stale, duplicated, or contradicted, capped per run. | It only proposes; every promote/demote/retire decision is a human-gated tracker ticket. | Propose teardown when BOTH hold: a date-filtered tracker search finds no `[lisa-gardener]` ticket created within the trailing six-week window (six runs at the weekly cadence), AND this run proposed nothing. | `lisa-learnings-audit/SKILL.md` |
+
+**Retirement condition is mandatory and non-empty.** Every seeded runbook states one, and a loop
+that is structurally permanent says exactly that instead of leaving the section blank — an operator
+reading it aloud must be able to say when this loop should stop existing, or that it never should.
+A valid condition is **stateless**: derived from the tracker, or from the loop's own bounded run
+history at `.lisa/automations/runs/<loop-id>.jsonl` — written by the contract's own recorder, not
+private per-loop state — and **never an ad-hoc counter** or a new state file. Those two sources are
+the same discipline, not a loosening of the contract's "never from a counter or a state file": the
+run history is written and bounded by `automation-run-record.mjs`, is readable by any run on any
+machine, and is never invented per loop. What the contract forbids is a loop minting private state
+to remember itself by. Prefer the tracker; reach for the run history only when the tracker cannot
+answer the question. The mechanism itself — the two-part test, the single marker-deduped teardown
+proposal, and the three operator responses — is defined once in the `automation-runbook-contract`
+rule; these seeds only fill in each loop's specifics. A seed may add a **domain conjunct** on top of the contract's
+two-part test — an extra AND that must also hold — because an additional conjunct is strictly
+tighter and never divergent. It may never drop or weaken either of the contract's two conditions.
+Silence alone means obsolescence only for the gardener; for a monitoring or exploratory loop a quiet
+month usually means the project is healthy, which is exactly why those seeds carry a third conjunct.
 
 A loop not in this table — one registered later — seeds all ten sections from its own SKILL.md the
 same way. The table is seed prose for first write only; it is **not** a roster and never decides

package/plugins/lisa-agy/skills/lisa-tear-down-automations/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: lisa-tear-down-automations
-description: "Remove every recurring Lisa automation that /setup-automations registered for this project — whatever is actually registered under the lisa-auto-<project>-* prefix, including the opt-in learnings-audit gardener — using the CURRENT runtime's native scheduler — Codex automations or, on Claude, /schedule. This skill is a declarative specification: it identifies WHICH automations to remove; it does not run teardown scripts. Carries no fixed list of loops: the registration set is the roster. Removes only this project's Lisa automations — never other projects' automations or non-Lisa ones. Leaves checked-in runbook files on disk. The inverse of /setup-automations."
+description: "Remove recurring Lisa automations that /setup-automations registered for this project — either the whole lisa-auto-<project>-* fleet by default, or one named loop registration when approving a policy-obsolete proposal — using the CURRENT runtime's native scheduler — Codex automations or, on Claude, /schedule. This skill is a declarative specification: it identifies WHICH automations to remove; it does not run teardown scripts. Carries no fixed list of loops for fleet teardown: the registration set is the roster. Removes only this project's Lisa automations — never other projects' automations or non-Lisa ones. Leaves checked-in runbook files on disk. The inverse of /setup-automations."
 allowed-tools: ["Skill", "Bash", "Read"]
 ---
 
@@ -8,7 +8,9 @@ allowed-tools: ["Skill", "Bash", "Read"]
 
 This skill is a **specification, not a script.** It tells the current runtime which recurring Lisa
 automations to remove — the ones `/setup-automations` created for THIS project — and the runtime
-removes them with its **native** scheduling mechanism.
+removes them with its **native** scheduling mechanism. With no loop argument it removes the whole
+project fleet. With a loop id argument (for example `monitor` or `learnings-audit`) it removes only
+that one registered loop.
 
 ## Runtime scheduler (branch on the current runtime)
 
@@ -21,11 +23,15 @@ removes them with its **native** scheduling mechanism.
 
 ## Scope (remove only what setup created)
 
-- Remove **every** automation `/setup-automations` registered for the current project — the whole
+- By default, remove **every** automation `/setup-automations` registered for the current project — the whole
   set found under the stable `lisa-auto-<project>-` name prefix, whatever it currently contains.
   **Membership is registration, not a roster** (`automation-runbook-contract`): sweep the prefix and
   remove what is there. Do **not** work from a fixed list of loop names — a list drifts the moment a
   loop is added, which is exactly how the opt-in gardener came to be orphaned.
+- When `$ARGUMENTS` names a loop id from a `policy-obsolete` teardown proposal, remove only that
+  loop's registration under the same prefix, e.g. `lisa-auto-<project>-monitor`. Report every other
+  project automation left in place. If the named loop is absent, that single-loop teardown is a clean
+  no-op; do not widen it into a fleet teardown.
 - This explicitly includes the opt-in **`learnings-audit`** gardener when it is registered:
   `/setup-automations learnings-audit=true` registers it under the same prefix, so teardown removes
   it with the rest. A conditionally-skipped loop (e.g. `exploratory-bugs` on a stack without
@@ -40,6 +46,31 @@ removes them with its **native** scheduling mechanism.
   loops did. Teardown removes scheduler registrations only; it never deletes, edits, or moves a
   runbook file. An operator who wants them gone removes them deliberately, in git.
 
+## Answering a `policy-obsolete` teardown proposal
+
+Running this skill with the proposing loop id is the **approve** answer to a loop's own retirement
+proposal. When a registered loop's runbook **Retirement condition** trips, that loop records the
+`policy-obsolete` run outcome and files exactly one ticket recommending its own teardown
+(`automation-runbook-contract`) — and then keeps running at its normal cadence, because a loop never
+removes its own registration.
+Teardown is **always human-invoked**: it is never
+triggered by a loop, on any schedule, for any outcome. The operator has three answers, and only the
+first brings you here. The proposal authorizes only that loop's registration unless the human
+explicitly asks for fleet teardown.
+
+1. **Approve** — run this skill with the proposal's loop id, e.g.
+   `/lisa:tear-down-automations monitor`. When it has run, close the proposal as **Completed**: the
+   loop-scoped teardown it asked for actually happened, and Completed is the close reason that says
+   so.
+2. **Decline** — close the proposal as **Not planned** (that close reason is what stops the loop
+   re-raising it; **Completed** would leave a later re-file open). The loop simply continues at its
+   normal cadence, and nothing is removed.
+3. **Re-cadence** — you pick the longer cadence and re-register the loop with
+   `/lisa:setup-automations`; the loop never adjusts its own schedule. The proposal's evidence
+   carries the loop's **current cadence** as the baseline to choose against, plus a one-line summary
+   of its recent runs. Then close the proposal as **Completed** — the schedule change is the action
+   it asked for.
+
 ## Report
 
 List each automation removed by name. For "already absent", compare against the one source of truth

package/plugins/lisa-cdk/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa-cdk",
-  "version": "2.257.2",
+  "version": "2.258.1",
   "description": "AWS CDK-specific plugin",
   "author": {
     "name": "Cody Swann"

package/plugins/lisa-cdk/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa-cdk",
-  "version": "2.257.2",
+  "version": "2.258.1",
   "description": "AWS CDK-specific Lisa plugin.",
   "author": {
     "name": "Cody Swann"

package/plugins/lisa-cdk-agy/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa-cdk",
-  "version": "2.257.2",
+  "version": "2.258.1",
   "description": "AWS CDK-specific plugin",
   "author": {
     "name": "Cody Swann"

package/plugins/lisa-cdk-copilot/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa-cdk",
-  "version": "2.257.2",
+  "version": "2.258.1",
   "description": "AWS CDK-specific plugin",
   "author": {
     "name": "Cody Swann"

package/plugins/lisa-cdk-cursor/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa-cdk",
-  "version": "2.257.2",
+  "version": "2.258.1",
   "description": "AWS CDK-specific plugin",
   "author": {
     "name": "Cody Swann"

package/plugins/lisa-copilot/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa",
-  "version": "2.257.2",
+  "version": "2.258.1",
   "description": "Universal governance — agents, skills, commands, hooks, and rules for all projects",
   "author": {
     "name": "Cody Swann"

package/plugins/lisa-copilot/rules/eager/automation-runbook-contract.md

@@ -34,7 +34,8 @@ Health and operator action are **orthogonal** — a healthy run can still need a
   capability, then close the escalation item.
 - `policy-obsolete` — the loop's own retirement policy (the retirement condition written in its
   runbook) tripped, so it proposed its own teardown. **Healthy.** Operator action: approve the
-  teardown, decline it (close the proposal; the loop keeps running at cadence), or re-cadence it.
+  teardown, decline it (close the proposal as **Not planned**; the loop keeps running at cadence),
+  or re-cadence it.
 
 ## A run outcome is NOT a work-item lifecycle terminal state (CRITICAL)
 

package/plugins/lisa-copilot/rules/reference/automation-runbook-contract.md

@@ -84,6 +84,11 @@ Retirement condition
   cadence until someone approves, declines, or re-cadences it.
 ```
 
+That example's 30-day retirement row is **illustration of the shape, not the shipped default**: the
+seed `lisa-setup-automations` writes declares the three `intake-*` loops structural to the factory,
+whose runbooks state plainly that they do not retire. The mechanism below is normative; the numbers
+above are only a filled-in example.
+
 ## The six run outcomes
 
 Exactly one per run. The one-line operator summary is not optional — it is what the status surface
@@ -99,7 +104,7 @@ only `recovery-required` means the machinery itself is broken.
 | `change-proved` | The loop made a change and proved it with evidence. | Healthy | None — informational. | What changed and the evidence that proves it. |
 | `approval-requested` | The loop reached its autonomous/approval boundary and asked a human. | Healthy | Answer the approval question. | What is waiting, on whom, and what happens if nobody answers. |
 | `recovery-required` | The loop itself could not complete: access, tooling, or substrate is broken. | **Not healthy** — needs a human | Restore the named capability, then close the escalation item. | What broke, and the escalation item to act on. |
-| `policy-obsolete` | The loop's own retirement policy — the retirement condition written in its runbook — tripped, so it proposed its own teardown. | Healthy | Decide: approve the teardown, decline it (close the proposal; the loop continues at cadence), or re-cadence it. | Why it looks obsolete and the teardown-proposal item. |
+| `policy-obsolete` | The loop's own retirement policy — the retirement condition written in its runbook — tripped, so it proposed its own teardown. | Healthy | Decide: approve the teardown, decline it (close the proposal as **Not planned**; the loop continues at cadence), or re-cadence it. | Why it looks obsolete and the teardown-proposal item. |
 
 ### Exemplar one-line summaries
 
@@ -189,7 +194,9 @@ teardown-proposal item — matched on the marker, never the title — carrying t
 result and this run's summary as evidence, and proposing either a longer cadence or
 `lisa-tear-down-automations`. The loop **keeps running at its normal cadence** until an operator
 flips that proposal one of three ways: **approve** it (`lisa-tear-down-automations` runs and the
-registration goes away), **decline** it (close the proposal — the loop simply continues), or
+registration goes away), **decline** it (close the proposal as **Not planned** — closing it as
+**Completed** leaves a later re-file open, per `rejection-detection`'s proposal rejection memory;
+either way the loop simply continues), or
 **re-cadence** it (register it at the longer cadence instead of tearing it down). Retirement is a
 recommendation like any other, **never a self-executed exit**: a loop never deletes its own
 registration, and a proposal nobody answers changes nothing.

package/plugins/lisa-copilot/skills/lisa-exploratory-qa/SKILL.md

@@ -104,8 +104,13 @@ and records it, so a quiet run and a broken run are never mistaken for each othe
 | Findings filed — one or more `Bug` / `Improvement` tickets created or referenced (§6) | `candidate-proposed` |
 | Clean pass — explored the personas and surfaces, nothing worth filing — **or** every candidate was suppressed by a prior decline (`rejection-detection` **Proposal rejection memory**): the summary MUST name the suppression count | `nothing-needed` |
 | Tracker unconfigured — the §1 stop path; findings cannot be filed — **or** the open-and-closed rejection-memory marker search could not run (tracker unreachable / credentials revoked): a memory check that could not run is a broken loop, never a silent `nothing-needed` | `recovery-required` |
+| The runbook's **Retirement condition** tripped — the trailing quiet window is empty AND this pass found nothing to file AND the project no longer ships an exploratory-qa surface — this row supersedes the `nothing-needed` row when it applies | `policy-obsolete` |
 | A degradation that still let the pass explore (e.g. Kane unavailable, one persona unreachable) | the outcome it actually reached above, with the summary **leading with the degradation** — degradation never mints a seventh token |
 
+Before invoking the run-record CLI, evaluate the **Retirement condition** first. If it applies,
+select `policy-obsolete` as the sole outcome and do not record a prior `nothing-needed` result;
+otherwise select the ordinary outcome from the table.
+
 Record **exactly one** outcome per invocation through the run-record CLI, naming this loop's runbook
 (the `--summary` is the operator-readable one-liner in the contract's exemplar voice — plain,
 specific, actionable, e.g. `Explored 4 personas; nothing confusing to file.` — or, when a decline suppressed the only candidates, `Explored 4 personas; 2 candidates suppressed by a prior decline — nothing new to propose.` — for `nothing-needed`; and for a `recovery-required` from an unreadable decline check, `Tracker unreachable during the decline check — restore credentials; nothing was filed this run.`):
@@ -123,6 +128,42 @@ If `${CLAUDE_PLUGIN_ROOT}` is unset, resolve the plugin scripts directory direct
 abort** (per `automation-runbook-contract`): note the recording failure in the run output and finish
 the cycle — a recording failure is a degradation to report, never a reason to block the loop.
 
+**Retirement evaluation (every run).** Evaluate this loop's runbook **Retirement condition** on
+every run, exactly as the `automation-runbook-contract` rule's Retirement section defines it — this
+skill conforms to that text and never restates or diverges from it. On top of the contract's two
+conditions the runbook seeds a third **domain conjunct** — the project no longer ships an
+exploratory-qa command surface to explore — which only tightens the test and never replaces it: a
+quiet month on a product nobody broke is quality holding, not a reason to stop looking. Evaluate all
+three. When all three hold, record `policy-obsolete` and file **exactly ONE** marker-deduped
+teardown proposal through `lisa-tracker-write` (per `tracked-work` + `integration-access-layer`):
+
+- **Marker** `<!-- [lisa-automation-retire] key=exploratory-bugs -->` plus a visible prose line;
+  matched on the marker, never the title; searched **open AND closed** per `rejection-detection`'s
+  **Proposal rejection memory**. Treat matches by close state: **open** suppresses another proposal;
+  **Not planned** suppresses another proposal unless new evidence postdates the rejection;
+  **Completed** means the prior approved action happened, so a later recurrence may be re-filed.
+  When an existing proposal suppresses filing, **the run still records `policy-obsolete` and files
+  nothing** — the outcome describes this run, while the ticket is filed exactly once.
+- **Labels** `status:blocked` + `human-needed`, carrying the contract's decision-ready packet. The
+  `human-needed` label marks the proposal human-owned: `lisa-repair-intake` recognizes it and never
+  re-dispatches it as stalled work.
+- **Evidence** the date-filtered search result, this run's summary, **the loop's current cadence**
+  (the baseline an operator needs to choose a longer one), and a one-line summary of recent runs
+  read from `.lisa/automations/runs/exploratory-bugs.jsonl`. Fill the rest of the packet the same
+  way every time: *Work already attempted* is the searches this run ran, and *Risk of inaction* is
+  that the loop keeps consuming schedule slots and tokens for nothing.
+- **How to answer** names the three operator responses: **approve** — run
+  `/lisa:tear-down-automations exploratory-bugs` and only that loop registration goes away;
+  **decline** — close the proposal as
+  **Not planned** (closing it as **Completed** leaves a later re-file open) and the loop simply
+  continues; **re-cadence** — pick a longer cadence off that evidence and re-register with
+  `/lisa:setup-automations` instead of tearing down.
+- **Operator footer**, verbatim, as on every loop-filed proposal (`rejection-detection`):
+  > To stop this from being raised again, close it as **Not planned**. Close it as **Completed** if it was fixed — a later recurrence may be re-filed as a regression.
+
+The loop **keeps running at its normal cadence** until a human acts, and never deletes its own
+registration.
+
 ## Quality bar
 
 - Explore as a true first-time user — judge clarity, not whether you (who can read the code) can figure it out.

package/plugins/lisa-copilot/skills/lisa-intake/SKILL.md

@@ -131,6 +131,7 @@ matches the mode this cycle ran in: **`intake-prd`** (PRD-side dispatch) or **`i
 | A build cycle that shipped and verified (merged PR + evidence), or a shipped PRD moved to `verified` | `change-proved` |
 | A protected deployment (or other autonomy boundary the lifecycle hits) waiting on a human approval | `approval-requested` |
 | The queue itself is misconfigured or unreadable — missing required input (step 1) or an unreachable Status/workflow (step 2/`3` misconfig) so the cycle could not run | `recovery-required` |
+| The runbook's **Retirement condition** tripped | `policy-obsolete` — **never reached by design for either intake loop-id** (see Retirement evaluation below) |
 
 **Seam warning (the #1 misread in this ticket).** A run outcome describes this *cycle*; `Blocked` is
 a *work item's* lifecycle terminal state — the two never merge in the summary. When Intake correctly
@@ -156,6 +157,13 @@ If `${CLAUDE_PLUGIN_ROOT}` is unset, resolve the plugin scripts directory direct
 abort** (per `automation-runbook-contract`): note the recording failure in the run output and finish
 the cycle — a recording failure is a degradation to report, never a reason to block the loop.
 
+**Retirement evaluation (every run).** Both loop-ids this skill backs are **structural to the
+factory — they do not retire.** Their runbooks say so plainly instead of leaving the Retirement
+condition blank, so the `automation-runbook-contract` rule's two-part retirement test never fires
+here: neither `intake-prd` nor `intake-tickets` ever records `policy-obsolete`, and neither ever
+files a teardown proposal. An operator who wants intake to stop runs `/lisa:tear-down-automations`
+themselves — the loop never removes its own registration.
+
 ## Schedule examples
 
 ```text

package/plugins/lisa-copilot/skills/lisa-learnings-audit/SKILL.md

@@ -339,8 +339,10 @@ failure is a degradation to report, never a reason to block the loop.
 
 ## Retirement condition
 
-The loop retires itself by the same discipline it applies to everything else,
-and the condition is **stateless — derived from the tracker, never from a
+The loop proposes retirement by the same discipline it applies to everything else,
+conforming to the `automation-runbook-contract` rule's Retirement section
+rather than restating or diverging from it. The condition is **stateless —
+derived from the tracker, never from a
 counter or state file** (there is no durable home for a run counter, and a
 tracker-derived condition is headless- and concurrent-safe by construction).
 Propose retirement when BOTH hold:
@@ -352,11 +354,46 @@ Propose retirement when BOTH hold:
 2. **This run proposes nothing** — the current run's inventory yields zero
    candidates (it is terminating `nothing-needed`).
 
-When both hold, the gardener files ONE (marker-deduped) ticket proposing to
-lengthen its cadence or tear down its automation (`/tear-down-automations`),
-with the date-filtered search result and this run's summary as evidence. It
-keeps running until a human flips that ticket — retirement is a
-recommendation like any other, never a self-executed exit.
+When both hold, the gardener records `policy-obsolete` and files **exactly ONE**
+marker-deduped ticket proposing to lengthen its cadence or tear down its
+automation, through `lisa-tracker-write` (per `tracked-work` +
+`integration-access-layer`):
+
+- **Marker** `<!-- [lisa-automation-retire] key=learnings-audit -->` plus a
+  visible prose line; matched on the marker, never the title; searched **open
+  AND closed** per `rejection-detection`'s **Proposal rejection memory**. Treat
+  matches by close state: **open** suppresses another proposal; **Not planned**
+  suppresses another proposal unless new evidence postdates the rejection;
+  **Completed** means the prior approved action happened, so a later recurrence
+  may be re-filed. The `[lisa-gardener]` search above stays what it is — the
+  candidate evidence, not the dedupe key. When an existing proposal suppresses
+  filing, **the run still records `policy-obsolete` and files nothing** — the
+  outcome describes this run, while the ticket is filed exactly once.
+- **Labels** `status:blocked` + `human-needed`, carrying the contract's
+  decision-ready packet. The `human-needed` label marks the proposal
+  human-owned: `lisa-repair-intake` recognizes it and never re-dispatches it as
+  stalled work.
+- **Evidence** the date-filtered search result, this run's summary, **the
+  loop's current cadence** (the baseline an operator needs to choose a longer
+  one), and a one-line summary of recent runs read from
+  `.lisa/automations/runs/learnings-audit.jsonl`. Fill the rest of the packet
+  the same way every time: *Work already attempted* is the searches this run
+  ran, and *Risk of inaction* is that the loop keeps consuming schedule slots
+  and tokens for nothing.
+- **How to answer** names the three operator responses: **approve** — run
+  `/lisa:tear-down-automations learnings-audit` and only that loop registration goes away; **decline** —
+  close the proposal as **Not planned** (closing it as **Completed** leaves a
+  later re-file open) and the gardener simply continues; **re-cadence** — pick a
+  longer cadence off that evidence and re-register with
+  `/lisa:setup-automations` instead of tearing down.
+- **Operator footer**, verbatim, as on every loop-filed proposal
+  (`rejection-detection`):
+  > To stop this from being raised again, close it as **Not planned**. Close it as **Completed** if it was fixed — a later recurrence may be re-filed as a regression.
+
+The gardener **keeps running at its normal cadence** until a human flips that
+ticket — retirement is a recommendation like any other, never a self-executed
+exit — and it never deletes its own
+registration.
 
 ## Scheduling
 

package/plugins/lisa-copilot/skills/lisa-monitor/SKILL.md

@@ -152,6 +152,7 @@ so a quiet monitoring run and a broken one never look identical.
 | Anomalies or in-scope gaps filed — one or more `Bug` / `Task` / `Improvement` leaves created or referenced | `candidate-proposed` |
 | Clean sweep — health/audit ran end to end, nothing over the bar and no in-scope gaps — **or** every finding was suppressed by a prior decline (`rejection-detection` **Proposal rejection memory**): the summary MUST name the suppression count | `nothing-needed` |
 | Provider/threshold resolution failure — threshold collection fails (a present-but-uninspectable config, an invalid configured threshold) or a signal provider is unreachable so the sweep could not run — **or** the open-and-closed rejection-memory search could not read the tracker: a memory check that could not run is a broken loop, never a silent `nothing-needed` | `recovery-required` |
+| The runbook's **Retirement condition** tripped — the trailing quiet window is empty AND this sweep found nothing AND no connected observability surfaces are left — this row supersedes the `nothing-needed` row when it applies | `policy-obsolete` |
 | A degradation that still let the sweep run (an optional `ops-specialist` overlay absent, Kane unavailable) | the outcome it actually reached above, with the summary **leading with the degradation** — degradation never mints a seventh token |
 
 Only the **standalone** run records. The nested report-only modes do their own job and do not file or
@@ -159,6 +160,10 @@ record: `--report-only` (including the `lisa-verify` post-deploy call, whose sum
 the originating item) and `--dry-run` (a preview that creates nothing) are not registered-loop
 invocations.
 
+Before invoking the run-record CLI, evaluate the **Retirement condition** first. If it applies,
+select `policy-obsolete` as the sole outcome and do not record a prior `nothing-needed` result;
+otherwise select the ordinary outcome from the table.
+
 Record **exactly one** outcome per standalone invocation through the run-record CLI, naming this
 loop's runbook (the `--summary` is the operator-readable one-liner in the contract's exemplar voice —
 plain, specific, actionable, e.g. `Health green; audit clean — nothing to propose.` for
@@ -177,3 +182,39 @@ If `${CLAUDE_PLUGIN_ROOT}` is unset, resolve the plugin scripts directory direct
 `plugins/src/base/scripts/automation-run-record.mjs`. If recording still fails, **degrade, never
 abort** (per `automation-runbook-contract`): note the recording failure in the run output and finish
 the cycle — a recording failure is a degradation to report, never a reason to block the loop.
+
+**Retirement evaluation (every run).** Evaluate this loop's runbook **Retirement condition** on
+every standalone run, exactly as the `automation-runbook-contract` rule's Retirement section defines
+it — this skill conforms to that text and never restates or diverges from it. On top of the
+contract's two conditions the runbook seeds a third **domain conjunct** — the project has no
+connected observability surfaces left, so there is nothing to monitor — which only tightens the test
+and never replaces it: a quiet month on a healthy project is good news, not a reason to stop
+watching it. Evaluate all three. When all three hold, record `policy-obsolete` and file
+**exactly ONE** marker-deduped teardown proposal through `lisa-tracker-write`
+(per `tracked-work` + `integration-access-layer`):
+
+- **Marker** `<!-- [lisa-automation-retire] key=monitor -->` plus a visible prose line; matched on
+  the marker, never the title; searched **open AND closed** per `rejection-detection`'s **Proposal
+  rejection memory**. Treat matches by close state: **open** suppresses another proposal;
+  **Not planned** suppresses another proposal unless new evidence postdates the rejection;
+  **Completed** means the prior approved action happened, so a later recurrence may be re-filed.
+  When an existing proposal suppresses filing, **the run still records `policy-obsolete` and files
+  nothing** — the outcome describes this run, while the ticket is filed exactly once.
+- **Labels** `status:blocked` + `human-needed`, carrying the contract's decision-ready packet. The
+  `human-needed` label marks the proposal human-owned: `lisa-repair-intake` recognizes it and never
+  re-dispatches it as stalled work.
+- **Evidence** the date-filtered search result, this run's summary, **the loop's current cadence**
+  (the baseline an operator needs to choose a longer one), and a one-line summary of recent runs
+  read from `.lisa/automations/runs/monitor.jsonl`. Fill the rest of the packet the same way every
+  time: *Work already attempted* is the searches this run ran, and *Risk of inaction* is that the
+  loop keeps consuming schedule slots and tokens for nothing.
+- **How to answer** names the three operator responses: **approve** — run
+  `/lisa:tear-down-automations monitor` and only that loop registration goes away; **decline** — close the proposal as
+  **Not planned** (closing it as **Completed** leaves a later re-file open) and the loop simply
+  continues; **re-cadence** — pick a longer cadence off that evidence and re-register with
+  `/lisa:setup-automations` instead of tearing down.
+- **Operator footer**, verbatim, as on every loop-filed proposal (`rejection-detection`):
+  > To stop this from being raised again, close it as **Not planned**. Close it as **Completed** if it was fixed — a later recurrence may be re-filed as a regression.
+
+The loop **keeps running at its normal cadence** until a human acts, and never deletes its own
+registration.

package/plugins/lisa-copilot/skills/lisa-project-ideation/SKILL.md

@@ -303,12 +303,17 @@ so a quiet ideation run and a broken one are never confused.
 | Nothing to ideate — no Practical Idea cleared the bar; nothing created — **or** every idea was suppressed by a prior decline (`rejection-detection` **Proposal rejection memory**): the summary MUST name the suppression count | `nothing-needed` |
 | The Step 5.5 **PRD-queue-pressure gate** blocked auto-ready creation — a human must drain the queue before another auto-ready PRD is added | `approval-requested` |
 | The loop itself could not run — the PRD source reader failed or the queue is misconfigured (a source-reader failure snapshot, not queue pressure) — **or** the open-and-closed rejection-memory marker search could not read the source: a memory check that could not run is a broken loop, never a silent `nothing-needed` | `recovery-required` |
+| The runbook's **Retirement condition** tripped — the trailing quiet window is empty AND this run proposed nothing AND no unresolved PRD pressure exists while no new surface has shipped — this row supersedes the `nothing-needed` row when it applies | `policy-obsolete` |
 | A degradation that still let ideation run (optional Codex automation memory unavailable, an inspiration source unreachable) | the outcome it actually reached above, with the summary **leading with the degradation** — degradation never mints a seventh token |
 
 The pressure gate is `approval-requested`, **not** `recovery-required`: the loop ran fine and
 correctly declined to add queue pressure — it is asking a human to drain the queue, not reporting a
 broken machine. `recovery-required` is reserved for the loop failing to run at all.
 
+Before invoking the run-record CLI, evaluate the **Retirement condition** first. If it applies,
+select `policy-obsolete` as the sole outcome and do not record a prior `nothing-needed` result;
+otherwise select the ordinary outcome from the table.
+
 Record **exactly one** outcome per invocation through the run-record CLI, naming this loop's runbook
 (the `--summary` is the operator-readable one-liner in the contract's exemplar voice — plain,
 specific, actionable, e.g. `Reviewed evidence; no practical idea cleared the bar — nothing to
@@ -328,6 +333,43 @@ If `${CLAUDE_PLUGIN_ROOT}` is unset, resolve the plugin scripts directory direct
 abort** (per `automation-runbook-contract`): note the recording failure in the run output and finish
 the run — a recording failure is a degradation to report, never a reason to block the loop.
 
+**Retirement evaluation (every run).** Evaluate this loop's runbook **Retirement condition** on
+every run, exactly as the `automation-runbook-contract` rule's Retirement section defines it — this
+skill conforms to that text and never restates or diverges from it. On top of the contract's two
+conditions the runbook seeds a third **domain conjunct** — no unresolved PRD pressure exists and the
+project has shipped no new surface to ideate against — which only tightens the test and never
+replaces it: a quiet month because the queue was full is the loop working, not the loop being
+obsolete. Evaluate all three. When all three hold, record `policy-obsolete` and file **exactly ONE**
+marker-deduped teardown proposal through `lisa-tracker-write` (per `tracked-work` +
+`integration-access-layer`):
+
+- **Marker** `<!-- [lisa-automation-retire] key=exploratory-prds -->` plus a visible prose line;
+  matched on the marker, never the title; searched **open AND closed** per `rejection-detection`'s
+  **Proposal rejection memory**. Treat matches by close state: **open** suppresses another proposal;
+  **Not planned** suppresses another proposal unless new evidence postdates the rejection;
+  **Completed** means the prior approved action happened, so a later recurrence may be re-filed.
+  When an existing proposal suppresses filing, **the run still records `policy-obsolete` and files
+  nothing** — the outcome describes this run, while the ticket is filed exactly once.
+- **Labels** `status:blocked` + `human-needed`, carrying the contract's decision-ready packet. The
+  `human-needed` label marks the proposal human-owned: `lisa-repair-intake` recognizes it and never
+  re-dispatches it as stalled work.
+- **Evidence** the date-filtered search result, this run's summary, **the loop's current cadence**
+  (the baseline an operator needs to choose a longer one), and a one-line summary of recent runs
+  read from `.lisa/automations/runs/exploratory-prds.jsonl`. Fill the rest of the packet the same
+  way every time: *Work already attempted* is the searches this run ran, and *Risk of inaction* is
+  that the loop keeps consuming schedule slots and tokens for nothing.
+- **How to answer** names the three operator responses: **approve** — run
+  `/lisa:tear-down-automations exploratory-prds` and only that loop registration goes away;
+  **decline** — close the proposal as
+  **Not planned** (closing it as **Completed** leaves a later re-file open) and the loop simply
+  continues; **re-cadence** — pick a longer cadence off that evidence and re-register with
+  `/lisa:setup-automations` instead of tearing down.
+- **Operator footer**, verbatim, as on every loop-filed proposal (`rejection-detection`):
+  > To stop this from being raised again, close it as **Not planned**. Close it as **Completed** if it was fixed — a later recurrence may be re-filed as a regression.
+
+The loop **keeps running at its normal cadence** until a human acts, and never deletes its own
+registration.
+
 ## Out of scope (hard rules)
 
 - **No fabricated personas.** No evidence citation → no persona; generic roles banned without
@@ -339,8 +381,9 @@ the run — a recording failure is a degradation to report, never a reason to bl
 - **Tests, lint, typecheck, and build are not the empirical verification plan** — they are
   prerequisites; verification must observe user-facing behavior.
 - **Do not create tracker tickets or mutate the host project's code.** PRD creation (via
-  `lisa-research`) is the only write this skill performs; ticket planning (`lisa-plan`) and
-  implementation (`lisa-implement`) are separate, user-invoked flows.
+  `lisa-research`) is the only normal write this skill performs; the only tracker-ticket exception is
+  the exactly-one marker-deduped `policy-obsolete` teardown proposal described above. Ticket planning
+  (`lisa-plan`) and implementation (`lisa-implement`) are separate, user-invoked flows.
 - **Do not write PRDs to the source directly** — always go through `lisa-research` →
   `lisa-prd-source-write` so the source stays switchable.
 - **Do not add a new verification/browser-automation framework** when one already exists — reuse it.