claude-code-session-manager 0.111.0 → 0.112.0

package/plugins/session-manager-dev/skills/memory-sanitation/SKILL.md

@@ -1,147 +0,0 @@
----
-name: memory-sanitation
-description: >-
-  Audit every memory in the current project's auto-memory store, fold anything now
-  duplicated in an always-loaded instruction file (global CLAUDE.md, project CLAUDE.md,
-  or a plugin skill's SKILL.md) into that file and delete the memory, verify and delete
-  memories whose tracked PRD/incident has since landed or expired, trim memories that are
-  part-stale, and leave genuinely current non-duplicated memories alone. Ends with a
-  structured summary (counts + per-memory outcome) suitable for display in a UI. Use
-  whenever the user says "/memory-sanitation", "clean up memory", "sanitize memory",
-  "audit my memories", "combine and remove memories", or asks what should move from
-  memory into system instructions. Keywords: memory, sanitation, sanitize, cleanup, audit,
-  dedupe, prune, CLAUDE.md, instructions, stale memory.
----
-
-# /memory-sanitation — audit → fold/delete/trim/keep → report
-
-**Role:** a periodic hygiene pass over `<memory-dir>/*.md` (the auto-memory store described
-in the top-level system instructions — one file per memory, indexed by `MEMORY.md`). Memory
-exists to recall things NOT already guaranteed to reach the assistant another way. Once a
-memory's content is baked into something always-loaded (CLAUDE.md, a skill's SKILL.md) or the
-event it tracked has resolved (a PRD landed, an incident closed, a pause expired), it is dead
-weight: it costs retrieval relevance and maintenance, and duplicated content risks drifting out
-of sync with the authoritative copy.
-
-**Never** delete a memory just because it's old — staleness is about resolution, not age. A
-memory describing a standing architecture fact that's still true and still nowhere else stays,
-no matter how old.
-
-## Procedure
-
-1. **Locate the memory dir** — the path in the system instructions'
-   `auto memory` section (`~/.claude/projects/<encoded-cwd>/memory/`). List every `*.md` file
-   except `MEMORY.md` itself.
-
-2. **Read every memory file in full**, plus `MEMORY.md`'s index, plus the project's own
-   `CLAUDE.md` (and the global `~/.claude/CLAUDE.md`) and the skill files under
-   `plugins/*/skills/*/SKILL.md` if the project ships a dev-skill plugin. You need all of
-   these loaded to judge duplication.
-
-3. **Classify each memory** into exactly one bucket:
-   - **DELETE — baked in.** The memory's content (a process rule, a behavioral preference, a
-     standing architecture fact) is now verbatim or near-verbatim present in an always-loaded
-     instruction file. Confirm with a direct text comparison, not a vibe check, before deleting.
-   - **DELETE — resolved/expired.** The memory tracks a PRD, incident, or temporary state
-     (a dev pause, a "queued as PRD NN" note, a "bug found, not yet fixed" note) whose tracked
-     event has since concluded. Verify before deleting — don't assume from the memory's own
-     text that something landed:
-     - PRD status: check `~/.claude/session-manager/scheduled-plans/queue.json` (or the
-       project's own scheduler queue file) for the PRD slug's `status` field, or
-       `prds-archived/` for a withdrawn/archived one.
-     - Code claims: `grep`/`ls` the file(s) and line(s) the memory cites — confirm the
-       described function/constant/behavior still exists as described (or confirm it's gone,
-       which is its own signal the memory is obsolete).
-     - Git history: `git log --oneline --all | grep <PRD-or-feature-slug>` when queue.json
-       doesn't resolve it.
-   - **FOLD then DELETE.** The memory is a durable, project-wide rule that belongs in an
-     instruction file but isn't there yet (a cross-project rule → global `~/.claude/CLAUDE.md`;
-     a this-project convention → project `CLAUDE.md`'s `## Conventions`/`## Avoid`; a
-     process/routing rule for a specific skill → that skill's `SKILL.md`). Write it into the
-     target file first, in that file's own voice and section, then delete the memory. Two
-     overlapping memories covering the same territory fold into ONE rule, not two.
-
-     **FOLD MUST NOT GROW AN ALWAYS-LOADED FILE.** A `CLAUDE.md` is read on every turn of every
-     session; this skill is the only process that routinely writes *into* one, which makes it a
-     one-way ratchet — memory gets a sanitation pass, `CLAUDE.md` becomes its landfill, and nothing
-     ever evicts from the landfill. So:
-     - If the target `CLAUDE.md` declares a **size budget**, honour it. Check `wc -c` first. If the
-       fold would breach it, fold the *rule* into `CLAUDE.md` as one line and its rationale into
-       whichever linked reference doc that file points at — never append the full memory body.
-     - Prefer the **narrowest** always-loaded target: a specific `SKILL.md` over project
-       `CLAUDE.md`, and project over global. Only a genuinely cross-project rule earns the global file.
-     - A fold that adds more than ~2 lines to a `CLAUDE.md` is a signal you're moving narrative, not
-       a law. Compress to the imperative rule and drop the history.
-     - Report the net char delta per instruction file you touched in the step-7 summary, so a run
-       that quietly added 3k to an always-loaded file is visible rather than counted as "cleanup".
-   - **TRIM.** The memory mixes durable facts with dated, closed narrative (a deploy log, a
-     PRD-tracking blow-by-blow, "verified live" status updates). Keep only what's still true
-     and not written down elsewhere; cut the rest. Re-verify any code claim you keep (grep it).
-   - **KEEP.** Genuinely current, non-duplicated, still load-bearing. Leave it — don't rewrite
-     for style.
-
-4. **Fix cross-references.** Any memory you delete or fold may be `[[wikilinked]]` from a
-   surviving memory. Grep `<memory-dir>/*.md` for the deleted memory's `name:` slug and update
-   the reference — point it at the new location (an instruction-file section) or drop the link
-   if nothing replaces it. A dangling `[[link]]` to a file that no longer exists is a bug.
-
-5. **Rewrite `MEMORY.md`'s index** to match exactly what's on disk after steps 3–4. Re-read the
-   directory listing immediately before writing — another session or a background job may have
-   added a memory mid-run (this has happened in practice); never clobber a concurrent addition
-   with a stale full-file overwrite. Prefer `Edit` for point changes; only rewrite the whole
-   index when you've just re-confirmed the current file list.
-
-6. **Collision safety for instruction-file edits.** Before editing `CLAUDE.md` or any
-   `SKILL.md`, `git status --short` that specific file. If it's already dirty from unrelated
-   concurrent work, use small targeted `Edit`s (never a full-file `Write`) so you can't discard
-   someone else's in-flight change.
-
-7. **Report a structured summary**, both as your end-of-turn text and in a form a UI can render
-   directly (a JSON object is fine when invoked programmatically — see Output shape below):
-   counts per bucket, and for each memory: its name, the bucket, and a one-line reason. If
-   invoked from a UI trigger (see `## UI trigger` below), keep the summary tight enough to
-   render in a side panel — lead with the counts, then a short list, not full memory bodies.
-
-## Output shape (for programmatic/UI invocations)
-
-When this skill is invoked non-interactively (e.g. from the Memory tab's Sanitize button), end
-the run by printing a single fenced JSON block as the last thing in the transcript, so the
-caller can parse it without scraping prose:
-
-```json
-{
-  "totalBefore": 26,
-  "totalAfter": 9,
-  "deleted": [{ "name": "feedback_fix_dont_ask", "reason": "baked into CLAUDE.md + develop/SKILL.md" }],
-  "folded": [{ "name": "feedback_nav_microservices", "into": "CLAUDE.md ## Avoid", "reason": "merged with feedback_extend_dont_add_tabs" }],
-  "trimmed": [{ "name": "web_remote_v2_mobile", "reason": "PRDs landed; cut deploy-log narrative" }],
-  "kept": [{ "name": "no_schedule_self_e2e", "reason": "active, tracks open PRD" }],
-  "instructionFileDelta": [{ "file": "CLAUDE.md", "charsBefore": 11576, "charsAfter": 11702, "delta": 126, "withinBudget": true }]
-}
-```
-
-`instructionFileDelta` is required whenever the run wrote to any always-loaded instruction file
-(`CLAUDE.md`, a `SKILL.md`). It is what makes a FOLD-heavy run that grew an always-loaded file by
-3k visible instead of counted as "cleanup" — see the FOLD rule above. Set `withinBudget: false`
-(and say so in the prose summary) if the file declares a size budget and the run breached it.
-
-Still print the normal human-readable summary too — the JSON block is additive, not a
-replacement.
-
-## UI trigger
-
-The Memory tab (`src/renderer/components/tabs/Memory.tsx`) has (or will have, per the queued
-PRD) a "Sanitize memory" button that fires this skill as a headless run and renders the JSON
-summary above. When authoring or reviewing that wiring, this skill is the contract: the button
-sends a prompt that invokes `/memory-sanitation`, and the tab parses the trailing JSON block
-from the run's final message. Don't hand-roll a second summary shape in the renderer — parse
-this skill's own output shape.
-
-## Notes
-
-- This is a hygiene pass, not a content-authoring pass — don't use it to write NEW memories,
-  only to reconcile existing ones against instruction files and resolved state.
-- Don't delete a memory solely because it's short, or solely because it's old. Staleness is
-  "the thing it tracked resolved" or "it's now duplicated elsewhere" — not age or length.
-- Don't run this against another project's memory store without being asked — memory dirs are
-  per-project (`~/.claude/projects/<encoded-cwd>/memory/`); stay scoped to the current cwd.

package/plugins/session-manager-dev/skills/ops-sweep/SKILL.md

@@ -1,137 +0,0 @@
----
-name: ops-sweep
-description: >-
-  Run the operations-folder maintenance protocol (see
-  session-manager-operations/architecture/ops-maintenance-protocol.md) against
-  ANY project's session-manager-operations/ folder — including a project with
-  a different OWNERS vocabulary than session-manager's own, or no CLAUDE.md at
-  all. Diffs declared-vs-actual namespace ownership, flags doc contradictions
-  (one doc says retired, another says still owned), and flags archived content
-  with no stated retention policy. Never deletes or migrates anything itself —
-  findings are reported to the human, or queued as PRDs in the current session
-  when the user asks for that. Use whenever the user says "/ops-sweep", "sweep the
-  ops folder", "audit operations hygiene", "check for ops drift", or wants the
-  maintenance protocol run against a project (this one or another). Keywords:
-  ops sweep, operations hygiene, namespace drift, OWNERS audit, retention
-  policy, doc contradiction.
----
-
-# ops-sweep
-
-**Role:** the automated, portable version of
-`session-manager-operations/architecture/ops-maintenance-protocol.md`'s Pattern F —
-a *finder*, never an *actor*. It reports drift between a project's declared
-architecture and what's actually on disk; a human (via a proposed Epic)
-decides what to do about it.
-
-Read the protocol doc in full before running this the first time, especially
-Pattern F ("generalizing to other projects") — this skill is that
-generalization.
-
-## What it does NOT assume
-
-Unlike this project's own `scripts/audit-ops-hygiene.cjs` (which hardcodes
-session-manager's OWNERS vocabulary — `feedback`, `scheduler`, `prompt-sessions`,
-etc.), this skill makes **no assumption about the target project's namespace
-names, its OWNERS table shape, or whether it has a CLAUDE.md at all**. It
-re-derives the source-of-truth hierarchy from what that specific project has:
-
-**Hand-authored-PRD detection stays out of this generic script on purpose.**
-`audit-ops-hygiene.cjs`'s Pattern E (cross-referencing a live PRD `.md` file
-against the machine-wide `prd_create` audit log to flag a PRD that bypassed
-`scheduler_create_prd`) requires session-manager's own scheduler/PRD/audit-log
-concepts, which a swept project may not even have — adding it here would break
-the "no assumption about vocabulary" guarantee above. When sweeping
-session-manager's own repo, run `node scripts/audit-ops-hygiene.cjs` alongside
-this skill and fold its Pattern C/D/E findings into the same report; when
-sweeping a different project, Pattern E simply doesn't apply.
-
-1. That project's own `CLAUDE.md` (if present) — the declared architecture.
-2. Each namespace's own `README.md` under its `session-manager-operations/<namespace>/`.
-3. On-disk content — folder names, and archived/processed subfolders.
-
-A project with no `CLAUDE.md` still gets a useful sweep: every namespace is
-reported `mentionedInClaudeMd: false` (nothing to compare against), so
-`MISSING_README` and `NO_RETENTION_POLICY` findings still fire; contradiction
-detection is simply skipped since there's no second doc layer to disagree.
-
-## How to run it
-
-```bash
-node "$SM_ROOT/scripts/ops-sweep.cjs" <target-project-cwd>
-```
-
-`$SM_ROOT` is `.` when you're already working inside the session-manager repo,
-otherwise four directories up from this file's own path (the installed package
-root).
-
-`<target-project-cwd>` is the project to sweep — it does **not** need to be
-the project you're currently working in. Sweeping session-manager's own repo
-(`.`) is a valid, common case (that's how the maintenance protocol doc itself
-was written), but so is sweeping a different project this machine has opened
-a TAB on.
-
-The script prints a JSON report to stdout:
-
-```jsonc
-{
-  "targetCwd": "...",
-  "opsRoot": "<cwd>/session-manager-operations",
-  "hasClaudeMd": true,
-  "namespaceCount": 12,
-  "namespaces": [ { "name": "...", "findings": [ { "type": "...", "detail": "..." } ] }, ... ],
-  "findings": [ { "namespace": "...", "type": "...", "detail": "..." }, ... ]
-}
-```
-
-Finding `type`s:
-- **MISSING_README** — namespace dir has no `README.md`.
-- **UNDOCUMENTED** — namespace name never appears anywhere in the target's
-  `CLAUDE.md` (no declared ownership, no explicit non-owned mention either).
-- **CONTRADICTION** — either (a) the same clause of `CLAUDE.md` uses both
-  "retired/gone" language and "owner/owns" language about this namespace, or
-  (b) the namespace's own README and `CLAUDE.md` disagree on whether it's
-  retired.
-- **NO_RETENTION_POLICY** — namespace has files under an archived/processed
-  subfolder but its README says nothing about how long they're kept or who
-  prunes them.
-
-## Text-heuristic findings need a sanity check before filing
-
-Detecting "the same clause talks about both retirement and ownership" is a
-regex heuristic over prose, not a parser — it can flag a namespace whose
-CLAUDE.md text legitimately describes a partial retirement (e.g. "the old
-flat layout under this namespace is retired" while the namespace itself is
-still owned) as a false-positive CONTRADICTION. Before filing each finding,
-read the actual CLAUDE.md clause and README the script points at and confirm
-the drift is real. Don't file findings you can see are heuristic noise.
-
-## Routing findings — never act directly
-
-This skill (and the script it runs) never deletes, moves, or archives
-anything. Once you've sanity-checked the findings:
-
-- **Default**: report the findings to the human, grouped by namespace (one
-  block per namespace, not one per finding line — mirrors how Pattern A in the
-  protocol doc was resolved as a single unit). State the namespace, the doc
-  locations that disagree, and what decision needs to be made. Do NOT open an
-  Epic anywhere: an Epic is created only by a human pressing New Epic, and that
-  is doubly true across a project boundary.
-- **If the user asks for PRDs in this session** (e.g. "just queue it here",
-  "PRDs on this session" — the mode used when this protocol doc's own findings
-  were resolved) — queue the work as PRDs in the *current* Epic's scheduler via
-  `/develop`. Only when the sweep target IS the current project; never author
-  PRDs into another project.
-
-Report back: namespace count swept, finding count by type, and the Epic
-id(s) or PRD(s) filed.
-
-## When NOT to use this
-
-- The user wants a one-off answer about a single namespace they already named
-  → just read that namespace's README and the relevant CLAUDE.md section
-  directly; don't run the full sweep for a question with a known answer.
-- Cron/scheduled sweeping across every active project cwd is an explicit
-  stretch goal, not implemented here — this skill is manual, single-project,
-  invoked per run. `src/main/lib/watchdogHelpers.cjs`'s `activeProjectCwds()`
-  is the reusable piece if that's ever built.

