Principles in Action

Guiding Principles states the commitments without tying them to a domain. This page shows what those commitments make two Foundries do: which rules they enforce, which artifacts they keep, and which machinery they have deliberately not built.

The comparison is intentionally uneven. Both the galaxy-workflow-foundry and statistical-genomics-foundry now have working cast layers; Galaxy has the broader runtime validation path, while Statistical Genomics’ current referee skills emphasize critique and are still working toward empirical calibration. Implemented means the behavior is observable in the repository today; partial means a real mechanism exists but a stronger layer is deferred. This page keeps the Galaxy/Statistical Genomics comparison rather than adding a TDA column. The TDA Bioinformatics Foundry is the active rigorous reference build; use its profile and the generated kind-catalog and tag-catalog for the current three-Foundry picture.

Principle	Galaxy Workflow Foundry	Statistical Genomics Foundry
Upstream authority	ImplementedCitations, derivatives, snapshots, and caches have distinct roles.	ImplementedSource notes declare identity, license, attribution, and transformation posture.
Licensing	ImplementedShared policy drives source validation, casting, and provenance.	ImplementedShared policy participates in source validation, casting, and provenance.
Corpus first	ImplementedIWC exemplars ground patterns, Molds, and verification work.	ImplementedGood methods and cautionary counterexamples ground referee Molds.
Reproducibility	ImplementedCast provenance and drift checks expose every packaged dependency.	ImplementedCast provenance and byte-drift checks expose generated dependencies.
Deterministic tools	ImplementedBuild, cast, and workflow checks fail mechanically.	PartialCorpus and cast checks run; critique ships, while empirical calibration is still maturing.
Actionable knowledge	ImplementedMolds compile into skills with explicit artifact contracts.	ImplementedReferee Molds compile into committed runtime skills.
Self-documentation	ImplementedGlossary, design records, kind docs, and catalogs map the system.	ImplementedThe same map records both working and deferred machinery.
Progressive disclosure	ImplementedReference load policy survives into generated skills.	ImplementedTyped load policy survives into generated skills.
Portability	ImplementedOne portable skill tree is exposed through thin runtime manifests.	ImplementedRuntime-neutral Molds compile into committed portable skills.

The shared commitment is the principle. Its implementation point—and an honest deferred boundary—belongs to the instance.

Keep knowledge grounded

Upstream Authority, Local Synthesis

Galaxy — implemented. The repository distinguishes four source relationships. Citations point to IWC workflows without mirroring them. Authored CLI pages retain their upstream URL while adding local operational guidance. Vendored schemas and specifications are pinned in vendored_upstreams.yml. Survey corpora live in gitignored working caches, outside the knowledge base and its casts.

Statistical genomics — implemented. Paper, tutorial, and book notes are substantial local syntheses, but their metadata records the source, access, license, attribution, and whether the note paraphrases or quotes. Multi-chapter books add manifests and checksums; raw source material remains staging input rather than committed knowledge.

What the contrast shows. Local bytes are not the failure. Ambiguous authority is. Each artifact needs an explicit relationship to its source and a lifecycle that matches that relationship.

Redistributed Content Carries Its License

Galaxy — implemented. The repository installs the shared @galaxy-foundry/license-policy decision table instead of maintaining a local mirror. Its own schema checks local license coherence; casting then rejects disallowed placement modes and records the license lineage of redistributed references in provenance.

Statistical genomics — implemented. It installs the same policy and applies it during source authoring, validation, and casting. License identifiers are typed, required notices and license texts accompany reusable quotations, and generated artifacts carry provenance rather than bypassing the policy boundary.

What the contrast shows. A shared package answers what a license permits. Each instance still owns the rules that connect that policy to its content and to every output layer it actually implements.

Corpus-First, Not Invention-First

Galaxy — implemented. IWC workflows ground conversion patterns and Molds. References carry an evidence posture; hypotheses require a verification plan, and schemas are expected to reach cast-validated status. Generated workflow skeletons make broad inspection cheap before maintainers read selected exemplars deeply.

Statistical genomics — implemented. Its corpus is deliberately bipolar: established methods supply positive evidence, while invalidity patterns such as double-dipping and confounding supply counterexamples a referee must recognize. Molds now draw on that corpus; the taxonomy grows from the work rather than preceding it.

What the contrast shows. Corpus-first does not prescribe one corpus shape. It requires abstractions and checks to be earned from the evidence the domain needs—including negative evidence when recognizing failure is part of the job.

