simt-dev 0.2.0 → 0.2.2

package/docs/decisions/ADR-072-the-budget-is-a-declaration-beside-the-gates.md

@@ -0,0 +1,104 @@
+# ADR-072 — The budget is a declaration beside the gates, not a number inside the projection
+
+Status: **accepted** · 2026-10-14 · filed as S38
+**Affects:** `src/projection/manifest.mjs`, `src/measure/context.mjs`,
+`src/projection/project.mjs`, `src/commands/sync.mjs`, `simt tokens`, `simt-dev check`,
+`test/tokens.test.mjs`, `test/surfaces.test.mjs`
+
+## Context
+
+Review 0002 row S38 asks for a per-repository always-on budget: "for these 7 roots,
+generated always-on bytes are at most 30 KB". Plan 0003 spells the mechanism as R08, and
+the plan was read rather than recalled, which is how the two facts below were found.
+
+The first is that R08 as written presupposes R07. Its compiler "packs kernel lines by
+priority class" and `check` reports "each cut line" — and there are no kernel lines
+without R07's `projection.mode` and the per-line kernel frontmatter it introduces, whose own default stays
+`full` until R02 proves a narrow mode is not worse. With no kernel there is nothing to cut,
+so the packing half of R08 cannot be built honestly before the R01–R05 evaluation has been
+run. Building it anyway would mean inventing a kernel nobody measured.
+
+The second is where the number lives. R08 says `projection.budget.bytes`. In this tool
+`projection` is a generated key: `GENERATED_KEYS` names it, and `withGenerated()` replaces
+it with the tool's own `{ simtDevSha, version }` on every write. A budget written there
+would be deleted by the next `upgrade`, and — because `manifestDrift` compares only the
+generated keys — not reported as deleted. The repo would watch its budget disappear on a
+green gate. That is the same defect this package treats as unrecoverable everywhere else:
+content the repository chose must be preserved by the repair, not overwritten by it.
+
+So the part of R08 that is independent of the kernel ships now, and the part that is not
+does not.
+
+## Rulings
+
+1. **The budget is a repository declaration at the top level of the manifest, beside
+   `limits` and `gates`.** It is content the repo chose, so it survives `upgrade`, and the
+   plan's `projection.budget.bytes` spelling is superseded rather than edited in place. The
+   default is not a field either: it is the value whoever measures applies when the key is
+   absent, so `simt tokens` and the gate read one number from one place.
+
+2. **A repository that declares nothing is not reported as having declared the default.**
+   `buildManifest` omits the key entirely when the repo has none, which keeps
+   `budget.declared` an honest fact. Writing the default in would make every adopted repo
+   look like it had chosen the review's line — a reader told "declared: true" about a
+   number nobody wrote is being lied to about the only thing the number is for.
+
+3. **The default is 30,000 bytes and it is the review's figure, not this tool's
+   measurement.** It is written as 30,000 rather than 30 × 1024 because it is a ceiling and
+   the conservative reading of "at most 30 KB" is the one that trips first.
+
+4. **Over budget is reported, never enforced.** The finding names the bytes measured, the
+   bytes declared and what was not done: nothing was cut, because the projection is still
+   in full mode. A reader who sees an over-budget line must not conclude the projection
+   shrank, and a gate that failed here would fail on a measurement this tool has not
+   validated against a study.
+
+5. **`simt tokens` carries the finding it would raise, produced by the same function.**
+   One function words the fact, so the report and the gate cannot describe the same
+   overflow two ways.
+
+6. **The rows themselves are unchanged.** Which rules move behind skills is R01–R05's
+   finding, not this record's, and a budget that silently dropped rules would be enforcing
+   a decision nobody has made.
+
+7. **The meter is the definition of the number, and the gate quotes it.**
+   `simt-dev check` calls the same `measureRoot` the meter does rather than summing the
+   bytes of the targets it happens to compare. That was the other way round first, and it
+   was wrong: the meter also counts managed skills and `.mdc` files, so one repository had
+   two budgets and two different numbers for the same declaration. Two definitions of one
+   ceiling is the same defect as two projections of one fact, one layer up.
+
+8. **The gate raises the finding and does not block on it.** `budget` is in both
+   non-blocking sets, `check` and `sync` alike. Nothing was cut, so the projection is
+   exactly what the repository agreed to project; failing the run over a ceiling it wrote
+   down itself would train people to raise the ceiling. R08 says non-blocking for the same
+   reason, and this record agrees with it now that the finding has a shape to be.
+
+9. **The cost of ruling 7 is accepted rather than avoided.** `check` now reads what the
+   meter reads — the projected region, the rule files, the skills — on every run, where it
+   previously compared bytes it had already read. A cheaper gate would have to keep its own
+   notion of what counts, and this is the one place where the two are not allowed to differ.
+
+## Consequences
+
+S38's accept criterion is now checkable rather than asserted: a repository can declare the
+line it intends to carry, and `simt tokens` reports it against that line and says how far
+over it is. Three tests hold the two halves that were easy to get backwards — the budget
+survives an upgrade, a repository that declared nothing keeps `declared: false`, and the
+finding says that nothing was cut.
+
+What has not landed: the gate reporting the budget as a finding, and R08's packing. The
+first needs the number the gate is already comparing — the bytes of the region and the rule
+files it checks — so that `check` and `tokens` cannot report different totals for one
+repository; that is a wiring decision, not a measurement. The second needs R07.
+
+## Rejected
+
+- **The plan's `projection.budget.bytes`.** The generated block is replaced wholesale on
+  every upgrade, and nothing in the repair would notice.
+- **A default written into every manifest.** It would make every adopted repo look like it
+  had chosen a number it never chose.
+- **Cutting lines to fit the budget now.** There is no kernel to pack and no measurement
+  saying which lines a reader can lose.
+- **Failing the gate on an over-budget projection.** The number is this tool's own
+  estimate, and a gate that fails on its own estimate teaches a reader to ignore it.

