mandrel 1.90.0 → 1.92.0

package/.agents/scripts/update-mutation-baseline.js

@@ -1,189 +0,0 @@
-#!/usr/bin/env node
-/**
- * update-mutation-baseline.js — Refresh `baselines/mutation.json` from a
- * fresh Stryker run (Story #1736, Task #1752 + #1753).
- *
- * Reads the configured mutation gate (`delivery.quality.gates.mutation`),
- * invokes the Stryker runner from `lib/mutation/stryker-runner.js`, and
- * atomically rewrites the baseline file with the new per-workspace
- * mutation scores. Preserves the configured `tolerancePct` (from the
- * gate's `tolerance.value`) so the file is self-contained — consumers
- * don't need to read `.agentrc.json` to interpret the baseline.
- *
- * Exit codes:
- *   0 — baseline refreshed (didChange true) or no change (didChange false)
- *   0 — Stryker skipped (no config) with an explanatory line on stderr
- *   1 — Stryker invocation failed
- *
- * The refresh is intentionally non-fatal when Stryker is not configured:
- * the operator can run `npx stryker init` and re-invoke this script.
- *
- * DORMANT BY DESIGN (Story #3665). This script and the rest of the
- * mutation-testing surface ship built-but-unwired: Mandrel declares no
- * `delivery.quality.gates.mutation` block and no `stryker.conf.*`, so the
- * gate never enters the `check-baselines` pipeline and this refresh
- * self-skips (no Stryker config detected). The dormancy is an evaluated,
- * intentional opt-in — not an oversight. A spike (Story #3665) concluded
- * DEFER on activation. The essential rationale, preserved here so it does
- * not depend on a point-in-time writeup:
- *
- *   - Cost model: a full `.agents/scripts` Stryker baseline is a
- *     tens-of-minutes-to-multi-hour job even under `coverageAnalysis:
- *     'perTest'` at `concurrency: 8`. Stryker reruns the affected test set
- *     once per mutant (~5,000–6,500 mutants over ~19k effective LOC), and
- *     Mandrel's tests live in a sibling `tests/` tree (not colocated with
- *     source), so there is no cheap per-source-file partition for `perTest`
- *     to exploit. Activation therefore belongs on a nightly `schedule`
- *     (never per-PR), with PR-time `check-baselines` consuming the
- *     nightly-produced baseline as a read-only ratchet.
- *   - Baseline-shape fit: the kernel/check side keys mutation rows by
- *     `path` (`lib/baselines/kinds/mutation.js` — per-file rows + per-
- *     component rollup, the right fit for this single-package repo), but
- *     this refresh writer (`lib/mutation/baseline-snapshot.js`) emits a
- *     workspace-keyed `{ workspaces: { '*': score } }` snapshot that
- *     collapses to one repo-wide number with zero per-file resolution.
- *     The two shapes do not agree; activation must first reconcile this
- *     writer to emit the kernel's path-keyed `rows[]`/`rollup` envelope.
- *   - Prerequisites: a `node --test` Stryker runner integration (no
- *     first-party `@stryker-mutator` plugin exists for the Node built-in
- *     runner), the shape reconciliation above, and nightly CI plumbing —
- *     together an Epic-sized effort, not a config flip.
- *
- * Re-evaluate (promote to an activation Epic) when a coverage-gamed
- * regression ships, the project migrates to a test runner with first-party
- * Stryker support, or an operator opts in for a specific high-risk subtree.
- */
-
-import path from 'node:path';
-
-import { resolveDiffScope } from './lib/baselines/diff-scope-cli.js';
-import { runAsCli } from './lib/cli-utils.js';
-import {
-  getQuality,
-  PROJECT_ROOT,
-  resolveConfig,
-} from './lib/config-resolver.js';
-import { Logger } from './lib/Logger.js';
-import {
-  DEFAULT_BASELINE_PATH,
-  DEFAULT_TOLERANCE_PCT,
-  writeBaseline,
-} from './lib/mutation/baseline-snapshot.js';
-import { runStryker } from './lib/mutation/stryker-runner.js';
-
-/**
- * Resolve the mutation gate config relevant to baseline refresh.
- *
- * @param {object} config Canonical resolved config (`resolveConfig()` output).
- * @returns {{ baselinePath: string, tolerancePct: number, strykerConfigPath: string | null }}
- */
-export function resolveMutationGate(config) {
-  const quality = getQuality(config);
-  const gate = quality.gates?.mutation ?? {};
-  const baselinePath =
-    typeof gate.baselinePath === 'string' && gate.baselinePath.length > 0
-      ? gate.baselinePath
-      : DEFAULT_BASELINE_PATH;
-  const tol = gate.tolerance;
-  const tolerancePct =
-    tol &&
-    typeof tol === 'object' &&
-    Number.isFinite(tol.value) &&
-    tol.value >= 0
-      ? tol.value
-      : DEFAULT_TOLERANCE_PCT;
-  const strykerConfigPath =
-    typeof gate.strykerConfigPath === 'string' &&
-    gate.strykerConfigPath.length > 0
-      ? gate.strykerConfigPath
-      : null;
-  return { baselinePath, tolerancePct, strykerConfigPath };
-}
-
-/**
- * @param {{
- *   cwd?: string,
- *   runStrykerFn?: typeof runStryker,
- *   writeBaselineFn?: typeof writeBaseline,
- *   resolveConfigFn?: typeof resolveConfig,
- *   logger?: { info?: (m: string) => void, warn?: (m: string) => void, error?: (m: string) => void },
- * }} [opts]
- * @returns {Promise<{ status: 0 | 1, didChange: boolean, skipped: boolean, reason?: string, baselinePath: string }>}
- */
-export async function refreshMutationBaseline({
-  cwd = PROJECT_ROOT,
-  runStrykerFn = runStryker,
-  writeBaselineFn = writeBaseline,
-  resolveConfigFn = resolveConfig,
-  logger = Logger,
-} = {}) {
-  const config = resolveConfigFn({ cwd });
-  const gate = resolveMutationGate(config);
-  const absBaseline = path.isAbsolute(gate.baselinePath)
-    ? gate.baselinePath
-    : path.resolve(cwd, gate.baselinePath);
-
-  logger.info?.(`[mutation] refreshing baseline → ${gate.baselinePath}`);
-  const runResult = await runStrykerFn({
-    cwd,
-    configPath: gate.strykerConfigPath,
-  });
-  if (runResult.skipped) {
-    logger.info?.(
-      `[mutation] skipped — ${runResult.reason ?? 'runner reported skip'}`,
-    );
-    return {
-      status: 0,
-      didChange: false,
-      skipped: true,
-      reason: runResult.reason ?? 'runner-skip',
-      baselinePath: absBaseline,
-    };
-  }
-  if (!runResult.ok) {
-    logger.error?.(
-      `[mutation] Stryker invocation failed: ${runResult.error ?? 'unknown error'}`,
-    );
-    return {
-      status: 1,
-      didChange: false,
-      skipped: false,
-      reason: runResult.error ?? 'stryker-failed',
-      baselinePath: absBaseline,
-    };
-  }
-
-  const writeResult = writeBaselineFn(absBaseline, {
-    tolerancePct: gate.tolerancePct,
-    workspaces: runResult.byWorkspace,
-  });
-
-  if (writeResult.didChange) {
-    logger.info?.(`[mutation] baseline updated at ${gate.baselinePath}`);
-  } else {
-    logger.info?.(`[mutation] baseline unchanged at ${gate.baselinePath}`);
-  }
-
-  return {
-    status: 0,
-    didChange: writeResult.didChange,
-    skipped: false,
-    baselinePath: absBaseline,
-  };
-}
-
-async function main() {
-  // Story #1974 — `--diff-scope` accepted for CLI parity with other
-  // update-*-baseline scripts; no row-narrowing effect because mutation
-  // baseline is workspace-keyed (not file-keyed).
-  const diffScope = resolveDiffScope({ argv: process.argv.slice(2) });
-  if (diffScope) {
-    Logger.info(
-      `[mutation] --diff-scope ${diffScope.ref}: noted (informational only).`,
-    );
-  }
-  const result = await refreshMutationBaseline();
-  if (result.status !== 0) process.exit(result.status);
-}
-
-runAsCli(import.meta.url, main, { source: 'update-mutation-baseline' });

