internal/

Package blocks defines the step-block executor contract shared by every rehearse block kind (bash, hurl, sql, dtql, graphql) plus the registry the runner dispatches through.

Package bash implements the ```bash rehearse step block: the block body runs via `bash -euo pipefail` in the scenario's working directory; a non-zero exit fails the step (REQ: bash-block).

Package directives parses the trailing directive comments shared by the data-oriented rehearse blocks (`sql`, `dtql`): `-- assert-rows: <N>`, `-- assert-row-json: {...}` and `-- capture: <name> = <column>` (REQ: sql-block, REQ: dtql-block, REQ: context-bag), and applies the parsed assertions/captures to a query's result rows.

Package dtqlblock implements the ```dtql rehearse step block: the block body is a DTQL query document (deserialized by dalgo's dtql package) executed against the SQLite store at `db=<path>` via the dalgo SQLite adapter (dalgo2sqlite), with the same trailing `-- assert-rows:` / `-- assert-row-json:` / `-- capture:` directives as the sql block (REQ: dtql-block).

Package fileblock implements evaluation of file assertions parsed from rehearse scenario `### Assert: file` headings.

Package graphql implements the ```graphql rehearse step block: a GraphQL query with `url=<endpoint>` in the info string, an optional `-- variables: {...}` directive, plus `-- assert-jsonpath: <path> == <json-value>` and `-- capture-jsonpath: <name> = <path>` directives.

Package hurl implements the ```hurl rehearse step block: the block body is verbatim Hurl syntax delegated to the `hurl` binary in test mode — the runner does NOT implement an HTTP client (REQ: hurl-block).

Package sqlblock implements the ```sql rehearse step block: the block's statement(s) run against the DSN from the info string (v0.3 driver: `sqlite:<path>` via the pure-Go driver already in go.mod), with trailing `-- assert-rows:` / `-- assert-row-json:` / `-- capture:` directives checked against the final statement's result rows (REQ: sql-block).

Package runner discovers rehearse scenario files, executes their step blocks through the block-executor registry, and renders the run report (REQ: scenario-discovery, REQ: scenario-shape, REQ: run-report).

Package scaffold resolves AC references, extracts Given/When/Then text, and generates scaffold scenario files for the rehearse new command.

Package scenario parses markdown rehearse scenario files: body metadata (`**Verifies:**` / `**Status:**`) and fenced step blocks with info-string params (REQ: scenario-shape).

Package adapters defines the ingestion-adapter contract for SpecScore Studio, the registry of built-in adapters, and the pipeline that runs every adapter over every resolved workspace repo and stamps the shared fact fields centrally.

Package codegraph is the CodeGrapher-snapshot ingestion adapter: it reads committed `codegraph/` snapshot recordsets (INGR encoding, inGitDB layout) and emits package entities and `derived` facts for `imports` edges at package granularity.

Package manifests is the dependency-manifest ingestion adapter: it parses `go.mod` and `package.json` files at the repo root plus one nested level (e.g.

Package registries is the ops-registry ingestion adapter: it parses well-known ops registry files — `domains.json` (Sneat-ops shape) and curated `ecosystem*.yaml` maps — into domain/product entities and `declared` facts.

Package rehearse is the rehearse-report ingestion adapter: it reads `.specscore/rehearse/latest.json` from the repo and emits `verified-behavior` facts — one `verified-by` and one `has-verification-status` pair for every scenario–AC combination whose status is `pass` or `fail`.

Package specscore is the SpecScore spec-tree ingestion adapter: it parses `spec/` trees of repos managed by SpecScore (marked by a `specscore.yaml` at the repo root) into idea/feature entities and `declared` facts.

Package ask is SpecScore Studio's deterministic question router — the engine behind `specscore studio ask "<question>"`.

Package contradictions computes SpecScore Studio's contradiction detectors as pure functions over the facts a `studio index`/`studio probe` run wrote into the fact store.

Package fact defines the SpecScore Studio fact model — the single record shape every ingestion adapter emits and the fact store persists — plus the stable-ID helpers used to mint entity references.

Package ingr writes SpecScore Studio facts as INGR recordsets — the same fixed-header/one-JSON-value-per-line encoding the CodeGrapher snapshots committed under codegraph/ use (and the codegraph adapter parses).

Package probe runs live checks against the ecosystem and produces `verified-behavior` facts that merge into the same fact store `studio index` builds.

Package repoid resolves stable Studio repository entity IDs.

Package resolve maps a brand, domain, repo slug, package, or product name to its canonical entity id by querying the fact store facts in memory.

Package store persists SpecScore Studio facts in a single-file SQLite database (pure-Go driver, house precedent) and answers the filter queries behind `specscore studio facts`.

Package workspace loads and resolves SpecScore Studio workspace files (studio.yaml): an ecosystem name plus a list of repo entries — directory paths or glob patterns, absolute or workspace-relative, each optionally carrying a per-repo `registries:` file list for the registries adapter.