package/docs/decisions/ADR-073-a-kernel-is-a-smaller-projection-the-repository-asks-for.md

@@ -0,0 +1,92 @@
+# ADR-073 — A kernel is a smaller projection the repository asks for, not one it is given
+
+Status: **accepted** · 2026-10-14 · filed as S38 (R07)
+**Affects:** `src/projection/manifest.mjs`, `src/projection/rules.mjs`, `src/measure/context.mjs`,
+`rules/core.md`, `rules/stacks/*.md`, `test/kernel.test.mjs`
+
+## Context
+
+S38 asked for a number — generated always-on bytes per turn — and this repository built the
+meter (ADR-064) and the budget line to measure it against (ADR-072). What the meter then
+made unavoidable is that the budget cannot be met by measuring more carefully. A python
+repository projects 11,305 always-on bytes: the shared core, the python profile, and the
+process rules. A kernel keeps the first of those and defers the other two, and the same
+repository projects 9,551. Sixteen percent, for a declaration.
+
+Plan 0003 R07 describes this as packing kernel lines by priority class, and R08's accept
+criterion — the budget is never exceeded — is only reachable once something is packed. So
+this is the piece R08 waits on.
+
+What R07 does not say is which lines are the kernel, and that question is not rhetorical.
+Classifying a rule is a claim about what a reader loses by not having it: a rule that says
+never force-push is not equivalent to a rule that says prefer descriptive commit subjects,
+and only one of those can be the one thing loaded when nothing matches. The classification
+lives in the rule's own frontmatter, because the judgement belongs beside the text it
+describes and not in a table that would have to be kept in step with 20 files.
+
+## Rulings
+
+1. **The mode is a repository declaration, beside the budget, not inside `projection`.**
+   `mode` is written only when the repository declared it, for exactly the reason ADR-072
+   gave for `budget`: `projection` is a generated key, `upgrade` replaces it wholesale, and
+   a mode that reset itself on upgrade would reset the reader's context size without anyone
+   asking.
+
+2. **Absent means `full`, and `full` stays the default.** Nobody has measured that a kernel
+   is not worse at getting a task done; plan 0003 R02 is that measurement and it has not
+   been run. Shipping a default that quietly withholds rules from every repository on the
+   strength of an unrun study is the same defect as a rule nobody can find.
+
+3. **A rule declares its class in its own frontmatter, and the vocabulary is closed.**
+   `simt-priority: hard | command | convention | style`, ordered as a kernel packs them.
+   An unrecognised value is a defect reported by `graph lint` and `check`, in the order the
+   other frontmatter checks run, rather than a class nobody happened to use.
+
+4. **A rule that states no class is deferred in kernel mode.** An unstated class is not a
+   hard constraint, and the asymmetry decides it: wrongly keeping a line defeats the mode
+   the repository asked for, while wrongly dropping one costs a convention or a style, which
+   `rules show <id>` returns on demand.
+
+5. **The kernel is the two classes a reader loses least from.** `hard` and `command` are
+   what a repository must not do wrong; `convention` and `style` are guidance that is
+   valuable in context and worthless out of it. The shipped content is classified to match:
+   `core.md` is `hard`, and the 19 stack profiles are `convention`.
+
+6. **Everything deferred is named in the region, with the command that shows it.** The
+   region gains a `## Deferred rules` section listing each omitted rule, its class and
+   `rules show <id>`, sorted by class then rule id. A rule left out and named nowhere is a
+   rule the reader cannot find, which is indistinguishable from a rule that was never
+   written — the same defect S50's scoped pointers exist to prevent, in the other
+   direction.
+
+7. **The order is deterministic and is the only thing that determines it.** Class, then
+   rule id. Two machines that project the same repository produce byte-identical regions,
+   which is R08's second half and this repository's standing rule.
+
+8. **A kernel over the budget is a different finding from a full projection over it.** The
+   budget finding takes the mode and says so: in `full`, nothing was cut and the advice is
+   to raise the number or switch to kernel; in `kernel`, the projection is already as small
+   as this mode makes it, so the advice is to raise the number or move rules out of the
+   hard and command classes. Conflating the two would leave a reader believing a trimmed
+   projection was waiting to be trimmed.
+
+## Consequences
+
+A repository that declares `mode: kernel` gets the shared core plus the hard and command
+rules, and a list of everything else with the command to fetch it. The meter's own reading
+drops by about a sixth on a python repository, and the budget finding now distinguishes the
+two reasons a projection can be over its line.
+
+What is not here: the measurement that would justify making `kernel` the default, and the
+workspace-level dedupe R11 proposes. Both are named in the tracker's remaining note for this
+row. This ruling is what makes them measurable rather than what concludes them.
+
+## Rejected
+
+- **Making `kernel` the default.** It withholds guidance from every repository on the
+  strength of a study that has not been run.
+- **A central table of classes rather than frontmatter.** A table beside 20 rule files is a
+  thing to keep in step with them, and the judgement it records belongs next to the text.
+- **Silently deferring, or deferring with a count.** A reader told "12 rules deferred" has
+  to guess which ones apply to the file in front of them; the names are the part that
+  answers.