package/.agents/workflows/explain.md

@@ -1,118 +0,0 @@
----
-description:
-  Walk the operator through a code change until they genuinely understand it.
-  Targets a PR, a branch, or the working-tree diff, then drives the
-  `core/knowledge-transfer` skill (restate-first, why-ladder, mastery gates,
-  persistent checklist) with an operator-controlled stop at every checkpoint.
----
-
-# /explain [PR# | branch | --staged | --diff <ref>]
-
-## Overview
-
-`/explain` is the **operator-facing comprehension command**. Use it when code
-landed (or is about to) and you want to be sure you actually understand it —
-the problem it solves, why it was solved this way, the design decisions, the
-edge cases, and the blast radius. It is the after-the-fact counterpart to
-[`/plan`](helpers/plan-epic.md) Phase 11 (which walks the operator through a
-*plan* before delivery); both drive the same engine.
-
-```text
-/explain 1234            → walk through merged/open PR #1234
-/explain story-104       → walk through the diff of branch story-104 vs main
-/explain --staged        → walk through the currently staged changes
-/explain --diff HEAD~3   → walk through the diff from HEAD~3 to working tree
-/explain                 → no subject given: ask what to explain, then proceed
-```
-
-This command **delegates the method** to the
-[`core/knowledge-transfer`](../skills/core/knowledge-transfer/SKILL.md) skill.
-This file owns only **subject resolution** (which diff) and the handoff into
-that skill. Read the skill before running — it defines the loop, the
-why-ladder, the depth levels, the quizzing rules, and the operator-stop
-contract.
-
-## When to use `/explain`
-
-| Scenario | Command |
-| --- | --- |
-| Understand a change that already merged | `/explain <PR#>` |
-| Understand a branch before merging it | `/explain <branch>` |
-| Understand what you are about to commit | `/explain --staged` |
-| Understand a freshly planned Epic backlog | `/plan` Phase 11 (automatic) |
-
-## Step 1 — Resolve the subject
-
-Determine the change to explain from the argument:
-
-- **PR number** (`/explain 1234`) — read the PR metadata and diff:
-
-  ```bash
-  gh pr view 1234 --json title,body,state,headRefName,baseRefName
-  gh pr diff 1234
-  ```
-
-- **Branch** (`/explain story-104`) — diff the branch against the base
-  branch (`project.baseBranch`, default `main`):
-
-  ```bash
-  git diff main...story-104
-  ```
-
-- **`--staged`** — the staged working-tree changes:
-
-  ```bash
-  git diff --staged
-  ```
-
-- **`--diff <ref>`** — an explicit diff range:
-
-  ```bash
-  git diff <ref>
-  ```
-
-- **No argument** — ask the operator which PR, branch, or range they want
-  walked through, then resolve as above. Do not guess.
-
-Read the resolved diff **and** the surrounding code it touches before
-explaining anything — ground every explanation in the real artifact, never
-the title alone.
-
-## Step 2 — Drive the comprehension loop
-
-Activate [`core/knowledge-transfer`](../skills/core/knowledge-transfer/SKILL.md)
-with the resolved change as the subject. Follow the skill exactly:
-
-1. **Frame & gather** — state the change in one sentence; write the checklist
-   to `temp/comprehension-<subject>.md`.
-2. **Restate-first** — ask the operator what they already understand before
-   explaining.
-3. **Fill gaps one layer at a time** along the why-ladder
-   (problem → why → branches → solution → why this solution → design
-   decisions → edge cases → broader impact), confirming mastery at each layer
-   and offering the stop exit before advancing.
-4. **Close** — summarize coverage, note any unchecked items, leave the
-   checklist artifact in place.
-
-Honor depth requests (ELI5 / intern / peer) and quiz via the host's
-structured-question mechanism when it sharpens understanding.
-
-## Constraints
-
-- **Operator-invoked only.** Never auto-fire `/explain`, and never run it
-  inside a non-interactive delivery sub-agent — there is no operator to
-  teach.
-- **Operator controls the exit.** Stop the moment the operator says they are
-  satisfied; this command never blocks or gates anything.
-- **Read-only.** `/explain` teaches; it does not modify code, tickets, or
-  branches. The only file it writes is the `temp/` checklist artifact.
-
-## See also
-
-- [`core/knowledge-transfer`](../skills/core/knowledge-transfer/SKILL.md) —
-  the comprehension engine this command drives.
-- [`/plan`](helpers/plan-epic.md) — Phase 11 runs the same engine over a plan
-  before delivery.
-- `/code-review` (Claude Code built-in) — correctness review of a diff. A
-  different concern: `/explain` builds *operator* understanding, not a defect
-  list.

