iriq 0.30.2 → 0.35.0

data/lib/iriq/trace.rb

@@ -31,8 +31,9 @@ module Iriq
         input:      iri.canonical,
         normalized: normalized,
         scheme:     iri.scheme,
-        host:       iri.host,
       }
+      # Fields that don't apply are omitted, not null (matches parse JSON).
+      out[:host] = iri.host if iri.host
       out[:port] = iri.port if iri.port
 
       if iri.urn?
@@ -84,25 +85,24 @@ module Iriq
         payload: { type: entry[:type], variable: entry[:variable], hint: entry[:hint] },
       )
 
+      # The canonical policy applies even when the value is already canonical
+      # (that's what makes the row print the value, not a placeholder); only
+      # the note is reserved for an actual rewrite.
       if entry[:variable]
         if entry[:type] == :date && (canon = SegmentClassifier.canonical_date(entry[:value]))
-          if canon != entry[:value]
-            records << Evidence.segment(
-              index: idx, value: entry[:value],
-              source:  :policy,
-              payload: { rule: :canonical_date, before: entry[:value], after: canon },
-              notes:   ["canonical date (#{entry[:value]} → #{canon})"],
-            )
-          end
+          records << Evidence.segment(
+            index: idx, value: entry[:value],
+            source:  :policy,
+            payload: { rule: :canonical_date, before: entry[:value], after: canon },
+            notes:   canon == entry[:value] ? [] : ["canonical date (#{entry[:value]} → #{canon})"],
+          )
         elsif entry[:type] == :currency && (canon = SegmentClassifier.canonical_currency(entry[:value]))
-          if canon != entry[:value]
-            records << Evidence.segment(
-              index: idx, value: entry[:value],
-              source:  :policy,
-              payload: { rule: :canonical_currency, before: entry[:value], after: canon },
-              notes:   ["currency upcase (#{entry[:value]} → #{canon})"],
-            )
-          end
+          records << Evidence.segment(
+            index: idx, value: entry[:value],
+            source:  :policy,
+            payload: { rule: :canonical_currency, before: entry[:value], after: canon },
+            notes:   canon == entry[:value] ? [] : ["currency upcase (#{entry[:value]} → #{canon})"],
+          )
         else
           extra = placeholder_decoration_evidence(entry, segments, idx, classifier, hints)
           records.concat(extra)
@@ -162,23 +162,19 @@ module Iriq
       )
 
       if effective == :date && (canon = SegmentClassifier.canonical_date(value))
-        if canon != value
-          records << Evidence.segment(
-            index: name, value: value,
-            source:  :policy,
-            payload: { rule: :canonical_date, before: value, after: canon },
-            notes:   ["canonical date (#{value} → #{canon})"],
-          )
-        end
+        records << Evidence.segment(
+          index: name, value: value,
+          source:  :policy,
+          payload: { rule: :canonical_date, before: value, after: canon },
+          notes:   canon == value ? [] : ["canonical date (#{value} → #{canon})"],
+        )
       elsif effective == :currency && (canon = SegmentClassifier.canonical_currency(value))
