# Universalist

> Use when current work must decide or reconsider an owned code boundary: introducing, removing, migrating, bypassing, or materially changing its semantic owner, admitted domain, representation, composition, compatibility, effects, failure semantics, or proof; or when repeated implementations distribute one law across owners. Skip routine implementation, validation, review closure, rebasing, Ship, and Land against an accepted architecture unless new evidence fires an invalidator. In Actuating, nominate only when architecture reconsideration is live. Explicit invocation always runs. Team mode requires explicit request.

- Skill: `tkersey/universalist` (Agent Skill, multi-file: 163 files)
- Install (CLI): `npx skillmds@latest add tkersey/universalist`
- Raw SKILL.md: https://api.skillmd.com/api/skills/tkersey/universalist/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: tkersey (https://skillmd.com/u/tkersey)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/tkersey/universalist

---


# Universalist

Universalist recognizes **latent law-bearing structure** and nominates the
smallest context-relative, correct-by-construction boundary justified by current
repository evidence.

Category theory is a hidden recognizer and optimizer. It must change what the
architecture owns, permits, excludes, composes, observes, preserves, identifies,
generates, interprets, proves, or refuses to invent. Otherwise it is explanatory
metadata.

Default discipline:

```text
one live semantic decision
one owned boundary
one current context
one primary architectural axis
one typed hole with its interacting law family
one ordinary candidate first
one smallest effective artifact
one governing law family and one discriminator
```

Activation is semantic-pressure-triggered. Disclosure and escalation are
proportional.

## Boundary-decision trigger (`UNI-BOUNDARY`)

Explicit `$universalist` invocation always activates this skill.

For implicit invocation, activate only when current repository evidence
establishes at least one of these conditions:

- current work must choose, introduce, remove, migrate, bypass, or materially
  change boundary ownership, authority, admitted behavior, representation,
  composition, compatibility, information retention, effects, failure
  semantics, or proof;
- repeated implementations distribute one invariant, composition law,
  interpreter, observation vocabulary, transition rule, or compatibility rule
  across owners;
- at least two materially different boundary candidates remain live;
- new evidence fires an invalidator of a prior boundary disposition;
- Actuating has reopened architecture and requests a bounded nomination.

Repeated obligations are boundary evidence even when the missing owner has not
yet been named. Syntactic duplication, a shared noun, or a category-shaped name
alone is insufficient.

Do not activate merely because work crosses, preserves, validates, publishes,
merges, or mechanically transports an already accepted boundary. Skip routine
implementation, tests, formatting, documentation correction, review
bookkeeping, mechanical rebasing, `$ship`, `$land`, and isolated owner-local
repair under an unchanged architecture unless that work exposes new semantic
boundary evidence.

A rebase conflict activates only when it reveals incompatible semantic owners,
representations, laws, or migrations. Ship or Land work that exposes such
pressure returns it to Actuating for architecture reconsideration instead of
running a duplicate publication- or landing-local Universalist pass.

When the same owner, axis, law, falsifier, route, obligations, and invalidators
remain current, reuse the existing disposition silently. Re-enter through
`UNI-RECLASSIFY` only after material new evidence. Nonactivation has no route,
record, or receipt; silence is the correct representation.

Team/subagent mode remains explicit-request only.

## Common path

The common path must complete without loading any deeper reference. Inside
Actuating, use the composition handoff below instead of also emitting the
standalone disposition template; the same applicable obligations remain.

1. Attribute the trigger evidence. If no implicit trigger condition is
   evidenced, stop without a disposition.
2. Inspect the incumbent seam: owner, admitted inputs, construction paths,
   operations, sanctioned observations, effects, resources, compatibility,
   bypasses, and failure behavior.
