mandrel 1.77.0 → 1.79.0

package/.agents/workflows/loops/nightly-audit.md

@@ -0,0 +1,71 @@
+---
+description: >-
+  Cron maintenance loop that runs a nightly audit sweep over the repository and
+  files actionable findings. Each run executes the audit workflows and routes
+  the results; the host (`/schedule` or a cron-driven `/loop`) owns the cadence.
+  verify is optional for a cron loop — the scheduler owns iteration, so this
+  unit ships the action and goal, not a terminating oracle.
+loop:
+  cadence: cron
+  goal: >-
+    Keep the repository's standing health surfaced by running the audit sweep on
+    a nightly schedule and turning each fresh finding into an actionable, deduped
+    record so regressions are caught within a day rather than at release time.
+  maxRounds: 30
+  onExhaust: report
+---
+
+# /loops:nightly-audit — scheduled maintenance audit sweep
+
+A **cron maintenance loop**. The host (`/schedule`, or a cron-driven `/loop`)
+owns the cadence and fires this unit once per scheduled window — typically
+overnight. Because the scheduler owns iteration, this unit carries **no
+`verify` oracle**: per the loop-unit schema, `verify` is required only for
+`self-paced` cadence and optional for `interval` / `cron`. Each run is a single
+sweep that observes, records, and yields until the next scheduled tick.
+
+## Action
+
+Each scheduled run:
+
+1. **Run the audit sweep.** Execute the relevant audit workflows for the repo
+   (`/audit-security`, `/audit-clean-code`, `/audit-dependencies`,
+   `/audit-quality`, and any others the project relies on). Each audit writes a
+   structured `temp/audits/audit-*-results.md` report — that is the canonical
+   artifact this loop consumes, not free-form prose.
+2. **Diff against the prior night.** Compare the fresh findings against the last
+   sweep's reports and against already-open Issues. A finding seen before is
+   not new signal; only genuinely fresh or regressed findings warrant a record.
+3. **Route fresh findings.** Hand the new findings to `/audit-to-stories`, which
+   deduplicates against existing Issues by fingerprint and either chains into
+   `/plan` or opens standalone Stories. Do not open raw duplicate Issues —
+   dedup is the loop's job, not the operator's.
+4. **Report and yield.** Emit a short digest (sweeps run, new findings, Issues
+   opened or updated) and return control to the scheduler, which sleeps until
+   the next cron window.
+
+## Goal & done-signal
+
+- **Goal:** the repository's health regressions are caught and turned into
+  actionable, deduplicated records within a day, without a human remembering to
+  run the audits by hand.
+- **Done-signal:** the nightly sweep completed and every fresh finding has been
+  routed to a record (or explicitly judged a non-finding). A cron loop has no
+  self-evaluated oracle — the scheduler owns whether the loop runs again; this
+  unit simply finishes the night's sweep and yields.
+- **Backstop:** `maxRounds: 30`. Roughly a month of nightly runs;
+  `onExhaust: report` emits a final digest and stops so a long-lived schedule
+  is renewed deliberately rather than running unbounded.
+
+## Stop & escalate
+
+- **An audit cannot run** (a required tool is missing, the audit harness errors,
+  the working tree is dirty in a way that invalidates the sweep). Report the
+  failure for that audit and continue with the others — do not abort the whole
+  night because one audit broke.
+- **A finding is high-severity and time-sensitive** (an exposed secret, a
+  critical CVE reachable in production). Surface it loudly in the digest rather
+  than letting it sit as one row among many — a nightly cadence is too slow for
+  an actively-exploitable finding.
+- **`maxRounds` is reached.** Emit a final digest (`onExhaust: report`) so the
+  operator can renew or retire the schedule deliberately.

package/.agents/workflows/loops/watch-ci.md