package/docs/decisions/README.md

@@ -66,6 +66,8 @@ record's status line — never by editing the ruling in place.
 | [056](ADR-056-three-names-one-of-which-is-cheap-to-move.md) | The command, the package and the project are three names, and only one of them is cheap to move | accepted · amends ADR-023 |
 | [057](ADR-057-an-identity-is-per-developer-and-a-repository-does-not-own-it.md) | An identity is per-developer, and a repository does not own it | accepted |
 | [058](ADR-058-one-tool-three-channels-and-the-order-is-forced.md) | One tool, three channels, and the order is forced | accepted |
+| [059](ADR-059-the-version-a-repository-runs-is-the-one-it-pinned.md) | The version a repository runs is the one it pinned, and the gate refuses otherwise | accepted |
+| [060](ADR-060-a-repository-with-nothing-to-run-is-adopted-and-says-so.md) | A repository with nothing to run is adopted and says so; a gate is verified where it runs | accepted |
 
 ADR-001 to ADR-010 resolve the contradictions found across the 16 repos in the 2026-10-05
 audit; each record names the repos whose text it replaces. ADR-011 and ADR-012 are the
@@ -402,6 +404,21 @@ docstring that used to claim the whole output "never contains a path" is withdra
 asserted a property the function never had, which is the same defect as a citation that
 cannot be resolved — a sentence that reads like evidence and carries none.
 