3. State the incoming incumbent or ordinary repository-native candidate first:
   record, tagged union, checked constructor, adapter, explicit parameter,
   state machine, operation IR, handler, labelled graph, query, bounded loop,
   canonical merge, or one typed compatibility witness.
   Before treating it as dispositive, ask: **what representation or composition
   would make the required behavior structural rather than a repeated obligation?**
   Ordinary-first is a comparison baseline, not a ceiling on reasoning. Consider
   at most one grounded law-derived challenger, including on a first-use boundary
   with no duplication. Do not invent a challenger when current evidence already
   decides the question. Derive an artifact, lawful transformation, or reusable
   proof; it may still be an ordinary constructor or loop. Preserve required-valid
   behavior as well as excluding invalid behavior. Keep necessary state, effect,
   resource, and observation interactions in the same argument. Reuse any equivalent
   challenger supplied by the receiving workflow; no second pass or packet.
   For a representation alternative, choose by required elimination: does the next
   boundary need inspectable data, or only its fold? Consider removing intermediate
   materialization only when its inspection, sharing, persistence, authorization,
   and rewriting roles are absent or preserved elsewhere. A native datatype plus
   fold or loop remains the baseline. Church-style callbacks alone establish
   neither parametricity, initiality, confidentiality, nor a performance gain;
   apply the existing observation, effect, resource, and claim-strength obligations.
4. Record the compact disposition:

```text
Trigger evidence:
Boundary:
Disposition: preserve / ordinary / escalate
Incoming incumbent or ordinary candidate:
Owner:
Required observations:
Law:
Falsifier:
Material decision delta: preservation / owner / admitted-domain / representation / composition / compatibility / migration / effects / failure-semantics / proof / obstruction
Mechanic: ordinary / card:<id>
Invalidates when:
```

5. **preserve** only when live change pressure exists and the incumbent already
   owns the law exactly. Continue the receiving workflow without adding an
   abstraction. Boundary presence without live pressure is nonactivation, not
   preservation.
6. **ordinary** when one uncontested repository-native artifact closes the seam.
   Name its owner, observation-preserving transition, every residual runtime
   check owner, and the first falsifying test or counterexample.
7. **escalate** only when one of the evidence gates below fires.
8. Stop after the first verified seam unless the user explicitly widens scope.

A more abstract candidate does not dominate because it is more general.
“Smallest” is relative to required observations, compatibility, effects,
resources, host capabilities, and migration cost—not source length or
categorical sophistication.

## Evidence-indexed disclosure

Load only the next module justified by evidence already established. Do not read
the whole reference corpus to search for a reason to escalate.

| Evidence established | Load exactly | Required return |
|---|---|---|
| Live change pressure exists and the incumbent is exact | nothing | compact `preserve` disposition with a preservation delta |
| One ordinary artifact clearly closes the seam | nothing | compact `ordinary` nomination and transition |
| Repeated obligations, an imminent constrained variant, or a grounded law-derived challenger needs discrimination | `references/latent-structure-recognition.md` | encoding relation, false friend, discriminator, dividend, transition need |
| At least two plausible routes materially differ | `references/consequential-boundary.md` | context-relative comparison and Boundary Artifact Contract candidate |
| A specific typed hole survives ordinary comparison | `references/artifact-selection-by-unknown-location.md`, then the matching registry card fragment only | evidence-bound card disposition |
| One advanced card remains live | only that card's `theory_refs` | effective repository-native lowering and proof profile |
| A consequential decision must remain independently durable outside Actuating | `references/durable-decision.md` | one Ledger-addressed plan and, after standalone adjudication, one root receipt |
| User explicitly requests Universalist subagents/team mode | `references/workflow/team-routing.md`, `references/workflow/subagent-packet-contract.md`, and `references/workflow/subagent-orchestration.md` | bounded read-only packets and one root synthesis |
| Evidence is unknown or candidates remain incomparable | nothing automatically | evidence debt or underdetermination |

### Latent-structure gate (`UNI-RECOGNIZE`)

Read `references/latent-structure-recognition.md` only when repository evidence
contains a repeated semantic obligation, a distributed owner, repeated
interpreter/composition/transition structure, or an imminent variant already
constrained by the same law, or the common path has already derived a concrete
alternative whose governing law needs discrimination. That alternative may arise
at a first-use boundary; it does not require a second implementation. This changes
recognition after activation, not the boundary-decision trigger.

Syntactic duplication, shared vocabulary, or a category-shaped name is
insufficient. Recognition must identify a nearest false friend and one
executable law or counterexample that distinguishes it. A recognized pattern
survives only when it removes or centralizes a material obligation, enables a
lawful transformation, or strengthens a reusable proof with an object-level delta.

### Consequential-decision gate (`UNI-CONSEQUENTIAL`)