package/.agents/workflows/git-merge-pr.md

@@ -1,377 +0,0 @@
----
-description: >-
-  Analyze, validate, resolve conflicts, and merge a given pull request by
-  number.
----
-
-# /git-merge-pr [#PR_LIST]
-
-This workflow performs a full end-to-end merge of one or more pull requests: it
-analyzes each PR diff, validates linting and tests, resolves any merge
-conflicts, and completes the merge into the target base branch.
-
-> **When to run**: Any time one or more PRs are ready for merge review and you
-> want an automated merge with conflict resolution and quality gates enforced.
->
-> **Persona**: `devops-engineer` · **Skills**:
-> `core/git-workflow-and-versioning`
-
----
-
-## Step 0 — Resolve Context
-
-1. Resolve one or more `[PR_NUMBER]` values from the slash-command argument
-   (e.g. `/git-merge-pr 42 43 45` → `PR_LIST=[42, 43, 45]`).
-2. **Sequential Loop**: Steps 1 through 7 must be performed **sequentially** for
-   each PR in the `PR_LIST`. Complete the full merge and cleanup for one PR
-   before starting the next.
-3. For the current `[PR_NUMBER]`, fetch metadata from GitHub by calling
-   `mcp__github__pull_request_read` (method `get`) with the repo's
-   `owner` / `repo` and `pullNumber: [PR_NUMBER]`. From the response, read
-   `number`, `title`, `headRefName`, `baseRefName`, `state`, `mergeable`,
-   and `mergeStateStatus`.
-
-4. From the output, resolve:
-   - `[PR_TITLE]` — the PR title.
-   - `[HEAD_BRANCH]` — the source branch (`headRefName`).
-   - `[BASE_BRANCH]` — the merge target (`baseRefName`).
-   - `[PR_STATE]` — must be `OPEN`. If `CLOSED` or `MERGED`, **SKIP** this PR
-     and proceed to the next one in the list.
-   - `[MERGEABLE]` — initial GitHub mergeability signal (`MERGEABLE`,
-     `CONFLICTING`, or `UNKNOWN`).
-
----
-
-## Step 1 — PR Analysis
-
-Fetch the full diff and review the scope of changes:
-
-```powershell
-gh pr diff [PR_NUMBER]
-```
-
-> **Why `gh pr diff` and not MCP?** `mcp__github__pull_request_read`'s
-> `get_diff` method returns a structured response rather than the raw
-> unified diff this step renders to the operator. `gh pr diff` stays
-> until MCP exposes a raw-diff equivalent.
-
-Summarize the following to the operator before proceeding:
-
-- **Files changed** (count and list).
-- **Lines added / removed**.
-- **Areas of concern** — any files that touch shared utilities, schemas,
-  migrations, or critical infrastructure.
-- **Initial mergeability status** from Step 0.
-
-> This is a read-only analysis step. No files are modified yet.
-
----
-
-## Step 2 — Checkout & Sync
-
-Delegate the rebase orchestration to `git-rebase-and-resolve.js`. It fetches
-`origin`, checks out the head branch, and rebases it onto the base — then
-reports the outcome in structured form so this skill routes on outcome
-instead of re-implementing the retry loop.
-
-```powershell
-node .agents/scripts/git-rebase-and-resolve.js --onto origin/[BASE_BRANCH] --head [HEAD_BRANCH] --json
-```
-
-Parse the JSON result. Route on `outcome`:
-
-- `clean` → rebase landed with no conflicts. Proceed to Step 3.
-- `conflict` → `conflictedFiles[]` lists the unmerged paths. Proceed to
-  Step 2.5.
-- `error` → git returned an error unrelated to conflicts. **STOP** and
-  surface `stderr` to the operator.
-
-### Step 2.5 — Conflict Resolution
-
-Follow the shared conflict-resolution procedure in
-[`helpers/_merge-conflict-template.md`](helpers/_merge-conflict-template.md):
-read both sides
-of each file in `conflictedFiles[]`, apply both when compatible (or choose a
-side with an explicit rationale), never silently drop code, then stage the
-resolutions.
-
-Continue the rebase via the script — it calls `git rebase --continue` and
-reports whether the rebase is now clean, still has conflicts (cascading
-conflict), or hit a different error:
-
-```powershell
-node .agents/scripts/git-rebase-and-resolve.js --continue --json
-```
-
-Loop until `outcome` is `continued`. If you need to bail out entirely:
-
-```powershell
-node .agents/scripts/git-rebase-and-resolve.js --abort --json
-```
-
-Once the rebase completes cleanly, force-push the rebased branch:
-
-```powershell
-git push --force-with-lease origin [HEAD_BRANCH]
-```
-
----
-
-## Step 3 — Quality Gate (Lint + Format + Test)
-
-Run the full lint / format / test suite via the gate wrapper. The wrapper
-owns the command list so this skill doesn't rot when a project renames
-`lint` → `lint:ci` or swaps Biome for ESLint. The default check set is
-`lint`, `format:check`, `test`; override via `.agentrc.json → github.branchProtection`.
-
-```powershell
-node .agents/scripts/git-pr-quality-gate.js --json
-```
-
-The script emits a JSON result `{ ok, checks: [...], failed: [...] }`.
-Exit code 0 means every check passed. On failure:
-
-1. Read the `failed[]` entries (each has `name` and `reason`).
-2. For **format** failures, run `npx biome format --write .` to auto-fix,
-   then re-run the gate.
-3. For **lint** failures, apply the minimal manual fix.
-4. For **test** failures, classify before fixing:
-   - **Pre-existing failures** (unrelated to this PR's diff): alert the
-     operator and ask whether to proceed or block.
-   - **Regression introduced by this PR**: apply the fix.
-5. Commit the fixes and re-push:
-
-   ```powershell
-   git add .
-   # justification: post-CI remediation; CI lint+test gate ran upstream and produced the failure being fixed here. Local hook would re-run the same gate.
-   git commit --no-verify -m "fix(ci): resolve quality-gate failures on [HEAD_BRANCH] for PR #[PR_NUMBER]"
-   git push origin [HEAD_BRANCH]
-   ```
-
-6. Re-run the gate until it exits 0 before continuing to Step 3.5.
-
-> If a failure cannot be resolved after exhausting reasonable remediation
-> attempts, **STOP** and escalate to the operator with a detailed summary.
-
----
-
-## Step 3.5 — Unified Baselines Gate (`check-baselines`)
-
-`check-baselines.js` is the single canonical floor + tolerance + schema
-gate for every baseline kind (coverage, crap, maintainability, mutation).
-It owns absolute-floor enforcement, schema validation, and kernel-mismatch
-surfacing. The per-kind regression CLIs that previously layered on top of
-this gate were removed in Epic #1943 — `check-baselines.js` is now the
-sole source of truth for baseline regressions at merge time.
-
-```powershell
-node .agents/scripts/check-baselines.js --format text
-```
-
-Exit codes:
-
-- `0` — every enabled gate's floors are met and no schema errors.
-- `1` — any floor breach. Inspect the JSON output
-  (`--format json`, the default) to see which kind / component / axis
-  fell below floor.
-- `2` — any baseline failed schema validation. Regenerate the offending
-  baseline through its per-kind update script.
-- `3` — config resolution error (typically a malformed `.agentrc.json`).
-
-Treat any non-zero exit as a hard merge block before proceeding to Step 4.
-
----
-
-## Step 4 — Final Mergeability Check
-
-Re-query GitHub to confirm the PR is now clean and ready to merge by
-calling `mcp__github__pull_request_read` (method `get`) with the repo's
-`owner` / `repo` and `pullNumber: [PR_NUMBER]`. Read `mergeable`,
-`mergeStateStatus`, `reviewDecision`, and `statusCheckRollup` from the
-response (the same fields the prior `gh pr view --json` shape exposed).
-
-Verify:
-
-- `mergeable` is `MERGEABLE`.
-- `mergeStateStatus` is `CLEAN` or `HAS_HOOKS`.
-- Required CI checks (if any) are passing (`statusCheckRollup` → all `SUCCESS`
-  or `NEUTRAL`).
-
-If any blocking condition remains, resolve it before proceeding to the merge
-step.
-
----
-
-## Step 5 — Merge
-
-Merge the PR as a squash commit and delete the head branch. Call
-`mcp__github__merge_pull_request` with the repo's `owner` / `repo`,
-`pullNumber: [PR_NUMBER]`, `merge_method: "squash"`, and
-`delete_branch: true`.
-
-> **MCP coverage gap — auto-merge queueing.** `mcp__github__merge_pull_request`
-> performs an **immediate** merge; it does not enable GitHub's native
-> auto-merge queue. When the workflow needs to queue the merge behind
-> required-check completion (the default `--auto` posture), fall back to
-> the shell form `gh pr merge [PR_NUMBER] --auto --squash --delete-branch`.
-> Use the MCP call when CI is already green and the merge can fire
-> synchronously (the common case after a clean Step 4 verdict).
->
-> **Merge strategy guidance** (override with operator instruction):
->
-> - `mcp__github__merge_pull_request` with `merge_method: "squash"` — the
->   default for an already-green PR; clean history, single squash commit.
-> - `gh pr merge [PR_NUMBER] --auto --squash --delete-branch` — auto-merge
->   queueing fallback when required checks are still pending. Requires
->   `allow_auto_merge=true` on the repo (Story #1239 turns this on).
-> - `gh pr merge [PR_NUMBER] --squash` (no `--auto`) — synchronous merge;
->   use only when bypassing auto-merge is intentional (e.g. CI is broken
->   and a hotfix is going in under admin override).
-> - `--merge` — preserves the full commit history from `[HEAD_BRANCH]` (use for
->   Epic branches with meaningful commit granularity); pass `merge_method:
->   "merge"` to the MCP call or `--merge` to `gh pr merge`.
-> - `--rebase` — linear history; ideal for small, atomic PRs; pass
->   `merge_method: "rebase"` to the MCP call or `--rebase` to `gh pr merge`.
-
-After the merge command returns, perform a conflict marker scan to confirm no
-stray markers entered the base branch. Delegate to `detect-merges.js` — it
-owns the scan logic and is the same script used by `/deliver` Phase 5.3.
-
-```powershell
-git checkout [BASE_BRANCH]
-git pull origin [BASE_BRANCH]
-node .agents/scripts/detect-merges.js
-```
-
-If the script exits non-zero: **STOP**, alert the operator immediately, and
-do not proceed until the conflict markers are resolved.
-
----
-
-## Step 6 — Post-Merge Verification & Cleanup
-
-Confirm the merge landed correctly on the base branch:
-
-```powershell
-git log origin/[BASE_BRANCH] -5 --oneline
-```
-
-Verify that the top commit corresponds to the merged PR.
-
-Explicitly delete the remote head branch. This is **mandatory** and must always
-succeed — even if the Husky pre-push hook blocks `git push origin --delete`. Use
-the **two-stage** approach below:
-
-**Stage 1 — git push (fast path):**
-
-```powershell
-# Attempt standard deletion first (fast, uses existing auth)
-git push origin --delete [HEAD_BRANCH] 2>$null
-$gitDeleteOk = $LASTEXITCODE -eq 0
-```
-
-**Stage 2 — REST API fallback (always run if Stage 1 failed):**
-
-If Stage 1 fails (exit code ≠ 0, e.g., due to Husky hook blocking the push),
-fall back to the GitHub REST API using the token from the git credential store:
-
-```powershell
-if (-not $gitDeleteOk) {
-  # Retrieve token from git's native credential manager
-  $creds = "protocol=https`nhost=github.com`n" | git credential fill 2>$null
-  $token = ($creds | Select-String 'password=(.+)').Matches[0].Groups[1].Value
-
-  if ($token) {
-    $url = "https://api.github.com/repos/[OWNER]/[REPO]/git/refs/heads/[HEAD_BRANCH]"
-    $headers = @{ Authorization = "token $token"; Accept = "application/vnd.github.v3+json" }
-    try {
-      Invoke-RestMethod -Method DELETE -Uri $url -Headers $headers -ErrorAction Stop
-      Write-Host "Remote branch deleted via REST API: [HEAD_BRANCH]"
-    } catch {
-      $status = $_.Exception.Response.StatusCode.value__
-      if ($status -eq 422 -or $status -eq 404) {
-        Write-Host "Branch already gone (HTTP $status) — skipping."
-      } else {
-        Write-Warning "Failed to delete remote branch via API (HTTP $status): [HEAD_BRANCH]"
-      }
-    }
-  } else {
-    Write-Warning "No GitHub token found in credential store — remote branch may not be deleted."
-  }
-}
-```
-
-Prune stale remote-tracking refs and delete the local branch:
-
-```powershell
-git fetch --prune
-git branch -D [HEAD_BRANCH] 2>$null
-```
-
-> **Note:** `git branch -D` is safe to ignore if the local branch does not
-> exist. `git fetch --prune` must always run to keep the local ref list clean.
-
-Explicitly close the GitHub PR object. Because this workflow squash-merges
-directly into the base branch (bypassing GitHub's native merge flow), GitHub
-**will not** auto-close the PR — it must be closed explicitly.
-
-Call `mcp__github__update_pull_request` with the repo's `owner` / `repo`,
-`pullNumber: [PR_NUMBER]`, and `state: "closed"`.
-
-> **Note:** This is a hard requirement — leaving the PR open after merging
-> pollutes the repository's open PR list and causes confusion for reviewers.
-
-Optionally, run the test suite one final time on the base branch to confirm no
-regressions were introduced by the merge:
-
-```powershell
-npm test
-```
-
----
-
-## Step 7 — Summary Report
-
-Post a structured summary comment to the PR (now closed) for traceability.
-Call `mcp__github__add_issue_comment` with the repo's `owner` / `repo`,
-`issue_number: [PR_NUMBER]` (PR comments use the issues comments endpoint),
-and `body` set to:
-
-```markdown
-✅ **Merged by agent** via `/git-merge-pr`
-
-- **Branch**: `[HEAD_BRANCH]` → `[BASE_BRANCH]`
-- **Conflicts resolved**: [YES/NO — list files if YES]
-- **Lint fixes applied**: [YES/NO]
-- **Test fixes applied**: [YES/NO]
-- **Merge strategy**: squash
-```
-
----
-
-## Constraint
-
-- **Never** merge a PR that has unresolved lint errors or failing tests. Running
-  a passing quality gate is mandatory before the merge commit.
-- **Never** silently drop code when resolving merge conflicts. When in doubt,
-  ask the operator.
-- **Never** bypass required GitHub branch protection checks (required reviewers,
-  required status checks). If these are blocking, surface them to the operator
-  rather than attempting to force-merge.
-- **Always** explicitly delete the remote head branch in Step 6 with
-  `git push origin --delete [HEAD_BRANCH]`. Do **not** rely solely on the
-  Step 5 merge call's `delete_branch` flag (whether passed via
-  `mcp__github__merge_pull_request` or `gh pr merge --delete-branch`) — that
-  flag is silently skipped when a PR auto-closes without a normal merge
-  commit (e.g., duplicate rebase scenarios).
-- **Always** treat a "remote ref not found" error from the delete command as a
-  non-fatal, idempotent success — the branch is already gone.
-- **Always** use `--force-with-lease` (never bare `--force`) when pushing
-  rebased branches to avoid overwriting concurrent pushes.
-- **Always** explicitly close the GitHub PR via
-  `mcp__github__update_pull_request` with `state: "closed"` in Step 6 after
-  branch cleanup. Because this workflow pushes directly to the base branch,
-  GitHub will **never** auto-close the PR — it must be closed manually
-  every time.
-- **Always** post a Step 7 summary comment for auditability, even if no fixes
-  were required.