Harmonize

The law this skill runs on: a standard that is set but not propagated is dead capital. /frontier looks OUTWARD — "is our standard still current vs the 2026 world?" — and updates the bar on one surface. But knowing the bar is not clearing it everywhere: parts drift as parallel agents edit them, and one module re-inlines json.loads where the shared util is mandated, one component falls off DESIGN_SYSTEM.md, one skill auto-writes where the family says propose-on-approval, one output path emits markdown where _clean_reply's contract says plain text. harmonize is the propagation: it takes a NAMED internal standard and sweeps inward for every part that diverged from it, then converges them. frontier sets the reference; harmonize makes everything obey it. The named-standard anchor is load-bearing — strip it and this is just /simplify; with it, harmonize is the only thing that makes a frontier upgrade reach past the surface it audited.

Three hard invariants:

• Every sweep is anchored to a NAMED standard. harmonize never improves code on its own merits — that is /simplify's lane (local quality, no external reference). harmonize converges parts onto an explicitly named reference (a DESIGN_SYSTEM rule, a CLAUDE.md mandate, the house skill template, an API/output contract) and CITES it on every proposed edit. No named standard → not a harmonize job; redirect to /simplify.
• Declared beats inferred; an inferred standard is approved before use. Prefer a written standard. Only when none is declared, infer the dominant/majority pattern — and then SURFACE the inferred standard for approval BEFORE converging anything. Never converge toward a silently-assumed reference: popular is not correct, and flattening everything to the majority can entrench a wrong pattern.
• An unexplained outlier is WATCHED, not converged. A divergence whose reason is not visible may be a deliberate exception, not drift. Run /moonwalk on it first — a KNOWN-LIVE or UNKNOWN fence verdict means KEEP, not flatten. (Chesterton's fence, shared with raze/moonwalk: do not converge away a part whose purpose you cannot trace.)

/harmonize <standard|surface> (default — sweep + propose)

Run as ordered evidence passes; fan the reads to scout subagents so only the divergence map returns to main context, never the raw file dumps. Writes nothing.

1. Name the standard + pin the scope. Identify the reference being enforced — an explicit doc (DESIGN_SYSTEM.md, a CLAUDE.md mandate, the house skill template, an output contract like _clean_reply) or, if none is declared, the dominant pattern inferred from the majority of parts. If inferred, STATE it explicitly and get approval before proceeding (invariant 2). Pin the set of parts to sweep (which files / modules / components / skills).
2. Sweep for divergence. Scan every in-scope part for where it disagrees with the named standard. Each divergence: the part · the rule it breaks · the exact gap (the re-inlined primitive, the off-system component, the missing house invariant, the contract violation).
3. Triage each divergence — CONVERGE / WATCH / EXCEPT.
   • CONVERGE: genuine drift, the standard clearly applies → propose the surgical convergence edit.
   • WATCH: the divergence may be a deliberate exception whose reason is not visible → do NOT converge; run /moonwalk to recover whether it is intentional (KNOWN-LIVE / UNKNOWN ⇒ keep).
   • EXCEPT: a confirmed legitimate exception → leave it, and record the carve-out in the standard so the next sweep does not re-flag it.
4. Propose the convergence set. For each CONVERGE: the diff · the standard citation · the blast radius (is it tested?). Gate on the four-part promotion gate — Reusable · Non-trivial · Specific · Verified against the named standard (not against taste). Reject the rest with reasons.
5. Report + route. Emit proposed convergences (each with its standard cited), the WATCH list (pending /moonwalk), the confirmed EXCEPTs, and the lane handoffs (touched code → /simplify to polish + /code-review for the new edges; a now-redundant divergent variant → /raze). Honest-empty: if nothing diverges, the system is already harmonized to that standard — say so and write nothing.

/harmonize audit

Read-only. Run steps 1–3, then STOP: the divergence map (CONVERGE candidates / WATCH / EXCEPT) against the named standard, with each gap and its citation. Propose and write nothing. The "where has the system drifted from its own standard" preview — mirrors /raze audit and /hone audit. Use it to see whether a frontier upgrade actually propagated, or only reached the surface it audited.

/harmonize apply

Execute ONLY pre-approved convergences from a prior sweep. One convergence = one commit; run the target's pinned check (tests / build / the app per /run) with real output BEFORE the next. A red check halts immediately, reverts that single convergence, and reports — never proceeds through a broken state. Record each landed convergence + the standard it enforced to ~/.claude/harmonize/convergences.md so the realized real-drift-vs-false-flag rate can be graded later (closes the loop the way /raze and /hone do).

Rules

• Anchored to a named standard, always: every convergence cites the explicit reference it enforces. harmonize improves nothing on its own merits — no named standard means it is not a harmonize job (→ /simplify). This anchor is the whole reason the skill exists distinct from /simplify; never relax it.
• Declared beats inferred; inferred is approved first: infer the majority pattern only when no standard is written, and surface it for approval before converging — never converge toward a silently-assumed reference.
• Unexplained outlier ⇒ WATCH, not converge: a divergence whose reason cannot be traced gets a /moonwalk fence verdict first; a deliberate exception is kept, not flattened (Chesterton's fence).
• Propose-on-approval, surgical, reversible: default writes nothing; convergences land one-per-commit in apply, individually approved (no bulk "yes to all"), tests green between each, branch-only and git-reversible.
• Lane discipline: /frontier sets the standard (outward); harmonize propagates it (inward); /simplify polishes the touched code on its own merits; /code-review checks the new edges; /raze deletes a now-redundant variant; /hone fixes skills that failed GRADES (harmonize fixes parts that diverged from a STANDARD, even un-graded ones). Hand off, never duplicate. A project fact → /burn rent; a preference → /taste; do not write CLAUDE.md or TASTE.md here.
• Essentialness metric (honesty hook): log to ~/.claude/harmonize/convergences.md; the grade is real-drift-converged ÷ divergences-flagged. Mostly false-flags = the standard is too loose (tighten it) or the parts are legitimately diverse (harmonize should not run there). It earns its keep when frontier→harmonize means a standard reaches every corner, not just the surface frontier audited.
• Shared-tree safety: explicit git add <path>, never -A; no history rewrite on a shared branch; an adversarial /code-review must try to refute each convergence before any PR.

Pipeline placement: /frontier (set/update the standard from the outside world) → harmonize (propagate it to every part) → /simplify + /code-review (polish + correctness on what moved) → /raze (cut the redundant variants the convergence exposed). harmonize is the propagation stage; without it a frontier upgrade reaches only the surface it touched. Scope guard: harmonize enforces consistency to a declared reference — it does not invent the standard (that is frontier's or a human's call) and does not optimize for its own sake (that is /simplify). Keeping it to propagation is what keeps it sharp.