+ADR-059 is the first record here whose subject is the version of the tool itself, and it
+exists because a check that runs from the wrong binary is a pass that never happened. ADR-010
+allowed a tool that is not a project dependency to be invoked directly, *provided its version
+is pinned* — and for a repository without npm that "pinned" half had no mechanism. The version
+on `PATH` was whatever the last global install left there, and the gate that ran on commit was
+the one in it: a green tick from a check running a different gate than CI is worse than a red
+build, because it is the failure that looks like evidence. The record rules that the version a
+repository adopted is recorded in the manifest, that the gate refuses when the running binary
+differs, and that the install and the remedy are per kind — so the check CI runs is the one the
+machine remedy names. Its most load-bearing consequence is the one that keeps it from becoming a
+trap: a repository adopted before the field existed has nothing to compare against, so it is
+skipped rather than failed, and reported as drift instead — because a gate that turns red on the
+day a check ships, for a mismatch nobody can resolve until they re-adopt, is a gate no one will
+trust again.
+
 ## The rule these records enforce
 
 Every shared rule has exactly **one** canonical home. Every other location is either a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "simt-dev",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Shared agent rules, skills and git hooks for a repository: one command adopts a repo, and every gate it declares is probed before it is written.",
   "license": "Apache-2.0",
   "author": "Said Elimam",