-        if canon != value
-          records << Evidence.segment(
-            index: name, value: value,
-            source:  :policy,
-            payload: { rule: :canonical_currency, before: value, after: canon },
-            notes:   ["currency upcase (#{value} → #{canon})"],
-          )
-        end
+        records << Evidence.segment(
+          index: name, value: value,
+          source:  :policy,
+          payload: { rule: :canonical_currency, before: value, after: canon },
+          notes:   canon == value ? [] : ["currency upcase (#{value} → #{canon})"],
+        )
       elsif effective == :ipv4 || effective == :ipv6
         records << Evidence.segment(
           index: name, value: value,

data/lib/iriq/version.rb

@@ -1,3 +1,3 @@
 module Iriq
-  VERSION = "0.30.2"
+  VERSION = "0.35.0"
 end

data/lib/iriq.rb

@@ -19,6 +19,7 @@ require "iriq/trace"
 require "iriq/cluster"
 require "iriq/clusterer"
 require "iriq/position_stats"
+require "iriq/position_evidence"
 require "set"
 
 require "iriq/observation"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: iriq
 version: !ruby/object:Gem::Version
-  version: 0.30.2
+  version: 0.35.0
 platform: ruby
 authors:
 - Daniel Pepper
@@ -86,16 +86,10 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
-- CLAUDE.md
-- Gemfile
-- Gemfile.lock
 - LICENSE.txt
-- Makefile
 - README.md
 - completions/_iriq
 - completions/iriq.bash
-- docs/ARCHITECTURE.md
-- docs/ROADMAP.md
 - exe/iriq
 - iriq.gemspec
 - lib/iriq.rb
@@ -116,6 +110,7 @@ files:
 - lib/iriq/parser.rb
 - lib/iriq/path_shape.rb
 - lib/iriq/position.rb
+- lib/iriq/position_evidence.rb
 - lib/iriq/position_stats.rb
 - lib/iriq/recognizer.rb
 - lib/iriq/recognizer_proposal.rb
@@ -153,7 +148,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.11
+rubygems_version: 3.6.9
 specification_version: 4
 summary: IRI extraction, normalization, and clustering.
 test_files: []

data/CLAUDE.md

@@ -1,208 +0,0 @@
-# Iriq development conventions
-
-> **⚠️ Behavior changes touch ALL THREE runtimes.** Ruby is the reference; Go
-> + Rust mirror it. Before committing any change to
-> parser/normalizer/extractor/CLI/etc:
->
->   1. Update Ruby + specs.
->   2. `bundle exec ruby script/generate_fixtures.rb` (regenerate JSON parity fixtures).
->   3. Port the change to Go (the Go module lives in `go/`).
->   4. `go -C go test ./...` — fixture tests should still pass.
->   5. `make build && script/cli_parity.sh` — Ruby ↔ Go CLI parity should still pass.
->   6. Port the change to Rust under `rust/`.
->   7. `cd rust && cargo test --workspace` — Rust fixture tests should still pass
->      (SQLite is a default feature).
->   8. `cd rust && cargo build --release --bin iriq && cd .. && script/rust_parity.sh`
->      — Rust ↔ Go CLI parity (covers Ruby transitively).
->   9. Commit the regenerated fixtures alongside the code change.
->
-> CI's parity + Rust jobs will fail if any step is skipped. The **Rust gate**
-> (fmt + clippy + tests) is automated — run `make hooks` once to install the
-> committed pre-push hook that runs `make check`. Full multi-runtime pre-push
-> for a behavior change:
-> `bundle exec rspec && go -C go test ./... && script/cli_parity.sh && make check && script/rust_parity.sh`.
-
-## Repo layout — Ruby at the root, Go and Rust in subdirs
-
-The Ruby gem lives at the repo root (it's the reference implementation and the
-published gem); the two mirror implementations are compartmentalized into
-`go/` and `rust/`. Earlier the Go code was intermixed at the root; it now sits
-in `go/`, symmetric with `rust/`, so the root reads as "Ruby + two ports."
-
-```
-iriq/
-  lib/ exe/ spec/         ← Ruby gem (library, CLI, specs) — the reference
-  completions/            ← shell-completion scripts shipped by the gem
-  iriq.gemspec
-  Gemfile
-
-  go/                     ← Go module github.com/dpep/iriq/go
-    go.mod go.sum
-    *.go                  ← Go package `iriq`
-    cmd/iriq/             ← Go CLI binary
-    completions/          ← Go's own embedded copy (go:embed can't reach ../)
-
-  rust/                   ← Cargo workspace
-    Cargo.toml            ← workspace root
-    iriq/                 ← one crate: library + `iriq` CLI binary; inlines completions
-    REPORT.md             ← Go → Rust port spike notes + perf
-    target/               ← Rust build artifacts (gitignored)
-
-  bin/                    ← built Go binary (gitignored)
-  script/                 ← shared dev scripts (fixture gen, parity, benches)
-  spec/fixtures/          ← golden JSON shared by Ruby specs + Go + Rust tests
-  .github/workflows/      ← Ruby CI, Go CI, Rust CI, parity CIs
-```
-
-Notes on this layout:
-
-- Go's import path is now `github.com/dpep/iriq/go` (the `/go` suffix matches
-  the subdir). Consumers import `github.com/dpep/iriq/go`.
-- One version tag (`vX.Y.Z`) serves all three runtimes — Ruby's gemspec, Go's
-  module, and Rust's `Cargo.toml` use the same tag stream.
-- The gemspec ships only Ruby + `completions/`, excluding `go/` and `rust/`:
-  `git ls-files * ':!:spec' ':!:script' ':!:bin' ':!:rust' ':!:go'`.
-- Completion scripts exist in three places (gem root `completions/`, `go/completions/`
-  for `go:embed`, and inlined in the Rust CLI) — keep them in sync like fixtures.
-
-## Building
-
-```sh
-# Ruby gem
-bundle install
-bundle exec exe/iriq --help     # runs the CLI from source
-
-# Go binary — convenience targets in the Makefile
-make build                      # → ./bin/iriq
-make install                    # go install into $GOBIN
-make uninstall                  # remove from $GOBIN
-make clean                      # remove ./bin/
-make test                       # go test ./...
-
-# Rust — one crate (library + `iriq` binary), SQLite bundled by default
-cd rust && cargo build --release --bin iriq    # → ./rust/target/release/iriq
-cd rust && cargo install --path iriq           # install into ~/.cargo/bin
-cd rust && cargo test --workspace
-
-# Via Homebrew (builds the Rust CLI from main)
-brew install dpep/tools/iriq
-
-# Via crates.io
-cargo install iriq
-```
-
-## Keeping the three runtimes in sync
-
-Ruby is the **reference implementation**. Go and Rust mirror its public API
-and behavior. Three layers of parity testing keep them aligned:
-
-1. **Golden JSON fixtures** (`spec/fixtures/*.json`)
-   Generated by `script/generate_fixtures.rb` from the Ruby implementation
-   over a curated set of inputs. Go's `fixtures_test.go` and Rust's
-   `rust/iriq/tests/fixtures.rs` both load each file and assert the same
-   outputs.
-
-2. **Ruby ↔ Go CLI parity harness** (`script/cli_parity.sh`)
-   Runs the same input through `bundle exec exe/iriq` and the Go binary and
-   diffs stdout. Lives in CI as the `Ruby ↔ Go parity` job.
-
-3. **Rust ↔ Go CLI parity harness** (`script/rust_parity.sh`)
-   Same idea — runs every Phase 1 + Phase 2 scenario (single-input,
-   pipe-mode, JSON corpus, SQLite corpus, --stats, --reinfer,
-   --propose-recognizers, --cross-host-shapes, --host=reg) through the
-   Go and Rust binaries and diffs stdout. Lives in CI as the
-   `Rust ↔ Go parity` job. Rust transitively inherits Ruby parity via Go.
-
-When changing behavior:
-
-1. Update the Ruby code + specs first.
-2. Regenerate fixtures: `bundle exec ruby script/generate_fixtures.rb`.
-3. Port the change to Go.
-4. `go test ./...` (uses the updated fixtures).
-5. `script/cli_parity.sh` should pass.
-6. Port the change to Rust under `rust/`.
-7. `cd rust && cargo test --workspace`.
-8. `cd rust && cargo build --release --bin iriq && cd .. && script/rust_parity.sh` should pass.
-9. Commit fixtures with the change — CI will fail if they're stale.
-
-## Tests
-
-```sh
-bundle exec rspec                                # Ruby suite (305+ examples)
-go test ./...                                    # Go suite (native + fixture parity)
-script/cli_parity.sh                             # Ruby ↔ Go CLI parity
-cd rust && cargo test --workspace
-cd rust && cargo fmt --check                      # formatting (CI-gated)
-cd rust && cargo clippy --workspace --all-targets -- -D warnings
-make check                                        # the three Rust checks above, in one shot
-script/rust_parity.sh                            # Rust ↔ Go CLI parity (~59 scenarios)
-```
-
-## Releases
-
-Versioning is single-stream: one `vX.Y.Z` covers all three runtimes. Bump the
-three version constants **together** — the `--version` parity checks fail
-if they drift:
-
-1. `lib/iriq/version.rb` (`VERSION`), `go/version.go` (`Version`), and the two
-   `version = "X.Y.Z"` / `pub const VERSION` lines in `rust/iriq/Cargo.toml` and
-   `rust/iriq/src/lib.rs` — same string.
-2. `Gemfile.lock` — re-resolve so the pinned `iriq (X.Y.Z)` matches
-   (`bundle install`, or it regenerates on the next `bundle exec`). Commit it.
-3. Run `cd rust && cargo update -p iriq` to refresh `Cargo.lock`.
-4. Tag `vX.Y.Z` and push. Go consumers pick it up via
-   `go get github.com/dpep/iriq/go@vX.Y.Z`.
-5. `gem push iriq-X.Y.Z.gem` to publish to RubyGems.
-6. `cd rust && cargo publish -p iriq` to publish to crates.io (the crate ships
-   both the library and the `iriq` binary).
-
-### Keep Homebrew in sync — bump on EVERY version change
-
-The tap (`~/code/lib/homebrew-tools`) ships a single `Formula/iriq.rb` that
-builds the Rust CLI (`cargo install --path rust/iriq`) from `branch: "main"`.
-SQLite is on by default (the `iriq` crate's `default` feature set), so there is
-no longer a separate `iriq-sqlite` formula.
-
-The formula pins a static `version "X.Y.Z"` label. Because the build tracks
-`main` rather than a tagged tarball, `brew upgrade` only rebuilds when that
-label changes. So on every bump here, update the `version` string in
-`Formula/iriq.rb` to match `version.rb`, then commit + push the tap. Leaving it
-stale means brew users never get the new code even though it's already on `main`.
-
-## Corpus storage backends
-
-The `Corpus` class delegates state to a `Storage` backend; three backends ship:
-
-- **Memory** — default, in-process only.
-- **JSON** — Memory wrapped with atomic load/save against a JSON file
-  (`.json` by default). Same shape both runtimes have always written.
-- **SQLite** — incremental UPSERTs against a `.db` / `.sqlite` / `.sqlite3`
-  file with WAL journaling. Supports concurrent observers and avoids
-  loading the whole corpus into memory.
-
-`Corpus.open(path)` (Ruby) / `iriq.OpenCorpus(path)` (Go) picks the backend
-by file extension. `corpus.save(other_path)` exports as JSON regardless of
-the live backend; `corpus.save(same_path)` is idempotent (no clobbering a
-SQLite file with JSON, etc.).
-
-The Ruby `sqlite3` gem is loaded lazily (only when a `.db` path is opened),
-keeping the iriq install footprint minimal for users that stick with JSON.
-On the Go side we use `modernc.org/sqlite` (pure Go — no cgo). The Rust
-side uses `rusqlite` with the `bundled` feature (statically links C SQLite,
-~3-4 MB binary cost). Schema v4 is shared across all three runtimes — a
-`.db` written by any binary opens cleanly in any other.
-
-When adding a new backend, replicate the contract in all three languages
-and add parity scenarios in `script/cli_parity.sh`'s `corpus_pair`
-section + `script/rust_parity.sh`'s `corpus_pair`.
-
-## What lives where in scripts
-
-- `script/benchmark.rb` — Ruby-only throughput benchmark.
-- `script/memory.rb` — Ruby-only memory profile.
-- `script/generate_fixtures.rb` — produces `spec/fixtures/*.json` for cross-runtime parity.
-- `script/cli_parity.sh` — Ruby ↔ Go CLI diff.
-- `script/rust_parity.sh` — Rust ↔ Go CLI diff.
-- `script/bench_three_way.sh` — Go vs Rust wall-clock comparison.
-- `script/bench_compare.sh` — Ruby vs Go CLI wall-time comparison.
-- `script/bench_storage.sh` — JSON vs SQLite backend timing (single-process, incremental, concurrent).

data/Gemfile

@@ -1,3 +0,0 @@
-source "https://rubygems.org"
-
-gemspec

data/Gemfile.lock

@@ -1,103 +0,0 @@
-PATH
-  remote: .
-  specs:
-    iriq (0.30.2)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    date (3.5.1)
-    debug (1.11.1)
-      irb (~> 1.10)
-      reline (>= 0.3.8)
-    diff-lcs (1.6.2)
-    docile (1.4.1)
-    erb (6.0.4)
-    io-console (0.8.2)
-    irb (1.17.0)
-      pp (>= 0.6.0)
-      prism (>= 1.3.0)
-      rdoc (>= 4.0.0)
-      reline (>= 0.4.2)
-    mini_portile2 (2.8.9)
-    pp (0.6.3)
-      prettyprint
-    prettyprint (0.2.0)
-    prism (1.9.0)
-    psych (5.3.1)
-      date
-      stringio
-    rdoc (7.2.0)
-      erb
-      psych (>= 4.0.0)
-      tsort
-    reline (0.6.3)
-      io-console (~> 0.5)
-    rspec (3.13.2)
-      rspec-core (~> 3.13.0)
-      rspec-expectations (~> 3.13.0)
-      rspec-mocks (~> 3.13.0)
-    rspec-core (3.13.6)
-      rspec-support (~> 3.13.0)
-    rspec-debugging (0.0.4)
-      rspec-expectations (>= 3)
-    rspec-expectations (3.13.5)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.13.0)
-    rspec-mocks (3.13.8)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.13.0)
-    rspec-support (3.13.7)
-    simplecov (0.22.0)
-      docile (~> 1.1)
-      simplecov-html (~> 0.11)
-      simplecov_json_formatter (~> 0.1)
-    simplecov-html (0.13.2)
-    simplecov_json_formatter (0.1.4)
-    sqlite3 (2.9.5)
-      mini_portile2 (~> 2.8.0)
-    stringio (3.2.0)
-    tsort (0.2.0)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  debug (>= 1)
-  iriq!
-  rspec (>= 3.10)
-  rspec-debugging
-  simplecov (>= 0.22)
-  sqlite3 (>= 1.6)
-
-CHECKSUMS
-  date (3.5.1) sha256=750d06384d7b9c15d562c76291407d89e368dda4d4fff957eb94962d325a0dc0
-  debug (1.11.1) sha256=2e0b0ac6119f2207a6f8ac7d4a73ca8eb4e440f64da0a3136c30343146e952b6
-  diff-lcs (1.6.2) sha256=9ae0d2cba7d4df3075fe8cd8602a8604993efc0dfa934cff568969efb1909962
-  docile (1.4.1) sha256=96159be799bfa73cdb721b840e9802126e4e03dfc26863db73647204c727f21e
-  erb (6.0.4) sha256=38e3803694be357fe2bfe312487c74beaf9fb4e5beb3e22498952fe1645b95d9
-  io-console (0.8.2) sha256=d6e3ae7a7cc7574f4b8893b4fca2162e57a825b223a177b7afa236c5ef9814cc
-  irb (1.17.0) sha256=168c4ddb93d8a361a045c41d92b2952c7a118fa73f23fe14e55609eb7a863aae
-  iriq (0.30.2)
-  mini_portile2 (2.8.9) sha256=0cd7c7f824e010c072e33f68bc02d85a00aeb6fce05bb4819c03dfd3c140c289
-  pp (0.6.3) sha256=2951d514450b93ccfeb1df7d021cae0da16e0a7f95ee1e2273719669d0ab9df6
-  prettyprint (0.2.0) sha256=2bc9e15581a94742064a3cc8b0fb9d45aae3d03a1baa6ef80922627a0766f193
-  prism (1.9.0) sha256=7b530c6a9f92c24300014919c9dcbc055bf4cdf51ec30aed099b06cd6674ef85
-  psych (5.3.1) sha256=eb7a57cef10c9d70173ff74e739d843ac3b2c019a003de48447b2963d81b1974
-  rdoc (7.2.0) sha256=8650f76cd4009c3b54955eb5d7e3a075c60a57276766ebf36f9085e8c9f23192
-  reline (0.6.3) sha256=1198b04973565b36ec0f11542ab3f5cfeeec34823f4e54cebde90968092b1835
-  rspec (3.13.2) sha256=206284a08ad798e61f86d7ca3e376718d52c0bc944626b2349266f239f820587
-  rspec-core (3.13.6) sha256=a8823c6411667b60a8bca135364351dda34cd55e44ff94c4be4633b37d828b2d
-  rspec-debugging (0.0.4) sha256=7a8e2dc240c140f0ed27b452a5661a56474ee8cf7b84c5bcbefd827ad36f0a6f
-  rspec-expectations (3.13.5) sha256=33a4d3a1d95060aea4c94e9f237030a8f9eae5615e9bd85718fe3a09e4b58836
-  rspec-mocks (3.13.8) sha256=086ad3d3d17533f4237643de0b5c42f04b66348c28bf6b9c2d3f4a3b01af1d47
-  rspec-support (3.13.7) sha256=0640e5570872aafefd79867901deeeeb40b0c9875a36b983d85f54fb7381c47c
-  simplecov (0.22.0) sha256=fe2622c7834ff23b98066bb0a854284b2729a569ac659f82621fc22ef36213a5
-  simplecov-html (0.13.2) sha256=bd0b8e54e7c2d7685927e8d6286466359b6f16b18cb0df47b508e8d73c777246
-  simplecov_json_formatter (0.1.4) sha256=529418fbe8de1713ac2b2d612aa3daa56d316975d307244399fa4838c601b428
-  sqlite3 (2.9.5) sha256=04572973a3f943ad50a8adfffc8dd752a5f06e4c3db2026f71838fed8a982606
-  stringio (3.2.0) sha256=c37cb2e58b4ffbd33fe5cd948c05934af997b36e0b6ca6fdf43afa234cf222e1
-  tsort (0.2.0) sha256=9650a793f6859a43b6641671278f79cfead60ac714148aabe4e3f0060480089f
-
-BUNDLED WITH
-  4.0.9