Make knowledge trustworthy and actionable

Reproducibility At Every Layer

Galaxy — implemented. Every cast carries _provenance.json: Mold identity, commit and content hash, target, resolved references, hashes, licenses, and artifact contracts. Its casting record defines stable ordering and deterministic regeneration so CI can report drift instead of asking a reviewer to infer it from generated text.

Statistical genomics — implemented. Source identities, access records, book manifests and checksums, generated frontmatter, and typed validation are inspectable. Its casting record now describes the CLI that produces committed skills and the sweep that detects byte drift.

What the contrast shows. Reproducibility is not a single file format. It is the ability to recover how each existing derivative was produced without claiming lineage for a derivative that does not yet exist.

Deterministic Tools Do Deterministic Work

Galaxy — implemented. Typed schemas, cross-file resolution, hashing, copying, cast rendering, and drift detection are mechanical. At runtime, gxwf parses and validates workflow structure inside the author–validate–fix loop; the Foundry does not replace those checks with a prose catalog of possible mistakes.

Statistical genomics — partial. Deterministic tests validate the corpus, kinds, references, licenses, generated book metadata, reading site, and cast tree. The current referee skills primarily critique; permutation, simulation, calibration, or negative-control evidence remains the stronger runtime target.

What the contrast shows. “Deterministic” describes the instrument, not every question a Foundry asks. Mechanical questions get pass/fail tools; judgment-heavy questions must still end in evidence outside the reasoning that produced the answer.

Actionable Knowledge, Not Passive Notes

Galaxy — implemented. A Mold declares one action, its references, and the artifacts it consumes and produces. Validation checks that artifact producers and schemas agree. Deterministic casting packages that dependency surface into an executable skill while keeping evals and maintainer notes out of the runtime bundle.

Statistical genomics — implemented. Its Molds turn corpus knowledge into procedures for doing analyses and auditing validity. audit-method-validity and the domain-specific referee Molds carry scenarios and evals and now compile into committed runtime skills.

What the contrast shows. The same typed-source boundary can produce runtime skills for very different actions without making either domain’s procedure part of the shared substrate.

Make knowledge legible and durable

The Knowledge Base Documents Itself

Both — implemented. Each repository keeps an authoritative glossary under content/meta/, typed design records with explicit ownership boundaries, documentation and examples beside its knowledge kinds, and generated catalogs for inventories. These records pass through the same validation and reading machinery as domain content. design-records describes the shared directory contract and expected records.

The Statistical Genomics Foundry makes the benefit especially visible: its casting record names the producer, committed outputs, and drift check. Self-documentation is not self-promotion; it gives a maintainer enough of a map to tell architecture from aspiration.

Progressive Disclosure Over Context Flooding

Galaxy — implemented. References declare when they are used, whether they load up front or on demand, and the trigger for deferred loading. Casting preserves those decisions in the generated skill, separating essential instructions from supporting schemas, manuals, patterns, and research.

Statistical genomics — implemented. The source contract narrows and validates the same load vocabulary, with research notes carrying most of the depth behind on-demand triggers. Casting now carries that policy into runtime skills.

What the contrast shows. Progressive disclosure begins as a property of source references, but it becomes real only when a reader or runtime can follow that policy.

Portable Artifacts Over Platform Fashion

Galaxy — implemented. Molds and references remain runtime-neutral. A deterministic target adapter produces one portable Agent Skills tree; thin Claude and Codex plugin manifests expose that same tree without duplicating the skills. Adding another artifact shape would require a target adapter, not a rewrite of the knowledge base.

Statistical genomics — implemented. Its Molds and references avoid runtime-specific vocabulary, and the shared caster produces a committed portable skill tree. Portability is now a generated output property rather than only a source constraint.

What the contrast shows. Portability does not require many targets. It requires a clean boundary: target language enters during deterministic casting, and until that boundary runs, portability remains a testable promise rather than a shipped feature.

What the Comparison Establishes

The instances do not need identical machinery to share the pattern. They need the same accountability: grounded sources, explicit transformation, enforceable contracts, honest status, and evidence outside self-certification. Galaxy demonstrates the broad workflow-construction path. Statistical Genomics demonstrates that the same substrate can organize and cast a different corpus around a different kind of external check.

That difference is evidence, not an embarrassment. The pattern is strongest where it lets a reader distinguish what was inherited, what the domain changed, what is working, and what is still only designed.