@@ -19,7 +19,6 @@
   "files": [
     "bin",
     "src",
-    "graph",
     "rules",
     "docs/decisions",
     "CHANGELOG.md"

package/rules/core.md

@@ -2,6 +2,7 @@
 simt-id: core
 simt-title: Shared rules
 simt-applies: always
+simt-priority: hard
 ---
 
 # Shared rules

package/rules/stacks/android.md

@@ -6,6 +6,8 @@ simt-title: Android
 # JVM backend, which is how a Spring or Ktor service used to receive this profile
 # (S28, ADR-047).
 simt-applies: [has-android-manifest]
+simt-priority: convention
+simt-scope: ["AndroidManifest.xml", "**/build.gradle", "**/build.gradle.kts", "**/*.kt"]
 ---
 
 # Stack profile: Android

package/rules/stacks/cloudflare-workers.md

@@ -7,6 +7,8 @@ simt-title: Cloudflare Workers (TypeScript)
 # happily as on Workers. A wrangler config or the `wrangler` dependency is the
 # only evidence that this is a Worker (S28, ADR-047).
 simt-applies: [cloudflare-workers]
+simt-priority: convention
+simt-scope: ["wrangler.jsonc", "wrangler.toml", "**/worker.ts"]
 ---
 
 # Stack profile: Cloudflare Workers (TypeScript)

package/rules/stacks/connectiq.md

@@ -2,6 +2,7 @@
 simt-id: connectiq
 simt-title: Connect IQ (Monkey C)
 simt-applies: [connectiq]
+simt-priority: convention
 ---
 
 # Stack profile: Connect IQ (Monkey C)

package/rules/stacks/container.md

@@ -2,6 +2,8 @@
 simt-id: container
 simt-title: Containers
 simt-applies: [has-dockerfile]
+simt-priority: convention
+simt-scope: ["Dockerfile", "*.dockerfile"]
 simt-fallback: false
 ---
 

package/rules/stacks/dart.md

@@ -0,0 +1,40 @@
+---
+simt-id: dart
+simt-title: Dart
+simt-applies: [has-pubspec]
+simt-priority: convention
+simt-scope: ["pubspec.yaml", "**/*.dart"]
+---
+
+# Stack profile: Dart
+
+Applies to: `has-pubspec` — a `pubspec.yaml`. A Flutter project is a Dart project
+with the `flutter` SDK dependency; the Flutter-specific rules live with the tools
+that build it, not here.
+
+## Build and gates
+
+- `dart analyze`, `dart test` are the entrypoints; `dart format --output=none
+  --set-exit-if-changed .` is the formatting gate. A Flutter project runs the same
+  commands through `flutter`, and the two must not be mixed in one change.
+- Dependencies are declared in `pubspec.yaml`; `pub get` resolves them into
+  `pubspec.lock`, which is committed for an application. A package that imports a
+  library the manifest does not list resolves only by accident.
+
+## Style
+
+- `package:lints` (or the repo's stricter set) is the lint source; a rule the repo
+  disabled is a decision, and re-enabling it is a change, not a fix.
+- No `dynamic` where a real type exists. A `dynamic` that is guessed rather than
+  checked is a hole the analyzer was told to stop looking through.
+- `late` and `?` are decisions: a field that is `late` because the author did not
+  know when it is set is a defect, not a convenience.
+- Prefer a small `sealed` class hierarchy over booleans; a pair of `bool` fields is
+  four states, one of which is always wrong.
+
+## Testing
+
+- `dart test` is the gate; a library with no tests is allowed to have none, but a
+  change that touches one must not break its neighbours.
+- Assert on values through the public API; a test that reaches into a private field
+  is coupled to an implementation it should not own.

package/rules/stacks/deno.md

@@ -0,0 +1,38 @@
+---
+simt-id: deno
+simt-title: Deno
+simt-applies: [has-deno-config]
+simt-priority: convention
+simt-scope: ["deno.json", "deno.jsonc", "**/*.ts"]
+---
+
+# Stack profile: Deno
+
+Applies to: `has-deno-config` — a `deno.json` or `deno.jsonc`.
+
+## Build and gates
+
+- `deno test`, `deno check .` are the entrypoints; `deno fmt --check` and
+  `deno lint` are the formatting and lint gates. A repo that vendors dependencies
+  runs them with `--vendor`; one that does not must not add the flag.
+- The lockfile (`deno.lock`) is committed where it exists; a build that ignores it
+  is not reproducible. A lockfile the repo chose to delete is a decision, and
+  re-adding it is a change, not a fix.
+- Import from `npm:` specifiers where the repo does; do not introduce a second
+  registry convention into a repo that has one.
+
+## Style
+
+- Types are checked with `deno check .`; a file that compiles under `deno run` but
+  not under `deno check` is a defect the gate exists to catch.
+- No `any`. An `unknown` that is narrowed at the boundary is a type; an `any` is a
+  hole the checker was told to stop looking through.
+- Prefer a small `enum`-shaped union over booleans; a pair of `boolean` fields is
+  four states, one of which is always wrong.
+
+## Testing
+
+- `Deno.test` is the runner; a test that needs a fixture reads it from a path
+  relative to the test file, never from a machine-specific location.
+- Assert on values through the public API; a test that reaches into module-private
+  state is coupled to an implementation it should not own.

package/rules/stacks/dotnet.md

@@ -0,0 +1,37 @@
+---
+simt-id: dotnet
+simt-title: .NET
+simt-applies: [has-nuget]
+simt-priority: convention
+simt-scope: ["*.csproj", "*.sln", "*.fsproj"]
+---
+
+# Stack profile: .NET
+
+Applies to: `has-nuget` — a `.csproj` or solution.
+
+## Build and gates
+
+- `dotnet build`, `dotnet test` are the entrypoints; `dotnet format
+  --verify-no-changes` is the formatting gate. A solution builds with `dotnet build
+  <solution>`, never a bare project path that skips the solution's configuration.
+- Build with `-warnaserror` where the repo sets it; a warning that is not an error
+  is a defect the gate is being asked to ignore.
+- Restore is deterministic: commit `global.json` and any NuGet.config the repo has,
+  so a build does not depend on a machine's cache.
+
+## Style
+
+- Prefer `required` members and `init` over a public setter that exists to satisfy
+  the constructor. A mutable property nobody should write is a hole in the type.
+- `async`/`await` all the way: no `.Result`, no `.Wait()`. A synchronous call into
+  an async boundary is a deadlock waiting for the thread pool.
+- Nullability is on: `#nullable enable` in new code, and a `?` that is guessed
+  rather than checked is a defect.
+
+## Testing
+
+- `dotnet test` runs xUnit, NUnit or MSTest — whichever the project references; do
+  not add a second framework to a repo that has one.
+- Assert on behaviour through the public surface; a test that reaches into a private
+  field is coupled to an implementation it should not own.

package/rules/stacks/elixir.md

@@ -0,0 +1,41 @@
+---
+simt-id: elixir
+simt-title: Elixir
+simt-applies: [has-mix]
+simt-priority: convention
+simt-scope: ["mix.exs", "lib/**/*.ex"]
+---
+
+# Stack profile: Elixir
+
+Applies to: `has-mix` — a `mix.exs`.
+
+## Build and gates
+
+- `mix test` is the entrypoint; `mix format --check-formatted` is the formatting
+  gate. A repo that uses `mix credo` runs it with `mix credo --strict` where the
+  `.credo.exs` exists; a check the repo configured is a decision, and skipping it
+  is a change, not a fix.
+- Dependencies are declared in `mix.exs`; `mix deps.get` resolves them into
+  `mix.lock`, which is committed. A module that imports a library the manifest does
+  not list compiles only by accident.
+- A release is built with `mix release` where the repo defines one; do not run a
+  `mix run` against a release's expectations.
+
+## Style
+
+- Pattern-match on the way in, not guard-and-raise on the way out. A function that
+  takes a map and digs three levels deep is a boundary somebody refused to name;
+  match the shape at the edge and pass values in.
+- Errors are returned, not raised, for expected failures; `raise` is for bugs, not
+  for a missing record. A caller that cannot handle the failure is a defect in the
+  caller's contract, not a reason to crash.
+- Prefer a small `struct` with named fields over a map of strings; a `%{}` that is
+  passed through five functions is a type somebody refused to give a name.
+
+## Testing
+
+- `mix test` is the gate; ExUnit is the runner, and a change that touches a module
+  must not break its neighbours.
+- Assert on behaviour through the public API; a test that reaches into a private
+  field is coupled to an implementation it should not own.

package/rules/stacks/go.md

@@ -0,0 +1,36 @@
+---
+simt-id: go
+simt-title: Go
+simt-applies: [has-go-mod]
+simt-priority: convention
+simt-scope: ["go.mod", "**/*.go"]
+---
+
+# Stack profile: Go
+
+Applies to: `has-go-mod` — a module.
+
+## Build and gates
+
+- `go build ./...`, `go test ./...` are the entrypoints; `go vet ./...` runs with
+  them. Never rely on a file the build does not include.
+- Format with `gofmt` (or `go fmt ./...`). A diff that is only formatting is a
+  defect: the gate fails closed on it.
+- Depend on the module, not on a `GOPATH` layout. A package import that resolves
+  only because of a local checkout is a broken dependency.
+
+## Style
+
+- Errors are values, not exceptions. Wrap with `fmt.Errorf("...: %w", err)` so the
+  caller can `errors.Is`/`errors.As`; a bare string loses the chain.
+- `context.Context` is the first parameter of anything that can be cancelled; never
+  store one in a struct.
+- Table-driven tests: one `for range` over named cases beats ten copy-pasted
+  subtests.
+
+## Testing
+
+- `go test ./...` is the gate; a package with no test file is allowed to have none,
+  but a change that touches one must not break its neighbours.
+- Benchmark with `-bench` only where the number is a decision; an unowned benchmark
+  is decoration.

package/rules/stacks/jvm.md

@@ -6,6 +6,8 @@ simt-title: JVM backend
 # or Ktor service received rules about Compose, Wear OS application ids and
 # instrumentation tests — advice with nothing to apply it to (S28, ADR-047).
 simt-applies: [gradle, has-maven-pom, kotlin, java]
+simt-priority: convention
+simt-scope: ["build.gradle", "build.gradle.kts", "pom.xml", "settings.gradle", "settings.gradle.kts"]
 ---
 
 # Stack profile: JVM backend

package/rules/stacks/node.md

@@ -2,6 +2,8 @@
 simt-id: node
 simt-title: Node (general)
 simt-applies: [node]
+simt-priority: convention
+simt-scope: ["package.json", "tsconfig.json", "jsconfig.json", ".nvmrc"]
 simt-fallback: true
 ---
 

package/rules/stacks/python.md

@@ -2,6 +2,8 @@
 simt-id: python
 simt-title: Python
 simt-applies: [python]
+simt-priority: convention
+simt-scope: ["pyproject.toml", "requirements.txt", "setup.py", "*.py"]
 ---
 
 # Stack profile: Python

package/rules/stacks/react-native.md

@@ -6,6 +6,8 @@ simt-title: React Native
 # CSS logical properties, a browser matrix, WCAG reflow at 400 % — none of which a
 # native surface has (S28, ADR-047).
 simt-applies: [react-native]
+simt-priority: convention
+simt-scope: ["app.json", "metro.config.js", "ios/**", "android/**"]
 ---
 
 # Stack profile: React Native

package/rules/stacks/react-web.md

@@ -6,6 +6,8 @@ simt-title: React web
 # listing the bare language tags (`typescript`, `vitest`, `node-web`, `less`) put
 # this profile on backend and static repositories that share them (S28, ADR-047).
 simt-applies: [react-dom, react-router, maplibre, firebase]
+simt-priority: convention
+simt-scope: ["src/**/*.{ts,tsx,js,jsx}", "index.html"]
 ---
 
 # Stack profile: React web

package/rules/stacks/ruby.md

@@ -0,0 +1,38 @@
+---
+simt-id: ruby
+simt-title: Ruby
+simt-applies: [has-gemfile]
+simt-priority: convention
+simt-scope: ["Gemfile", "**/*.rb"]
+---
+
+# Stack profile: Ruby
+
+Applies to: `has-gemfile` — a Bundled application or gem.
+
+## Build and gates
+
+- `bundle install` then `bundle exec rspec` are the entrypoints; run every command
+  through `bundle exec`, never a bare binary, so the Gemfile.lock is the only
+  source of truth for versions.
+- `bundle exec rubocop` is the lint gate where the repo has a `.rubocop.yml`; a
+  cop the repo disabled is a decision, and re-enabling it is a change, not a fix.
+- `Gemfile.lock` is committed for an application; for a library it is not, and the
+  distinction is a decision the repo made, not one to reverse silently.
+
+## Style
+
+- Frozen string literals (`# frozen_string_literal: true`) at the top of new files
+  where the repo already uses them; a mixed repo is a transition, not a licence to
+  pick either.
+- Prefer `case`/`when` or a hash over a chain of `if`/`elsif` on one variable; a
+  five-branch if-chain is a lookup table somebody refused to name.
+- `raise` with a message that names the failure and the value that caused it; a
+  bare `raise` is a defect the next reader cannot debug.
+
+## Testing
+
+- RSpec is the runner where the repo has one; do not add a second framework to a
+  repo that has one.
+- Assert on behaviour through the public interface; a spec that stubs everything
+  and asserts on the stub is testing the stub, not the code.

package/rules/stacks/rust.md

@@ -0,0 +1,36 @@
+---
+simt-id: rust
+simt-title: Rust
+simt-applies: [has-cargo-toml]
+simt-priority: convention
+simt-scope: ["Cargo.toml", "src/**/*.rs"]
+---
+
+# Stack profile: Rust
+
+Applies to: `has-cargo-toml` — a Cargo workspace or crate.
+
+## Build and gates
+
+- `cargo build`, `cargo test` are the entrypoints; a workspace builds with
+  `cargo build --workspace`. Never invoke a toolchain the manifest does not pin.
+- Format with `cargo fmt`; lint with `cargo clippy -- -D warnings`. A warning is a
+  defect, not a note: fix it or the gate fails.
+- Pin the toolchain in `rust-toolchain.toml` where one is committed; a rustup
+  default on the developer's machine is not a floor anything enforces.
+
+## Style
+
+- No `unwrap()` or `expect()` outside tests. A panic path in library code is an
+  unhandled error; return a `Result` and let the caller decide.
+- `#[must_use]` on fallible constructors; a `Result` that is ignored is a bug the
+  compiler should flag.
+- Prefer a small `enum` of states over booleans; a pair of `bool` fields is four
+  states, one of which is always wrong.
+
+## Testing
+
+- Unit tests live in `#[cfg(test)]` next to the code; integration tests in `tests/`
+  exercise the public API only.
+- Assert on values, not on panic messages. A test that asserts a panic string has
+  coupled itself to an implementation detail it should not own.

package/rules/stacks/swift.md

@@ -0,0 +1,39 @@
+---
+simt-id: swift
+simt-title: Swift
+simt-applies: [has-swift-package]
+simt-priority: convention
+simt-scope: ["Package.swift", "**/*.swift"]
+---
+
+# Stack profile: Swift
+
+Applies to: `has-swift-package` — a Swift package.
+
+## Build and gates
+
+- `swift build`, `swift test` are the entrypoints; `swift format lint -r .` is the
+  formatting gate. A platform build (Xcode) is a different question from a package
+  build — do not conflate the two in one command.
+- Pin the toolchain where the repo does (a `Package.swift` tools version or a
+  pinned Xcode); a compiler on the developer's machine is not a floor anything
+  enforces.
+- Dependencies are declared in `Package.swift`; a package that imports a module the
+  manifest does not list builds only by accident.
+
+## Style
+
+- Concurrency is checked, not assumed: `Sendable` conformance is a decision. A
+  `@unchecked Sendable` that papers over a real race is a defect the compiler was
+  told to stop reporting.
+- `throws` for expected failures, not `fatalError`. A crash path in library code is
+  an unhandled error; return a `Result` or throw.
+- Prefer a small `enum` of states over optionals of optionals; a triple `??` is a
+  state machine somebody refused to name.
+
+## Testing
+
+- `swift test` is the gate; a target with no tests is allowed to have none, but a
+  change that touches one must not break its neighbours.
+- Assert on values through the public API; a test that reaches into an internal
+  field is coupled to an implementation it should not own.