package/plugins/session-manager-dev/skills/pr-review-sweep/0-fetch/SKILL.md

@@ -1,41 +0,0 @@
----
-name: pr-review-sweep:fetch
-description: Step 0 of pr-review-sweep — fetch every unresolved review thread on one or more of the current project's PRs, fully paginated. Never trust file names, a prior status report, or a reply's own claim about what's outstanding.
----
-
-# pr-review-sweep:fetch
-
-Query GitHub's GraphQL API directly for each PR. Resolve `$owner`/`$name` from the current
-project's own remote — `gh repo view --json owner,name -q '.owner.login,.name'` — never
-hardcode a repo.
-
-```graphql
-query($owner: String!, $name: String!, $n: Int!) {
-  repository(owner: $owner, name: $name) {
-    pullRequest(number: $n) {
-      reviewThreads(first: 100) {
-        totalCount
-        nodes {
-          isResolved
-          path
-          line
-          comments(first: 3) { nodes { author { login } body createdAt } }
-        }
-      }
-    }
-  }
-}
-```
-
-Filter to `isResolved: false`. **`first: 100` is load-bearing** — `first: 50` silently
-truncates on any PR that has grown past 50 threads (two real PRs hit this: one had 64
-threads, another had 55; the truncated queries under-reported unresolved counts and caused
-genuinely-missed comments). Always compare `totalCount` to how many nodes you actually
-paged through, and keep paginating (`after:` cursor) until they match — never report a
-count you haven't verified is complete.
-
-## Output
-
-One unresolved-thread list per PR, each entry carrying: the PR number, thread id, file
-path + line, and full comment text/author/timestamp — everything `pr-review-sweep:classify`
-needs to decide disposition and type without a second round-trip to GitHub.