A route is consequential only when at least two plausible candidates materially
differ in persistent behavior, owner or authority, admitted domain,
representation, compatibility, migration, enforcement, information retention,
legal composition, effects, resources, invalidation, or proof obligations.

When that condition holds, read `references/consequential-boundary.md` before
the next affected mutation. Otherwise remain on the common path.

Strong escalation evidence includes repeated falsification of the same route
family, a boundary that keeps accumulating predicates or bypasses, invalid
states that remain representable and are only rejected downstream, one owner
absorbing unrelated law families, duplicated projections, a missing
protocol/state-machine artifact, or proof obligations exposing an implicit
algebra.

Do not escalate merely because a local helper is possible, domain rules remain
unstable, the stronger model cannot be tested, required compatibility forbids
the transition, or the abstraction's onboarding and resource cost dominates
its reduction in semantic risk.

Diff size, retry count, elapsed time, vocabulary, and theoretical
interest do not establish consequentiality.

### Advanced-mechanics gate

Advanced mechanics are selected by a concrete typed hole, not by browsing for
an attractive theorem.

After the ordinary candidate and consequential comparison:

1. read `references/artifact-selection-by-unknown-location.md`;
2. consult `references/universal-construction-registry.yaml`;
3. inspect at most three nearby cards, including the ordinary alternative;
4. classify each relevant card as `selected`, `rejected`, `contradicted`, or
   `unresolved`;
5. read only the selected or still-material card's exact `theory_refs`;
6. lower any retained card into one repository-native boundary artifact.

Match proof to the actual claim: a lawful structure needs its laws and
interpretation, not an invented universal property. Mediation and uniqueness
apply only to a named universal construction with specified competitors and maps.
Opacity, one public interpreter, and passing examples alone establish neither.
A bounded approximation states its domain, losses, and evidence limits. A route
name never upgrades claim strength.

Signals, registry order, `diagnostic_order`, evidence count, and theorem
sophistication never prove prerequisites or select a route. Ordinary dominance
is a successful advanced-mechanics rejection, not a failed analysis.

### Durability gate (`UNI-DURABLE`)

Do not load Ledger plan mechanics merely because a boundary decision is
consequential.

Read `references/durable-decision.md` only when the decision must remain
independently addressable outside the active Actuating run across sessions,
actors, migration, or supersession. Actuating's ephemeral Architecture Working
Set is never a durability carrier.

Never load the durability module in Actuating composition.

## Route discipline

Assign routes only after lowering:

- `UNI-PRESERVE` — preserve an already exact boundary against live change
  pressure.
- `UNI-ORDINARY` — nominate the smallest ordinary repository-native artifact.
- `UNI-CANONICAL` — nominate an advanced construction only when it materially
  strengthens the ordinary candidate and has a complete claim-appropriate
  effective witness; this route name does not itself assert universality.
- `UNI-OBSTRUCT` — stop only when no honest representable or effective artifact
  remains, or an explicitly primitive bypass is contained.

Do not add a `UNI-SKIP` route. No live semantic decision means Universalist did
not activate.

If several candidates are incomparable minima, the result is
**underdetermined**. Do not manufacture a winner.

The machine-readable authority for trigger, route, and clause identifiers is
`references/decision-contract.json`. This file supplies their operational
semantics. Change semantic policy, the contract, and the durable plan template
together.

## Actuating composition

Inside `$actuating`, Universalist is a nominator only. Actuating owns the
invocation point and calls Universalist only after architecture reconsideration
is live. Do not run a duplicate root or worker pass merely because Actuating
will cross a boundary while realizing an already selected architecture.

Return `candidate`, `preserve-incumbent`, `unresolved`, or `obstructed` with the smallest
code-bound argument that changes Actuating's decision: trigger evidence, owner
and operation, required law/observations, discriminator, and material migration,
residual, or invalidation consequences. For counterexample-driven work, identify
the enabling freedom removed or lawfully controlled. Reuse supplied facts and proof references. No fixed field projection
or second Working Set report is required.

Return `unresolved` when evidence is missing or adequate candidates remain
incomparable; name that reason and the smallest available discriminator. This
is a supporting result, not a new route or mode. Do not convert uncertainty into
`obstructed`, preserve an unjustified incumbent, or invent a winner. Actuating
owns any authorized experiment outside an open review epoch and blocks only the
affected decision. Obstruction still requires the evidence specified below.

