Story: Consolidate standalone scripts into compass

Make compass the single, documented entry point for operating and developing ORE Studio, folding the ~61 standalone shell and Python scripts into compass subcommands organised by pillar. Today the operational surface is a sprawl of scripts across build/scripts/, projects/ores.sql/, projects/ores.codegen/, and elsewhere; each reimplements .env sourcing, preset resolution, and path plumbing, and they drift independently (the regroup broke one by changing the directory layout it globbed). A contributor should run compass <pillar> <verb> rather than memorising script paths.

This story supersedes and absorbs the service-registry consolidation task discovered during the regroup — that becomes one concrete migration within this larger effort.

61 operational/dev scripts, by category:

Most .sh scripts already share a .env-sourcing + ORES_PRESET idiom (set -a; source .env; set +a), which is exactly the plumbing compass already does once in Python.

Compass is self-contained Python (projects/ores.compass/src/compass.py) organised into five pillars — all of which serve the information architecture, not system operation:

Subcommands are registered in compass.py via a two-tier dispatch: top-level commands with sub-subcommands are short-circuited before argparse and handled by a cmd_<name>(argv) function with its own nested ArgumentParser. Adding a pillar = add a cmd_<pillar>() handler + an _EPILOG section + a short-circuit dispatch entry. Compass shells out only for git=/=gh; everything else is native Python.

The existing five pillars cover navigating the project. The scripts cover running the project — a distinct concern that warrants new operational pillars. Candidate mapping (illustrative, not final):

Open questions for the design task: pillar names and boundaries; whether codegen folds in or stays a delegated tool (compass add already delegates to it); whether scripts become thin shims that call compass (backward-compat) or are deleted; how CI workflows that call the scripts migrate; the single service registry's home (projects/services.json).

• The operational-pillar taxonomy — every operational script mapped to a compass pillar + verb, with backward-compatibility and CI-migration decisions — is settled in the design task and distilled into this story's * Decisions (kept inline, not in doc/plans/).
• The operational pillars are implemented in compass and documented in --help and the compass recipes/knowledge docs.
• Migrated scripts are removed (hard cutover) with every caller — CI workflows, the ores.lisp dashboard, recipes, docs — updated to call the compass verb. No shims, no dangling references.
• The service registry is consolidated to a single source (absorbs the prior task); init-environment functionality runs under compass.
• cmake --build + ctest and a full provision → run round-trip pass.

From the taxonomy design task (T1):

• Four operational pillars: Provision (env/db/nats setup), Operate (services lifecycle, client, logs), Build (compile, site), Generate (codegen delegation) — alongside the five info-architecture pillars.
• Noun-first grammar: compass db recreate, compass services start, matching the existing compass sprint status / compass story new.
• Hard cutover: migrated scripts are deleted and all callers (CI, dashboard, recipes, docs) updated; no compatibility shims.
• Codegen stays its own CLI: the Generate pillar adds thin compass gen verbs that delegate to ores.codegen; the 18 codegen scripts are not absorbed wholesale.
• Logs belong to services: compass services start --delete-logs for the clean-run case (clears while down → no stale inodes), plus a standalone compass services clear-logs. No separate logs noun.
• Shared plumbing: one compass-side helper resolves .env + ORES_PRESET + build/output/<preset> once, replacing the per-script set -a; source .env; set +a idiom. Single service registry source: projects/services.json.
• Not migrated (out of scope): PR/CI tooling (pr_watch, ci_health, append_pr_to_backlog), release tooling, set_ssh_agent.sh (since deleted — compass self-heals the agent socket; was: must be sourced), and ores.codegen's own scripts.

The full script → pillar → verb mapping lives in the T1 design task.

• Rewriting the codegen engine itself (ores.codegen); at most its wrapper scripts become compass verbs that delegate to it.
• Changing what any script does — this is a relocation/consolidation onto a single CLI, not a behaviour change.
• The component regroup (done) and the org-mode model migration (separate story).

• Compass CLI UX redesign — established the pillar model and the taxonomy-design-doc-first approach this story follows.
• Regroup C++ components under product-group parent directories — where the script-fragility (and the absorbed registry task) surfaced.