…ave 2 wave-2 PR 2) (#230)

Tap every successful `BatchCheckAdapter::batch_describe_schema` result in
`rocky run` into the persisted schema cache shipped in #223 and wired for
reads in #228. Downstream compiles (and the LSP's per-keystroke typecheck)
can now resolve leaf `FROM <schema>.<table>` references against real
warehouse types without a round-trip on every call.

Scope:
- New `rocky-cli::schema_cache_writer` module with
  `persist_batch_describe(store, config, tap, catalog, schema, cols_by_table)`.
  One entry per returned table — the DESCRIBE cost is already paid, so
  sibling tables in the same source schema join the cache too.
- Gate on `[cache.schemas] enabled` (default true, per design doc §4.3).
  Cache-write failures log `warn!` and never fail the run; the helper
  returns `()` so the best-effort contract is enforced at the type level.
- Dedup within one run via `SchemaCacheWriteTap::seen` (a `HashSet` over
  `schema_cache_key`). Databricks already deduplicates at the
  `(catalog, schema)` pair level, but the tighter guarantee keeps the
  invariant local for PR 3's `rocky discover --with-schemas`.
- Writes the map returned by `batch_describe_schema` for both source and
  target schema directions — distinct keys, free signal for models that
  read from a sibling's target.

Deliberate non-scope:
- Per-table `warehouse.describe_table(...)` fallback inside `process_table`
  stays untapped for now. That path only fires when (a) the warehouse has
  no `BatchCheckAdapter` (DuckDB — not a wave-2 cache target, no warehouse
  schemas to cache) or (b) the batch call failed (rare; adding a lock-held
  write inside a concurrent task-spawn contends with the rest of the run
  for dubious cache benefit). Can be a follow-up if demand appears.
- `rocky discover --with-schemas` (PR 3, parallel fan-out).
- `rocky state clear-schema-cache` and `--cache-ttl` override (PR 4).
- The `state_path` CLI/LSP divergence. CLI default is
  `.rocky-state.redb` (CWD); LSP default is `models_dir.join(...)`. Fixing
  this requires a migration story for existing users' CWD state files
  with watermarks and run history; scoped out of PR 2 and tracked as a
  follow-up. PR 1b's commit message already flagged it.

Tests (7 new):
- `writes_entry_when_enabled` — happy-path write + readback.
- `writes_nothing_when_disabled` — config gate short-circuits before redb.
- `dedups_repeated_key_within_one_run` — second call with same key is
  suppressed (evidence: differing column list has no effect).
- `writes_all_tables_in_batch_not_just_selected` — full-schema write.
- `distinct_catalogs_do_not_collide` — key composition includes catalog.
- `round_trip_through_reader` — writer + PR 1b reader contract stays
  consistent; key shape and column conversion survive the round-trip.
- `signature_does_not_propagate_errors` — compile-time pin on the `()`
  return type; the best-effort contract can't be accidentally changed
  without a test failure.

Verification:
- `cargo test -p rocky-cli` — 220 prior + 7 new = 227 tests green.
- `cargo test --workspace` — full suite green.
- `cargo clippy -p rocky-cli --all-targets -- -D warnings` clean.
- `cargo fmt --all --check` clean.
- Playground smoke: `rocky run` against the default POC stays green
  (DuckDB has no `BatchCheckAdapter`, so the tap branch is never entered).

Design doc: `~/Developer/rocky-plans/plans/rocky-arc7-wave2-wave2-design.md`
(§4.2 write path, §4.5 JSON serialization, §4.6 ColumnInfo conversion).
Infra dependencies: #223 (PR 1a — schema cache types + state CRUD) and
#228 (PR 1b — read-path wiring). PR 2 closes the write end.

… 2 wave-2 PR 3) (#231)

Explicit warm-up path for the Arc 7 wave 2 wave-2 schema cache (design
doc §4.2 route B). When `--with-schemas` is set, `rocky discover` walks
each unique `(catalog, schema)` pair reachable via the source's
`BatchCheckAdapter`, issues one `batch_describe_schema` round-trip, and
persists every returned table as a `SchemaCacheEntry` via
`StateStore::write_schema_cache_entry` (the infra PR 1a shipped in
#223). Downstream `rocky compile` / `rocky lsp` invocations pick up
those entries via the read path wired in #228 (PR 1b), so leaf models
that reference the cached source stop typechecking as `Unknown`.

What the flag does NOT do:

- Does not touch the `rocky run` write tap (PR 2, parallel agent).
- Does not add `clear-schema-cache` or a CLI TTL override (PR 4).
- Does not alter the read path, the cache-entry format, or the
  `state_path` resolution.

Error handling (design doc §4.2 + trust positioning):

- `--with-schemas` + `[cache.schemas] enabled = false` in rocky.toml
  → hard error with an actionable message. The two signals are
  contradictory; silently skipping would leave the user guessing why
  `schemas_cached=0`. Erroring keeps the user's mental model aligned
  with what the cache actually does.
- Missing `source.catalog` → warn once, skip writes (cannot key
  entries without a catalog).
- `BatchCheckAdapter` not registered for the source adapter (DuckDB
  today) → warn once, skip writes.
- Per-schema `batch_describe_schema` failure → warn and continue.
- Per-entry `write_schema_cache_entry` failure → warn and continue.

DiscoverOutput schema change:

- New `schemas_cached: usize` field (skipped from the wire format
  when zero — fixtures captured without the flag stay byte-stable).
  Full codegen cascade run: `schemas/discover.schema.json`,
  `integrations/dagster/.../types_generated/discover_schema.py`, and
  `editors/vscode/src/types/generated/discover.ts` all regenerated.

Tests:

- 5 new unit tests (`discover::tests`) covering the dedup helper and
  the inner warm-up loop against a stub `BatchCheckAdapter`: writes
  one entry per table, continues past describe failures, handles the
  empty schema list, and lowercases key components. DuckDB adapter
  has no `BatchCheckAdapter` so playground integration tests hit the
  warn-and-skip path; the stub gives meaningful assertions for the
  happy path that would otherwise require a live warehouse.

Test plan:

- `cargo test -p rocky-cli -p rocky-core` — 1236 tests green.
- `cargo clippy --all-targets -- -D warnings` — clean on full
  workspace.
- `cargo fmt --all --check` — clean.
- `just codegen` — schemas regenerated, only the expected
  `schemas_cached` node added to `discover`.
- `uv run pytest` in `integrations/dagster/` — 370 tests green after
  Pydantic regeneration.
- `npm run compile` in `editors/vscode/` — clean.
- `scripts/regen_fixtures.sh` — fixtures byte-stable (field skipped
  when zero).
- Smoke-tested against the 00-playground-default POC: discover
  without the flag returns the same JSON as before (no
  `schemas_cached` field); discover with `--with-schemas` warns
  about the missing DuckDB `BatchCheckAdapter` and returns the same
  JSON (no entries written, `schemas_cached=0` elided); discover
  with `enabled = false` + `--with-schemas` errors cleanly.

…(Arc 7 PR 4) (#232)

* feat(engine/rocky-cli): add rocky state clear-schema-cache + --cache-ttl override (PR 4)

Arc 7 wave 2 wave-2 PR 4 — user-facing control surface for the schema cache:

- `rocky state clear-schema-cache [--dry-run]` — explicit flush of the
  SCHEMA_CACHE redb table. Missing state store treated as no-op (CI-friendly:
  safe to run on an ephemeral runner before a build).
- `--cache-ttl <seconds>` global CLI flag — overrides `[cache.schemas]
  ttl_seconds` for this invocation. Precedence: `--cache-ttl` > `rocky.toml`
  > built-in default (86400s / 24h). Applies to CLI read paths; the
  `rocky lsp` / `rocky serve` daemons keep the config-derived TTL.
- `rocky state` becomes a subcommand group; bare `rocky state` preserved
  via `Option<StateAction>` defaulting to `Show`.

Completes the Arc 7 wave 2 wave-2 sequence (PR 1a #223 infra, PR 1b #228
reads, PR 2 #230 write tap, PR 3 #231 discover warm-up, PR 4 user controls).

* docs(engine/rocky-cli): strip task references from ClearSchemaCacheOutput doc

The doc comment on the output struct flows into schemas/*.schema.json,
dagster Pydantic docstrings, and vscode TypeScript jsdoc. Keep the
behavioral description; drop the 'Arc 7 wave 2 wave-2 PR 4 / PR 2 / PR 1b'
references per monorepo CLAUDE.md (task refs in code rot over time).

* docs(engine): add CHANGELOG entries for rocky state clear-schema-cache + --cache-ttl

* fix(integrations/dagster): sort ClearSchemaCacheOutput in types.py import block

Ruff I001 was tripping on the import block order in types.py; the
original PR 4 agent inserted ClearSchemaCacheOutput between SourceOutput
and StateOutput instead of between CiOutput and ColumnLineageOutput.

* chore: release engine-v1.14.0 + dagster-v1.10.0 + vscode-v1.6.4

Bumps all three artifacts to cover the 16-PR cascade since engine-v1.13.0
/ dagster-v1.9.0 / vscode-v1.6.3. Details in each CHANGELOG.

Engine headlines (12 PRs):
- Arc 7 wave 2 wave-2 complete — cached DESCRIBE end-to-end
  (#223 infra, #228 reads, #230 write tap, #231 discover warm-up,
  #232 state controls + --cache-ttl override)
- Arc 2 wave 3 complete — bytes_scanned / bytes_written on
  MaterializationOutput (#219 BQ, #221 Databricks, #220 Snowflake
  deferred doc, #222 docstring cascade). Real $ on rocky cost for
  BQ + Databricks
- FR-005 Unity Catalog workspace-binding reconcile (#226)
- FR-002 Fivetran connector metadata via SourceOutput.metadata (#225)
- Housekeeping: compute_backoff dedup into rocky_core::retry (#217)

Dagster headlines (4 PRs):
- FR-001 RockyComponent Pipes execution mode + FR-006 strict doctor
  on RockyResource startup (#224)
- FR-003 RockyResource.state_health() (#227) + FR follow-up threading
  doctor(check=state_rw) for sub-second probes (#229)
- RockyResource.cost() wiring + fixture (#218)

VS Code: regenerated TS bindings for engine 1.14.0 type additions.
No extension feature changes.

* chore(integrations/dagster): regenerate test fixtures for engine 1.14.0

36 fixtures picked up the new engine version string in their top-level
"version" field. No schema changes — just the version bump.

* feat(engine): unify CLI + LSP state_path resolution

The CLI default state_path (`.rocky-state.redb` in CWD) and the LSP /
server default (`<models>/.rocky-state.redb`) diverged after Arc 7 wave
2 wave-2. The schema-cache write tap (PR #230) persisted entries to
CWD, while the LSP read-path (PR #228) looked next to the models
directory — so inlay-hint cache-hits never fired end-to-end for any
project where the two locations weren't already co-located.

Add `rocky_core::state::resolve_state_path(explicit, models_dir)` as
the single resolution point for both halves of the binary:

1. Explicit `--state-path` wins verbatim.
2. `<models>/.rocky-state.redb` exists — use it (canonical default).
3. CWD `.rocky-state.redb` exists — use it with a one-time
   deprecation warning on stderr (legacy fallback; protects existing
   watermarks, branches, partitions, run history).
4. Both exist — CWD wins (preserves legacy state) with a louder
   warning asking the user to reconcile. Merge is lossy.
5. Neither exists (fresh project) — default to
   `<models>/.rocky-state.redb`, no warning.

Wire the helper through main.rs (single top-level resolution),
commands/watch.rs, and all four rocky-server callsites (state.rs,
lsp.rs, api.rs, dashboard.rs). Passing `--state-path` explicitly
remains a hard override, so the Dagster integration — which always
passes an explicit path — is unchanged.

Five resolver unit tests cover every branch (explicit / models-dir /
CWD-fallback / both-exist / fresh). Smoke-tested end-to-end against
the release binary: the warning lands on stderr; the models-dir case
is silent; the both-exist case emits the louder warning.

* fix(engine/rocky-core): fall back to CWD when models dir is missing

Case 5 of `resolve_state_path` returned `<models>/.rocky-state.redb`
unconditionally on fresh projects. For replication-only and
quality-only pipelines (and several POCs, e.g.
`02-performance/06-schema-drift-recover`) there is no `models/`
directory at all, so the next `rocky run` failed trying to open
the state lock file at a path whose parent doesn't exist:

    Error: failed to open state store at models/.rocky-state.redb
      i/o error opening state lock file at models/.rocky-state.redb.lock:
      No such file or directory (os error 2)

That crash surfaced as a `just regen-fixtures` normalizer failure
in the codegen-drift CI workflow for PR #238 — the `drift/run_clean`
capture emitted empty stdout and the JSON normalizer then errored on
`Expecting value: line 1 column 1 (char 0)`.

Refine the resolver to check `models_dir.is_dir()`:

- Case 5 (fresh project): default to `<models>/.rocky-state.redb`
  only when `models_dir` exists; otherwise fall back to CWD.
- Case 3 (legacy CWD state): emit the migration-nudge warning only
  when `models_dir` is a real directory. Without one there's
  nowhere to move the file to, so the warning would be noise.

The LSP only attaches to projects with `.rocky` files (i.e.
projects that have a models dir by definition), so the no-models
fallback path has no CLI-vs-LSP divergence to unify.

Two new unit tests pin the behaviour — fresh-project-without-models
and CWD-state-without-models. Verified locally: the drift POC run
now emits valid JSON, and `just regen-fixtures` completes with
zero drift against the committed `fixtures_generated/`.