data/Makefile

@@ -1,113 +0,0 @@
-# Iriq Go binary — build/install/clean/uninstall helpers.
-#
-#   make                   - same as `make help`
-#   make build             - dev build into ./bin/iriq (no SQLite, debug info)
-#   make build-sqlite      - dev build with SQLite backend included
-#   make release           - stripped + trimpath build (no SQLite)
-#   make release-sqlite    - stripped + trimpath build with SQLite
-#   make install           - go install into $GOBIN
-#   make test              - go test ./... (both tag states)
-#   make clean             - remove ./bin/
-#   make uninstall         - remove the binary from $GOBIN
-#
-# The default build excludes the SQLite backend to keep the binary lean.
-# Pass `-tags sqlite` (or use the *-sqlite targets) to compile it in. The
-# CLI's `--version` output tells you which backends are baked in.
-#
-# Ruby gem build/install is handled by Bundler/RubyGems; see CLAUDE.md.
-
-GO          ?= go
-GO_DIR      := go
-BIN_DIR     := bin
-BIN         := $(BIN_DIR)/iriq
-# Absolute output path: builds run inside $(GO_DIR) via `go -C`, so a
-# relative -o would land under go/. Keep the binary at the repo-root bin/.
-ABS_BIN     := $(CURDIR)/$(BIN)
-PKG         := ./cmd/iriq
-
-# Rust crate lives under rust/; CI gates fmt + clippy + tests there.
-CARGO       ?= cargo
-RUST_DIR    := rust
-
-# Release flags strip the symbol table (-s), debug info (-w), and bake
-# reproducible paths (-trimpath). Drops binary size ~30% with no
-# functional impact; stack-trace function names are gone but file:line
-# resolution still works.
-RELEASE_FLAGS := -ldflags "-s -w" -trimpath
-
-# Resolve $GOBIN, falling back to $GOPATH/bin (Go's default install location).
-GOBIN       := $(shell $(GO) env GOBIN)
-ifeq ($(GOBIN),)
-GOBIN       := $(shell $(GO) env GOPATH)/bin
-endif
-INSTALLED   := $(GOBIN)/iriq
-
-.DEFAULT_GOAL := help
-.PHONY: help build build-sqlite release release-sqlite install test clean uninstall check fmt hooks
-
-help:
-	@echo "Iriq Go targets:"
-	@echo "  make build            slim dev build into $(BIN)"
-	@echo "  make build-sqlite     dev build with SQLite backend"
-	@echo "  make release          stripped slim build into $(BIN)"
-	@echo "  make release-sqlite   stripped build with SQLite backend"
-	@echo "  make install          go install into $(GOBIN)"
-	@echo "  make test             run go test ./... in both tag states"
-	@echo "  make check            Rust gate: cargo fmt --check + clippy + test (run before merging)"
-	@echo "  make fmt              cargo fmt the Rust crate"
-	@echo "  make hooks            enable the committed git hooks (pre-push runs 'make check')"
-	@echo "  make clean            remove $(BIN_DIR)/"
-	@echo "  make uninstall        remove $(INSTALLED)"
-
-build:
-	@mkdir -p $(BIN_DIR)
-	$(GO) -C $(GO_DIR) build -o $(ABS_BIN) $(PKG)
-	@echo "built $(BIN) (slim, debug)"
-
-build-sqlite:
-	@mkdir -p $(BIN_DIR)
-	$(GO) -C $(GO_DIR) build -tags sqlite -o $(ABS_BIN) $(PKG)
-	@echo "built $(BIN) (sqlite, debug)"
-
-release:
-	@mkdir -p $(BIN_DIR)
-	$(GO) -C $(GO_DIR) build $(RELEASE_FLAGS) -o $(ABS_BIN) $(PKG)
-	@echo "built $(BIN) (slim, stripped)"
-
-release-sqlite:
-	@mkdir -p $(BIN_DIR)
-	$(GO) -C $(GO_DIR) build -tags sqlite $(RELEASE_FLAGS) -o $(ABS_BIN) $(PKG)
-	@echo "built $(BIN) (sqlite, stripped)"
-
-install:
-	$(GO) -C $(GO_DIR) install $(PKG)
-	@echo "installed $(INSTALLED)"
-
-test:
-	$(GO) -C $(GO_DIR) test ./...
-	$(GO) -C $(GO_DIR) test -tags sqlite ./...
-
-# The Rust gate — mirrors CI's Rust job. Run before merging/pushing (the
-# pre-push hook runs this for you once `make hooks` is enabled).
-check:
-	cd $(RUST_DIR) && $(CARGO) fmt --check
-	cd $(RUST_DIR) && $(CARGO) clippy --workspace --all-targets -- -D warnings
-	cd $(RUST_DIR) && $(CARGO) test --workspace
-
-fmt:
-	cd $(RUST_DIR) && $(CARGO) fmt
-
-hooks:
-	git config core.hooksPath .githooks
-	@echo "git hooks enabled (.githooks) — pre-push now runs 'make check'"
-
-clean:
-	rm -rf $(BIN_DIR)
-	@echo "removed $(BIN_DIR)/"
-
-uninstall:
-	@if [ -f "$(INSTALLED)" ]; then \
-		rm "$(INSTALLED)" && echo "removed $(INSTALLED)"; \
-	else \
-		echo "not installed at $(INSTALLED)"; \
-	fi