package/plugins/session-manager-dev/skills/pr-review-sweep/1-classify/SKILL.md

@@ -1,56 +0,0 @@
----
-name: pr-review-sweep:classify
-description: Step 1 of pr-review-sweep — classify each unresolved review thread on two independent axes — disposition (accept-as-is / policy-override / needs-my-decision) and type (bug / feature) — so downstream steps can route and template correctly.
----
-
-# pr-review-sweep:classify
-
-Decided per-thread, never per-PR — a single PR routinely mixes threads that need very
-different handling.
-
-## Axis 1 — disposition
-
-- **Accept-as-is** — the reviewer's ask is valid, no repo-policy reason not to do it. The
-  default bucket.
-- **Policy-override** — the comment conflicts with something the repo's own `AGENTS.md` /
-  `CLAUDE.local.md` already decided (a staged-rollout convention, an intentional
-  trade-off). Policy wins silently — no need to escalate to the user — but still reply
-  explaining why, so the reviewer isn't left wondering. Verify the policy text actually
-  says what you think it says before invoking this bucket; don't assume.
-- **Needs-my-decision** — a genuine judgment call with no clear answer from repo policy
-  alone. Stop, surface the question verbatim to the user, never guess. This bucket blocks
-  only that one thread — every other thread on the PR keeps moving. A needs-my-decision
-  thread never gets a type tag (axis 2 is moot until it's decided to do the work at all).
-
-## Axis 2 — type (accept-as-is and policy-override threads only)
-
-- **Bug** — the reviewer flagged something objectively broken: wrong output, a crash, a
-  security issue, an off-by-one, a missed edge case. Anything where "what should happen
-  instead" is unambiguous from the current code being wrong.
-- **Feature** — the reviewer asked for additional behavior, a refactor, or a
-  consistency/style improvement that isn't fixing broken behavior. If the current code does
-  what it currently does *on purpose* and the ask is to make it do something more or
-  different, it's a feature, not a bug — even when phrased urgently.
-
-When genuinely ambiguous between the two (e.g. "this should also handle nulls" — is null
-input a bug the code should already handle, or new scope?), default to **bug** only if
-there's a concrete failing case (a real input that breaks today); otherwise **feature**.
-Record the reasoning either way — `pr-review-sweep:queue` uses it to pick the PRD template,
-and a future reader should be able to see why a borderline call went the way it did.
-
-## Known-pattern check (if the project curates one)
-
-Before finalizing type/reasoning, check whether the thread matches an already-documented
-recurring pattern. Some projects keep a curated, evolving corpus of past review findings
-(commonly `docs/review-*.md`, indexed from `docs/README.md`, fed by a project-local
-`project-status-local` mining step — sigma is the reference example). If such docs exist in
-this repo and the thread matches a named pattern there, say so in the reasoning and cite the
-doc/section — it strengthens the bug-vs-feature call (a documented recurring bug is bug,
-full stop) and carries forward to `:queue`. If no such docs exist, or the thread doesn't
-match anything in them, this is a no-op — don't go hunting for docs a project doesn't have.
-
-## Output
-
-Per thread: `{disposition, type | null, reasoning}`. Needs-my-decision threads carry the
-open question verbatim, collected for the final report rather than blocking the other
-threads.

package/plugins/session-manager-dev/skills/pr-review-sweep/2-check-fixed/SKILL.md

@@ -1,49 +0,0 @@
----
-name: pr-review-sweep:check-fixed
-description: Step 2 of pr-review-sweep — before queuing anything, triage every accept-as-is / policy-override thread into already-fixed, reply-only (no code change needed), or genuinely-open. Mandatory for every survivor, including policy-override threads — skipping it on the assumption "policy-override never needs a code check" is what caused a real wrong reply (see below).
----
-
-# pr-review-sweep:check-fixed
-
-Read the current file content at the cited location, and check recent git log/commits on
-the PR's actual branch, for **every** accept-as-is/policy-override thread — no exceptions
-for threads that look like a pure confirmation ask. **This step is mandatory before posting
-any reply, not optional for policy-override threads.**
-
-**Incident that made this mandatory:** on sigma PR #206, a policy-override thread (empty-
-string EIK display) was replied to with "leaving as-is, test locks in current behavior"
-without re-checking the code first — but the thread had *already been fixed* two commits
-earlier by a different session. The wrong reply had to be corrected with a follow-up
-comment. The cause wasn't a broken tool, it was skipping this step because the thread's
-disposition (policy-override) felt like it obviously needed no verification. It didn't
-obviously need verification — but it needed it anyway, and every thread does.
-
-## Triage into three outcomes, not two
-
-1. **Already-fixed** — the code (or a recent commit on the PR's branch) already does what
-   the thread asks. Routes straight to `pr-review-sweep:land-and-resolve`, citing the
-   fixing commit SHA. Skips `:queue` entirely.
-2. **Reply-only, no code change needed** — the thread is fully answered by information
-   that already exists (a repo convention, an intentional design documented elsewhere, a
-   fact about the code the reviewer didn't have) and genuinely requires zero code change to
-   resolve — not "a trivial one-line fix," but literally nothing to write. Common for
-   policy-override threads whose reviewer ask was really a question ("confirm X is
-   intentional") rather than a change request. Routes straight to
-   `pr-review-sweep:land-and-resolve`, citing the evidence/reasoning instead of a SHA.
-   **Do not send these to `:queue`** — queuing a PRD to "fix" a thread that needs no fix
-   wastes a scheduler run and produces a PRD with no real acceptance criteria to execute.
-3. **Genuinely open** — needs an actual code change that doesn't exist yet. Goes to
-   `pr-review-sweep:queue` as before, carrying its `{disposition, type}` tags.
-
-The dividing line between outcomes 2 and 3: if you can point to the exact existing
-line/paragraph that answers the reviewer's ask, it's outcome 2. If satisfying the ask
-requires writing or changing any code, however small, it's outcome 3 — don't downgrade a
-real fix to "reply-only" just because it's tiny; that's what `:queue`'s bug/feature
-templates are for, sized appropriately.
-
-## Output
-
-Three lists per PR:
-- **already-fixed** (thread id + the commit/line that fixed it) → `:land-and-resolve`
-- **reply-only** (thread id + the evidence/reasoning to cite) → `:land-and-resolve`
-- **survives** (thread id, disposition, type) → `:queue`

package/plugins/session-manager-dev/skills/pr-review-sweep/3-queue/SKILL.md

@@ -1,57 +0,0 @@
----
-name: pr-review-sweep:queue
-description: Step 3 of pr-review-sweep — bundle surviving accept-as-is/policy-override threads by (PR, type) and queue one /develop PRD per bundle. Never fixes inline; the scheduler is the only place code changes happen.
----
-
-# pr-review-sweep:queue
-
-Only ever receives the **survives** list from `pr-review-sweep:check-fixed` — threads that
-genuinely need a code change that doesn't exist yet. `check-fixed` has already routed
-already-fixed and reply-only threads straight to `land-and-resolve`, so if you're looking
-at a thread here, it needs real code written; don't second-guess that by trying to answer
-it with a reply instead of a PRD.
-
-Group `survives` threads by **(PR number, type)** — up to two bundles per PR, one `bug` and
-one `feature`. Queue each bundle as its own `/develop` PRD. Never write the fix in this
-session; this step's own actions are read-only except for the act of queuing.
-
-## Duplicate-PRD guard (idempotency)
-
-Before queuing a bundle, check the scheduler queue for an existing queued/in-flight PRD for
-that same (PR, type). If one exists, skip queuing and report the existing PRD id instead —
-re-running `pr-review-sweep` must never double-queue the same bundle. If a thread newly
-qualifies for a bundle that already has an in-flight PRD (e.g. a fresh review comment
-landed after the PRD was queued but before it completed), do not silently fold it in —
-queue a follow-up PRD once the first completes, so each PRD's diff stays traceable to a
-known snapshot of threads.
-
-## PRD acceptance criteria, by type
-
-Every PRD, regardless of type, ends with: commit + push to the fork branch that owns the
-PR (never `origin`, never force-push, never a new PR to carry a review fix — land on the
-existing PR's branch), and the standard two independent verification passes before commit.
-
-- **`bug` bundle** — additionally require: reproduce each defect described in the bundled
-  threads, write a regression test per defect that fails before the fix and passes after,
-  then fix. The PRD body should quote the reviewer's exact wording per thread so the
-  executor root-causes the actual reported defect, not a guessed one. If `:classify` flagged
-  a thread as matching a known documented pattern (see its "Known-pattern check"), the PRD
-  must say so explicitly and instruct the executor to **grep the rest of the codebase for
-  the same pattern, not just fix the one flagged instance** — several of sigma's own
-  documented patterns (e.g. an SSR-unsafe `useLayoutEffect`, an un-deduped array into a D1
-  `IN (...)`) turned out to be the exact same bug copy-pasted across 5+ sibling files, each
-  caught as a separate review comment on a separate PR because the first fix never swept the
-  rest. One PRD closing all occurrences beats N PRDs closing them one review cycle at a time.
-- **`feature` bundle** — additionally require: scope the change to exactly what each
-  bundled thread asked for (no piggybacked scope creep across threads even though they're
-  bundled together), match existing patterns/conventions in the touched files, and add a
-  test only if the ask itself introduces new testable behavior.
-
-Neither template authorizes a description edit or a reviewer request — those stay
-`pr-review-sweep:land-and-resolve`'s and `pr-signal`'s jobs respectively, so a PR's
-description reflects the *final* landed state, not a snapshot mid-fix.
-
-## Output
-
-Per (PR, type) bundle: a queued PRD id (new or pre-existing), or — if `survives` was empty
-for that PR — nothing to queue, reported as such rather than silently skipped.

package/plugins/session-manager-dev/skills/pr-review-sweep/4-land-and-resolve/SKILL.md

@@ -1,60 +0,0 @@
----
-name: pr-review-sweep:land-and-resolve
-description: Step 4 of pr-review-sweep — reply on the GitHub thread and resolve it, via one of three entry points from check-fixed/queue (already-fixed, reply-only, or a completed PRD). Runs async relative to steps 0-3 for the PRD path, typically triggered by a later project-status-local pass noticing a completed PRD.
----
-
-# pr-review-sweep:land-and-resolve
-
-Three entry points:
-
-1. **Already-fixed threads** from `pr-review-sweep:check-fixed` — no PRD to wait on, act
-   immediately, citing the commit that step already identified.
-2. **Reply-only threads** from `pr-review-sweep:check-fixed` — no PRD, no commit; act
-   immediately, citing the evidence/reasoning `check-fixed` already worked out (a repo
-   convention, an intentional-design confirmation, a fact about the code the reviewer
-   didn't have). **Re-verify that reasoning is still accurate right now, not just at
-   classify time** — code moves between when a thread was classified and when you're about
-   to reply; don't post a stale "confirmed" against code that's since changed.
-3. **Queued PRDs** from `pr-review-sweep:queue` that the scheduler now reports
-   `completed` — this is where this step actually waits on external state; a fresh
-   `/project-status` (or manual) run is what notices the PRD finished and re-enters here.
-
-## Steps
-
-1. **For the PRD entry point only:** confirm the PRD actually ran its required
-   verification — both independent passes, and (for a `bug` bundle) that the regression
-   test genuinely exists and is green, not just claimed in the PRD's own summary. A PRD
-   marked `completed` without evidence of the ACs having run is `needs_review`, not landed —
-   report it as stuck, don't proceed to reply/resolve. (Already-fixed and reply-only
-   entries have no PRD to verify — skip to step 2.)
-2. **Confirm CI is green** on the PR (for the PRD entry point, after the PRD's commit
-   landed; for already-fixed/reply-only, CI state is whatever it already is).
-3. **Reply** on each thread — naming the specific fixing commit SHA for already-fixed/PRD
-   entries, or the evidence/reasoning for reply-only entries — so the reviewer can verify
-   without re-reading the whole diff or re-asking the question.
-4. **Resolve** the thread via GraphQL `resolveReviewThread`. Order matters: reply first,
-   resolve second, so there's a paper trail explaining why a thread closed before it drops
-   off the unresolved list.
-
-Needs-my-decision threads (set aside back in `pr-review-sweep:classify`), and any
-policy-override thread where convention says the reviewer should be the one to close it,
-are deliberately left unresolved after the reply — that is correct behavior, not an
-oversight.
-
-## Stuck PRDs
-
-A `failed` or `needs_review` PRD is reported to the user as a stuck bundle, never silently
-retried and never silently downgraded to an inline fix — re-queuing or fixing it directly
-both require the user's decision, since either implies the original PRD's scope or ACs
-were wrong.
-
-## Hard constant
-
-**Never contact a reviewer** at any point in this step — replying to a thread and
-resolving it are not reviewer contact; requesting/re-requesting one is `pr-signal`'s job
-alone, gated separately.
-
-## Output
-
-Per thread: resolved (+ the SHA it was resolved against), or reported as blocked (PRD
-still in flight, or stuck) — loops back to `project-status-local`'s rollup either way.