@@ -0,0 +1,68 @@
+---
+description: >-
+  Interval watch loop that polls a pull request's CI checks until they settle.
+  Each round runs `gh pr checks` and reports the delta; the host (`/loop 5m`)
+  owns the cadence and re-invokes the unit on its schedule. verify is optional
+  for an interval loop — the externally-scheduled host owns iteration, so this
+  unit ships the action and goal, not a terminating oracle.
+loop:
+  cadence: interval
+  goal: >-
+    Keep an eye on the current pull request's required CI checks each interval,
+    surfacing the first failed or stuck check the moment it appears so a human
+    can act before the checks finish.
+  maxRounds: 60
+  onExhaust: report
+---
+
+# /loops:watch-ci — poll a PR's checks until they settle
+
+An **interval watch loop**. The host (`/loop <interval> /loops:watch-ci`, e.g.
+`/loop 5m …`) owns the cadence and re-runs this unit on each tick. Because the
+host schedules iteration externally, this unit carries **no `verify` oracle** —
+per the loop-unit schema, `verify` is required only for `self-paced` cadence and
+optional for `interval` / `cron`. The unit's job each round is to observe and
+report, not to converge.
+
+## Action
+
+Each interval:
+
+1. **Read the current check state.** Run `gh pr checks` for the PR under watch
+   (the host supplies the PR number, or it is inferred from the current
+   branch's open PR). Capture the per-check status: pending, passed, or failed.
+2. **Compute the delta since last round.** Compare against the prior round's
+   snapshot. A check that flipped `pending → failed` is the headline; a check
+   that flipped `pending → passed` is progress.
+3. **Surface failures immediately.** On the first failed or cancelled required
+   check, report it — name the check, link the run, and quote the first error
+   line if cheaply available — so a human can act before the rest of the matrix
+   finishes. Do not wait for the whole suite to settle to raise a red check.
+4. **Report and yield.** Emit a one-line status summary
+   (`N passed, M pending, K failed`) and return control to the host, which
+   sleeps until the next interval.
+
+## Goal & done-signal
+
+- **Goal:** the operator learns about a CI failure on the watched PR as early as
+  the polling interval allows, and knows when all required checks have gone
+  green.
+- **Done-signal:** all required checks have a terminal status (every check
+  passed, or at least one has failed). An interval loop has no self-evaluated
+  oracle — the host stops the loop when the operator cancels it, when a failure
+  is surfaced and acted on, or when `maxRounds` is reached.
+- **Backstop:** `maxRounds: 60`. At a 5-minute interval that is ~5 hours of
+  watching; `onExhaust: report` emits a final status and stops rather than
+  polling forever on a wedged check.
+
+## Stop & escalate
+
+- **A required check failed.** Surface it and let the operator decide whether to
+  keep watching the remaining checks or stop. A failed required check is the
+  signal the watch existed to catch.
+- **The PR cannot be resolved** (no open PR for the branch, `gh` not
+  authenticated, the PR was merged or closed out from under the watch). Report
+  the condition and stop — there is nothing left to watch.
+- **`maxRounds` is reached with checks still pending.** Emit a final summary of
+  the stuck checks (`onExhaust: report`) so the operator can investigate the
+  wedged run.

package/docs/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.79.0](https://github.com/dsj1984/mandrel/compare/mandrel-v1.78.0...mandrel-v1.79.0) (2026-06-30)
+
+
+### Fixed
+
+* **decompose-author:** require namespaced [@epic](https://github.com/epic)-<id>-ac-N tag on wave-0 BDD scaffold scenarios (refs [#4301](https://github.com/dsj1984/mandrel/issues/4301)) ([#4304](https://github.com/dsj1984/mandrel/issues/4304)) ([c97d45e](https://github.com/dsj1984/mandrel/commit/c97d45e806a72a8511995d8f606b5be2ef486315))
+* **reconciler:** single-source the parent/Epic body trailer so force re-decompose retains Epic: #<id> (refs [#4300](https://github.com/dsj1984/mandrel/issues/4300)) ([#4303](https://github.com/dsj1984/mandrel/issues/4303)) ([a8e78a9](https://github.com/dsj1984/mandrel/commit/a8e78a9fd946e6f532a59df9cd37237e0d046b2d))
+
+## [1.78.0](https://github.com/dsj1984/mandrel/compare/mandrel-v1.77.0...mandrel-v1.78.0) (2026-06-24)
+
+
+### Added
+
+* Epic [#4284](https://github.com/dsj1984/mandrel/issues/4284) ([#4297](https://github.com/dsj1984/mandrel/issues/4297)) ([0f7c543](https://github.com/dsj1984/mandrel/commit/0f7c543e1ceb1c38ac425c388e338e3bfaaec49e))
+
+
+### Fixed
+
+* **baselines:** apply ignoreGlobs in the maintainability baseline CLI diff-scope branch (refs [#4293](https://github.com/dsj1984/mandrel/issues/4293)) ([#4294](https://github.com/dsj1984/mandrel/issues/4294)) ([c0c7dd5](https://github.com/dsj1984/mandrel/commit/c0c7dd5948314800e5a9d5808fb5eb0b01b09833))
+* **close-validation:** treat biome "No files were processed" as a clean format-gate skip (refs [#4292](https://github.com/dsj1984/mandrel/issues/4292)) ([#4295](https://github.com/dsj1984/mandrel/issues/4295)) ([bf6840d](https://github.com/dsj1984/mandrel/commit/bf6840dd69abbece4eb221797e6432519b6614a0))
+
+
+### Changed
+
+* **github-provider:** unify the two divergent withTransientRetry into one canonical primitive (refs [#4298](https://github.com/dsj1984/mandrel/issues/4298)) ([#4299](https://github.com/dsj1984/mandrel/issues/4299)) ([e5668dc](https://github.com/dsj1984/mandrel/commit/e5668dcca73b37c37d38e52e1eb8d2930a0e1790))
+
 ## [1.77.0](https://github.com/dsj1984/mandrel/compare/mandrel-v1.76.0...mandrel-v1.77.0) (2026-06-24)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mandrel",
-  "version": "1.77.0",
+  "version": "1.79.0",
   "description": "Claude Code-first opinionated workflow framework: instructions, personas, skills, and SDLC workflows that govern AI coding assistants.",
   "files": [
     ".agents/",

package/.agents/scripts/providers/github/transient-retry.js

@@ -1,62 +0,0 @@
-/**
- * transient-retry — shared retry-with-backoff for GitHub provider calls.
- *
- * Resilience for flaky connections (e.g. cell hotspots): retry ONLY on
- * connectivity blips, never on auth / scope / not-found / already-exists /
- * validation errors. Works for both surfaces the provider uses:
- *   - the gh CLI path — errors carry the Go HTTP error on `err.stderr`
- *     (e.g. `dial tcp ...: i/o timeout`); and
- *   - the direct `fetch` path — errors are a `TypeError: fetch failed` with
- *     the real reason on `err.cause` (e.g. `ETIMEDOUT`, `ENOTFOUND`).
- *
- * Retrying a non-idempotent create is acceptable for the dominant hotspot
- * failure (`dial tcp ... i/o timeout` means the connection never opened, so
- * the request never reached GitHub). Callers still gate retry per call so
- * the genuinely non-idempotent project-create can opt out.
- */
-
-const TRANSIENT_RE =
-  /i\/o timeout|dial tcp|TLS handshake timeout|connection reset|connection refused|temporary failure|could not resolve host|no such host|network is unreachable|socket hang up|fetch failed|ConnectTimeoutError|UND_ERR_CONNECT_TIMEOUT|ETIMEDOUT|ECONNRESET|ECONNREFUSED|ENOTFOUND|EAI_AGAIN|\b50[234]\b/i;
-
-/** True when an error looks like a retryable network/connectivity blip. */
-export function isTransientNetworkError(err) {
-  const hay = [
-    err?.stderr,
-    err?.message,
-    err?.code,
-    err?.cause?.message,
-    err?.cause?.code,
-  ]
-    .filter(Boolean)
-    .join(' ');
-  return TRANSIENT_RE.test(hay);
-}
-
-/**
- * Run `fn`, retrying with exponential backoff ONLY on transient network
- * errors (1s, 2s, 4s by default). Non-transient errors throw immediately so
- * real failures stay loud. `sleep` is injectable for tests.
- *
- * @template T
- * @param {() => Promise<T>} fn
- * @param {{ retries?: number, baseDelayMs?: number,
- *   sleep?: (ms: number) => Promise<void> }} [opts]
- * @returns {Promise<T>}
- */
-export async function withTransientRetry(
-  fn,
-  {
-    retries = 3,
-    baseDelayMs = 1000,
-    sleep = (ms) => new Promise((r) => setTimeout(r, ms)),
-  } = {},
-) {
-  for (let attempt = 0; ; attempt++) {
-    try {
-      return await fn();
-    } catch (err) {
-      if (attempt >= retries || !isTransientNetworkError(err)) throw err;
-      await sleep(baseDelayMs * 2 ** attempt);
-    }
-  }
-}