# The root

- The root holds only these entries: `app.jadpo`, `config.jadpo`,
  `authentication.jadpo`, `policy.jadpo`, `flags.jadpo`, `jadpo.lock`,
  `ignored_suggestions.jadpo_record`, `taught_suggestions.jadpo_record`,
  `domains/`, `shared/`, `packages/`, `database/`, `api/`,
  `acceptances/`, `translations/`, `tests/` and `build/`.
- `jadpo suggest ignore` writes the suggestions a team ignores, and
  `jadpo suggest found` the patterns it taught
  ([Suggestions](suggestions.md)).
- The hidden `.jadpo/` folder holds local, untracked state and is never
  read as source.
- `packages/` holds only installed packages, each in
  `packages/<name>/<version>/`. They are committed, read-only, and checked
  against their digest in `jadpo.lock`. Everything the app's authors wrote
  lives in `domains/` and `shared/`, whatever kind it is, so the app's own
  integrations are in `shared/providers/`
  ([Where packages live](where-packages-live.md)). A package
  is laid out as `shared/` is, under the same rules.
- `app.jadpo` names the Jadpo release line the project is written for, as
  `jadpo: "0.1"` in `application { }`. It is the major and minor numbers as
  text, the same form a package's index uses for its own
  ([The package format](the-package-format.md)). It is a
  line, not a minimum: while Jadpo is at 0.x, a minor release may break
  apps, so the line is what must match, and a release that only fixes
  something stays on its line. The installed `jadpo` runs the newest
  release of that line it keeps or can fetch, and `jadpo.lock` may pin the
  exact release for reproducible builds
  ([Which jadpo runs](which-jadpo-runs.md)). A `jadpo` that
  can't hand the project to that release refuses it with an error alone,
  naming the release to install: `toolchain.version_newer` when it is on
  an earlier line, rather than misread what a later version added, and
  `toolchain.version_older` when it is on a later line, rather than compile
  the project silently. Anything but a major and minor number is
  `toolchain.version_invalid`. If the line is left out, nothing is checked.
  `jadpo new` writes the line of the `jadpo` that ran it
  ([The `jadpo` command](the-jadpo-command.md)).
- The root `translations/` holds only the app's wording for text it didn't
  write, one `<locale>.jadpo` file each, grouped by owner: `jadpo: { }` for
  Jadpo's own text, a library package's name for its text. An
  application's own messages live in the domain that uses them, or in
  `shared/translations/`
  ([Translations as messages](translations-as-messages.md)).
- A `.jadpo` file anywhere else is an error. Folders with no `.jadpo` files
  (`docs/`, `.github/`) are ignored.
- There is no `env.jadpo`. `config.jadpo` declares every setting. Values
  come from the platform's environment in production and from one
  git-ignored `.env.local` file locally, with secrets entered through
  `jadpo config set`.
- A single file handed to the compiler on its own, such as a test case or
  a snippet in these docs, is checked as one implicit domain with the
  layout rules off.