An ordinary nomination can be direct: derive the receipt subject from the
execution-owned evidence instead of accepting both independently; retire the
unchecked constructor, migrate callers, and identify the mismatch witness and
required-valid counterpart. This nominates work; it is not proof of a successor.
Admission, preservation under permitted operations, and sanctioned-path coverage
remain distinct obligations. Adequate native evidence may discharge them without
a duplicate topology account. When route or migration coverage needs explicit
accounting, return the relevant source-derived topology obligations to Actuating.

A candidate may improve the causal explanation. Return the material delta and
its discriminator for Actuating's existing selection decision; do not silently
redefine the family or require a separate co-refinement pass. The family is not
just its observed examples, and a local correction may still be the adequate
construction.

When a candidate changes the comparison domain, quotients distinctions, or
conservatively approximates behavior, justify total interpretation over that
domain, reflection of every concrete violation, exclusion of invalid behavior,
and preservation of required valid behaviors and observations at an explicit
evidence strength. Do not underapproximate danger or erase required distinctions.
Report any optional safe behavior excluded by a conservative approximation;
diagnostic exactness is separate from safety. Do not invent these transformations
or their reporting fields for a candidate that does not use them.

Keep primary enforcement distinct from derived trust-boundary, compatibility,
observability, and compensating guards. Do not nominate a construction as adequate
while a sanctioned escape or permitted transition still admits its claimed family.

Universalist never selects or reopens Actuating's target, adjudicates its causal
alternatives, grants mutation or closure, allocates a plan/root receipt, or persists
an Actuating architecture artifact. Actuating alone adjudicates the nomination
and any interpretation delta in its active Working Set. Git and actual proof own
the realized result. Standalone selection remains subject to its applicable
consequential and durability contracts.

## Execution-time reclassification (`UNI-RECLASSIFY`)

Treat every compact disposition, nomination, or durable decision as a proof
lease over current evidence.

Reclassify before the next affected mutation only when new evidence may
materially change the owner, requirements, observations, compatibility,
effects, resources, axis, typed hole, law, falsifier, enforcement, residuals,
route, or seam decomposition. Routine refinement under the same owner, axis,
law, falsifier, route, obligations, and invalidators reuses the current proof
lease silently.

Record:

```text
Prior disposition or decision:
New evidence:
Material semantic delta:
Outcome: retain / split / escalate / obstruct
Invalidated artifacts: receipt / plan / proof lease / none
Successor packets: owner + axis + seam / none
```

- **retain** — the same owner, axis, law, falsifier, route, and obligations hold;
- **split** — independently governed owners or axes appeared;
- **escalate** — the route materially changed; repeat consequential analysis;
- **obstruct** — no honest current route is representable or authorized.

Before Actuating selects a target architecture, revise the nomination in
place. After implementation begins, return material evidence to Actuating;
Universalist must not reopen the target directly. Never overwrite an existing
root receipt.

## Evidence and obstruction

Keep distinct:

```text
evidenced true
evidenced absent
unknown / not inspected
underdetermined
witnessed obstruction
```

Unknown evidence is epistemic debt, not nonexistence. A real obstruction
requires attributed counterevidence, a reproducible counterexample, stability
under the declared comparison maps, an effectivity account, a falsifier, a
reopening condition, and resolution of every active constructive alternative.

Return evidence debt rather than loading more doctrine automatically. Return
obstruction rather than inventing evidence, authority, policy,
representability, effect laws, host capability, resource feasibility, or
coherence.

## Output contract

Use repository and domain language by default:

```text
These repeated tenant checks are one distributed agreement rule.
Introduce one owner-controlled compatibility object.
Translate one existing caller through its checked constructor.
Preserve both sanctioned projections.
Retire unchecked pair construction after the witness seam verifies.
```

Add category names, encoding relations, mediators, canonicality claims, and
expert proof detail only when the user requests expert explanation or the
selected mechanic requires them.

Do not emit routine no-op ceremony. Report the trigger evidence, boundary
decision, and material architecture delta that matter to the receiving
workflow.

