theurian 0.1.0.dev7__tar.gz → 0.1.0.dev9__tar.gz

{theurian-0.1.0.dev7 → theurian-0.1.0.dev9}/.gitignore

@@ -19,17 +19,6 @@ dist/
 coverage.xml
 htmlcov/
 
-# --- Theurian derived artifacts -------------------------------------------
-# Canonical state is rebuilt from Git-tracked migrations and content.
-# Never commit any of these. See docs/adr/0004-sqlite-is-a-derived-artifact.md
-.theurian/state/
-.theurian/cache/
-.theurian/runtime/
-.theurian/generated/
-*.sqlite
-*.sqlite-wal
-*.sqlite-shm
-
 # --- Documentation site (derived) ---
 # `mkdocs build` writes site/. The Pages workflow copies the logo into
 # docs/assets/ before building, so anyone replicating that build locally
@@ -58,3 +47,14 @@ htmlcov/
 .env.*
 !.env.example
 *.token
+
+# >>> theurian >>>
+# Derived artifacts. Rebuilt from Git-tracked migrations (ADR-0004).
+.theurian/state/
+.theurian/cache/
+.theurian/runtime/
+.theurian/generated/
+*.sqlite
+*.sqlite-wal
+*.sqlite-shm
+# <<< theurian <<<

{theurian-0.1.0.dev7 → theurian-0.1.0.dev9}/CHANGELOG.md

@@ -12,6 +12,361 @@ Pre-1.0, a MINOR bump may change the protocol. Post-1.0, only a MAJOR may.
 
 ## [Unreleased]
 
+## [0.1.0.dev9] - 2026-08-22
+
+### Fixed
+
+- **`propose accept` translates every accept-path filesystem or path fault into
+  an `{error, remedy}` document instead of escaping a raw traceback**
+  ([#227](https://github.com/theurian/theurian/issues/227)). A proposal directory
+  this process cannot list, stat or read; a migration file it cannot open; a
+  `contentFile` whose path `resolve()` refuses (a NUL byte or an unpaired
+  surrogate); an unwritable `.theurian/migrations/` — each used to leave `accept`
+  as a bare `OSError`/`ValueError`, so `--json` published nothing where it
+  promises a document. (An unreadable `evidence.json` is not in this set: it was
+  already translated to an indeterminate document in 0.1.0.dev8,
+  [#253](https://github.com/theurian/theurian/issues/253).) Each is now a `ProposalError` naming the offending path
+  relative to the project root — never the absolute path, which is the machine's
+  home directory (SEC-7) — whose remedy sends the reader to
+  `.theurian/migrations/` before re-drafting: a refused read establishes nothing
+  about whether the migration landed, and re-drafting an accepted proposal mints a
+  duplicate migration (#89). A move that landed but whose trailing cleanup of the
+  proposal's own copied files could not run (a read-only `0o555` proposal
+  directory) now degrades to success with a `remedy` naming the leftover, rather
+  than reporting a non-landing that would send the caller to re-draft.
+- **`propose accept`'s replacement guard reads the loaded migration set and keys
+  on the body's filesystem identity, closing a disagreement with the loader**
+  ([#234](https://github.com/theurian/theurian/issues/234)). The guard that
+  refuses a body replacement which would leave the migration set unable to
+  validate used to enumerate `.theurian/migrations/*.yaml` itself and skip the
+  symlinked entries the loader follows, so a pin held by a relocated (symlinked)
+  migration was invisible to it: the replacement was allowed, and the set then
+  stopped loading at exit 4 with no undo. It now reads the same `MigrationSet` the
+  loader produced, and compares on the body's `(st_dev, st_ino)` rather than a
+  path string.
+
+  **Behaviour change:** `accept` now refuses four inputs it previously let
+  through, each of which then broke the loaded set at exit 4:
+
+  - a *different* revision replacing an **unpinned** landed body — the old guard
+    filtered on the pin and waved this through, yet the set then holds two
+    revisions on one physical file (`refuse_duplicate_content_files`, exit 4);
+  - a byte-identical replacement of a **pinned** landed body under a *different*
+    revision id — the old guard treated "byte-identical changes nothing" as true
+    of the *set*, but it is the same two-revisions-on-one-file break;
+  - a **hardlink** to a landed body — the identity key `(st_dev, st_ino)` reaches
+    the same inode by every alias, where the old path-string compare saw none;
+  - a **case variant** of a landed body's path (`RETRY-POLICY.md` against a landed
+    `retry-policy.md`) — likewise one inode by every spelling. A Unicode
+    normalisation variant reaches it the same way, though no test exercises that
+    face.
+
+  The one in-place re-declare `accept` still allows — this proposal's own revision
+  re-declared byte-for-byte **on the same item**, the in-place status change of
+  ADR-0024 decision 5 — is an explicit conjunction of equal item id, revision id
+  and bytes. A byte-*different* re-declare of a *pinned* landed revision was
+  already refused before this branch and is unchanged. There are no users yet, but
+  the refusals change what `accept` exits on, so they are named here.
+- **`propose accept` refuses a cross-item re-declare of a landed revision id**
+  (round-one review finding). The replacement-guard skip that admits the one
+  legitimate in-place re-declare (ADR-0024 decision 5) fired on two conjuncts —
+  equal revision id and equal bytes — so a byte-identical body re-declared under a
+  *different* item's id passed it. `accept` returned 0, and `migrate validate`
+  passed too (it does not check cross-item revision ownership); then `migrate
+  apply` refused the whole set at exit 4 ("a revision id belongs to one item",
+  INV-1/SEC-13) after the pull request had merged and the proposal was already
+  consumed, with no undo. The skip now carries the item id as a third conjunct
+  (item id, revision id, bytes), moving that refusal to the accept door. No
+  rejected-item content is disclosed either way — `store.py` refuses a cross-item
+  revision-id reuse before it reads content (SEC-13) — so this spares the operator
+  a consumed proposal; it does not add a disclosure control.
+- **`propose accept` refuses a migration whose id the loaded set already holds
+  under another filename** (round-one review finding). The "already in place"
+  refusal keyed only on the destination filename (`<id>-<slug>.yaml`), but the
+  loader keys migrations by their *inner* `id`. A hand-authored proposal named
+  `<landed-id>-other-slug.yaml` carrying `id: <landed-id>` collided on the inner
+  id while its filename was free: the name check waved it through, the
+  filename/id agreement check was satisfied (the prefix equals the id), and
+  `accept` landed a *duplicate* migration id, on which `migrate
+  validate`/`status`/`apply` then all exit 4. The refusal now also answers the id
+  against the same loaded migration set the loader, `migrate validate` and
+  `migrate apply` read (#234/#253/#254). This is the third and last accept-path
+  procedure moved off a filesystem enumeration and onto the loaded set; no method
+  on the accept path enumerates `.theurian/migrations/` any more.
+- **The accept-path read-failure remedy is chosen by `errno`, not a blanket
+  `chmod`** (round-one review finding, extending
+  [#227](https://github.com/theurian/theurian/issues/227)). The remedy prescribed
+  "Make _path_ readable — chmod u+rX on it" for every accept-path read failure —
+  the same over-claim [#233](https://github.com/theurian/theurian/issues/233)
+  corrected for `PathEscapeError`, reopened here. A `contentFile` naming a
+  directory raises `EISDIR`, which no `chmod` cures: the fault is the authored
+  input, so the remedy now names the `contentFile` to correct and says nothing
+  about permissions. A `stat`/`open` refused for a *child* is the parent directory
+  lacking its search bit, so `chmod u+rX` on the child cures the wrong file — the
+  remedy now points `chmod u+x` at the unsearchable directory instead.
+  `EACCES`/`EPERM` still earn a `chmod`; a `None` errno is treated as
+  non-permission, since a `chmod` prescribed for an unknown cause is the very
+  over-claim this avoids. Every branch still points at `.theurian/migrations/`
+  before any re-draft (#89).
+- **Scope note, not a behaviour change: `propose accept` does not self-validate
+  the proposal it is accepting**
+  ([#307](https://github.com/theurian/theurian/issues/307)). The replacement
+  guard's docstring claimed it holds the invariant that `accept` "never leaves the
+  set unable to validate." That is false as a global invariant: `accept` does not
+  schema-validate the incoming migration and does not check it against itself, so
+  a self-contained breakage in a single proposal — two operations naming one
+  `contentFile`, a self-inconsistent pin, an empty `contentFile` — lands and is
+  caught by `migrate validate` in CI, which is the check by design (ADR-0013 §4).
+  The docstring is narrowed to what the guard actually holds: it refuses a
+  replacement that would break a pin *already landed* in the approved set, the one
+  fault it can judge from the landed set alone. No behaviour changed here;
+  hardening `accept` itself against a self-contained breakage is deferred to #307.
+- **A migration-schema rejection echoed `jsonschema`'s raw `{instance!r}` and
+  had dropped the schema-side fact that names the defect**
+  ([#289](https://github.com/theurian/theurian/issues/289)). When a migration
+  failed validation, the message interpolated the whole failing instance
+  verbatim — unbounded, and with control characters unescaped — while no longer
+  saying *what the schema expected*: the `const` a value must equal, the
+  `pattern` it must match, or the unexpected keys an `additionalProperties:
+  false` rejected. The rejection is now built at Theurian's own seam
+  (`migration_loader.py`'s `_schema_rejection`), keeping that schema-side fact
+  and bounding every author-written fragment it echoes to `MAX_ECHOED_VALUE`
+  (1,000 characters) through a `reprlib`-based renderer that escapes control
+  characters. This restores the diagnostic parity the pre-change wording had
+  while removing the unbounded echo — a 100 KB value no longer renders a
+  100,198-character refusal into a terminal.
+
+- **An oversized scalar nested in a rejected operation reported its
+  post-truncation length, not its true length**
+  ([#289](https://github.com/theurian/theurian/issues/289)). When a rejected
+  operation carried an oversized string, the echo truncated the container's
+  render first, so the "N characters in all" count reported the *container
+  repr's* length (~1,100), not the offending value's. The renderer now records
+  the longest scalar's pre-truncation length and the rejection names that true
+  length — the one number that is the diagnosis for a value refused for being
+  large.
+
+- **A hostile migration document could exhaust CPU or memory at validate time,
+  and a giant-integer scalar escaped `--json` as a raw traceback**
+  ([#291](https://github.com/theurian/theurian/issues/291)). Several shapes of a
+  parsed migration document defeated `jsonschema`'s own message building at
+  validate time. The loader now applies three bounds ahead of `validate` in its
+  own un-memoised walk — nesting depth, node count, and total rendered magnitude
+  — and translates a single giant integer by type after `validate` raises:
+  - **Nesting** is refused ahead of `validate` at `MAX_DOCUMENT_NESTING` (64).
+    Past the interpreter's C recursion budget `jsonschema` cannot build its own
+    refusal message, and the `RecursionError` that follows is indistinguishable
+    from a corrupt schema — so a deep *document* was answered "reinstall
+    theurian". A schema-valid migration nests at most 7 levels.
+  - **Branching alias expansion** is refused ahead of `validate` at
+    `MAX_DOCUMENT_NODES` (100,000). A YAML anchor aliased into a doubling chain
+    is a ~500-byte file whose expansion is 2^N nodes; `jsonschema`'s
+    `{instance!r}` re-expands it the same way, building a 46 MB message from a
+    500-byte file at alias level 22 (measured 2026-08-21, `jsonschema` 4.26.0).
+    The walk deliberately does not collapse shared references — a collapsed
+    count would wave the bomb through. Same un-memoised-walk shape as the OpenAPI
+    `$ref` ref-walk in
+    [#245](https://github.com/theurian/theurian/issues/245), in another seam.
+  - **Total rendered magnitude** is refused ahead of `validate` at
+    `MAX_DOCUMENT_RENDERED_CHARS` (1,000,000) — a new bound in the same walk that
+    the node count could not stand in for. One large scalar aliased into many
+    slots is only a handful of nodes, well under `MAX_DOCUMENT_NODES`, but
+    `{instance!r}` re-expands it to N times its rendered width. The walk charges
+    every leaf's width via a new O(1) `_rendered_width` per un-memoised reference
+    — `len` for a `str`/`bytes`, a `bit_length`-derived decimal-digit estimate
+    for an `int` (never `str(int)`, which is quadratic and raises past CPython's
+    int→str limit), and the `repr` length of a bounded `bool`/`float`/`None`.
+    This closes two aliased-scalar faces. The first is a large *string* aliased
+    into N slots: a hundreds-of-gigabytes transient that raises `MemoryError`,
+    which is neither a `ValueError` nor an `ArithmeticError` and so escaped the
+    scalar catch below as a raw traceback. The second was found by the round-two
+    review and missed by the round-one bound, which charged only `str`/`bytes`: a
+    *medium integer* — a few thousand digits, so its own `repr` does not raise —
+    aliased into N slots is O(N) nodes under `MAX_DOCUMENT_NODES` and not a
+    `ValueError`, so it defeated every round-one control while `{instance!r}`
+    re-emitted its digits once per slot, a `digits × slots`-character message.
+    Charging every leaf per reference refuses both faces before `validate`. The
+    refusal message still says "characters of string content", but the bound now
+    covers every leaf type, integers and bytes included.
+  - **A single giant integer** — one whose own `{instance!r}` render raises,
+    past CPython's int→str limit (4300 digits by default) — is one node whose
+    lone width passes the aggregate budget above, so it reaches `validate` and is
+    *translated by type* rather than refused ahead. `jsonschema` renders it past
+    that limit and raises `ValueError` (reachable today), or a float `multipleOf`
+    coerces it and raises `OverflowError` (latent — the bundled schema carries
+    only `minimum`/`maximum`). `_validate_document` catches the whole
+    `(ValueError, ArithmeticError)` class as a `MigrationError` so a future
+    numeric keyword cannot reopen the escape. This catch and the rendered budget
+    are complementary, not redundant: the budget refuses the *aliased* integer
+    whose aggregate render is large, and this catch handles the *single* integer
+    whose lone render raises. The file-load path closes the same single-value
+    face: a YAML integer literal past CPython's limit is now translated to the
+    same bounded "reduce it" wording instead of forwarding CPython's message,
+    which named `sys.set_int_max_str_digits()` — an interpreter tuning knob no
+    migration author should reach for. As defence in depth, the rejection
+    builder's `_echo` refuses an integer wider than `_MAX_ECHOED_INT_BITS`
+    (2,000 bits) as a placeholder.
+
+## [0.1.0.dev8] - 2026-08-20
+
+### Added
+
+- **`evidence.json` now records the `migrationId` and `itemId` its proposal
+  drafted** ([#253](https://github.com/theurian/theurian/issues/253)). These are
+  the two fields of that file Core reads back: together they let `propose accept`
+  ask whether a migration with that id, operating on that item, is in
+  `.theurian/migrations/`. Both are a contributor's claim, not authority —
+  `evidence.json` is committed and untrusted (ADR-0013 point 7) — so `itemId` is
+  the cross-check that stops a forged `migrationId` (one pointing at another
+  proposal's landed migration) from reading as accepted. Optional on read: the 26
+  proposals committed in this repository predate both fields and are diagnosed by
+  best-effort inference, which their message says.
+
+### Fixed
+
+- **The installed migration schema resolved `$ref`s over the network, and its
+  resolution failures escaped as raw tracebacks**
+  ([#235](https://github.com/theurian/theurian/issues/235)). The migration
+  schema was validated with `jsonschema`'s default registry, whose retrieve
+  callable fetches an external `$ref` over the network
+  (`urllib.request.urlopen`) at validate time — and reads a `file://` ref off
+  disk the same way. An SSRF-shaped read gated only on the installed schema
+  being corrupted or replaced (an operator-side precondition; `schema_root()`
+  never reads user-project paths), and covered by no existing claim:
+  `parsers/openapi.py`'s "external `$ref` targets are recorded, never fetched"
+  governs *ingested* documents, not the schema this build ships. Every
+  validator is now built with `referencing`'s `EMPTY_REGISTRY` — no retrieve
+  callable — so an external `$ref` fails closed; internal `#/$defs/…` refs
+  still resolve from the schema's own root resource, so the bundled schema
+  validates unchanged. Separately, the resulting resolution failures — an
+  unresolvable `$ref`/`$dynamicRef` raises `referencing.exceptions.Unresolvable`
+  and a self-recursive or empty `$ref` raises `RecursionError`, neither a
+  `ValidationError` — used to slip past every `except ValidationError` seam and
+  reach `resolve_context` as a raw traceback under `--json`. Both are now
+  translated to `SchemaUnreadableError`, the type every other
+  installed-schema-corruption failure already carries, at both validate seams
+  (`migrate validate` / `propose`, and any command that loads migrations from
+  disk).
+- **A path-containment refusal told the user to go somewhere they already were,
+  and could instruct them to delete their own work**
+  ([#233](https://github.com/theurian/theurian/issues/233)). With
+  `.theurian/migrations` — or one `*.yaml` file inside it — a symlink pointing
+  outside the project, `theurian migrate validate --json` printed
+  `{"error": "Path escapes the permitted root /<absolute>/<project>", "remedy":
+  "Run this inside an initialised Theurian project."}` at exit 1. The refusal
+  itself was correct and is unchanged; what it said about itself was not.
+  `PathEscapeError` set no `remedy` of its own, so the CLI's generic fallback
+  won — the "exception that does not describe itself" shape
+  [#205](https://github.com/theurian/theurian/issues/205) exists to end. It now
+  names, relative to the project root and with the `!r` quoting its siblings
+  use, *where* the problem is — and **no remedy names a file to delete.** That
+  is the substantive change: an escape happens through a symbolic link somewhere
+  on the entry's ancestor chain or its resolution chain, and which link it is
+  cannot be determined from the entry alone. Three successive attempts to
+  determine it anyway were each refuted by a deeper construction — the last by
+  `x.yaml → y.yaml → outside`, where following the remedy deleted two
+  Git-tracked files and ended at `valid: true` while the minimal cure was
+  repointing `y` alone. So the remedy now states only what `lstat` proves — that
+  the named entry is or is not itself a link — and then hands over the finite
+  checklist: this entry, the directories above it, the links it resolves
+  through. "Repoint that link, or remove that link" refers to whichever the
+  reader finds; Theurian never names it. Related: an outside-pointing
+  `.theurian` is reachable from a plain `git clone`
+  ([#237](https://github.com/theurian/theurian/issues/237)). The offending path
+  is still never echoed (SEC-7), and neither is the absolute project root.
+- **A `contentFile` refusal no longer denies the commonest cure.** The
+  path-escape remedy for a `contentFile` used to say that removing the `..` was
+  "not the cure" — wrong for a plain over-traversal typo, which involves no
+  symlink at all and is fixed by exactly that edit, and in conflict with the
+  sibling `MigrationContentUnreadableError`, which tells the author to fix the
+  path. It now offers both candidates: correct the path, or find the link
+  something it traverses goes through.
+- **Exit code:** a `PathEscapeError` raised while resolving a project now exits
+  `EXIT_STATE_ERROR` (4) rather than 1 for the commands routed through
+  `_require_project` — measured, all nine: `migrate validate`, `migrate status`,
+  `migrate apply`, `index build`, `index status`, `index gc`, `ingest`,
+  `propose` and `propose accept` — matching every sibling refusal on the same
+  load path (`MigrationsDirectoryUnreadableError`,
+  `MigrationFileUnreadableError`, `MigrationError`). A script keying on exit 1
+  for those must be updated. `init` and `project register` call
+  `resolve_context` directly and still exit 1; `project status` reports at exit
+  0 as it always has. All three now carry the new remedy text.
+- **A path refused only for nesting too deep no longer claims to have escaped**
+  ([#233](https://github.com/theurian/theurian/issues/233)). `resolve_within_root`
+  refuses a path past `MAX_PATH_DEPTH` whether or not it ever leaves the root,
+  and reported it as `Path escapes the permitted root` — false for a path
+  sitting entirely inside. It now raises `PathDepthExceededError` with its own
+  message and a remedy about flattening the nesting. The new type is a
+  `PathEscapeError` subclass, so every existing `except` and every exit-code
+  route catches it unchanged; only what the caller is told differs.
+- **An interrupted `theurian propose` was diagnosed as an accepted one**
+  ([#253](https://github.com/theurian/theurian/issues/253)). `propose accept`
+  read the presence of `evidence.json` as "this proposal has already been
+  accepted", but `propose` writes the body, then the evidence, then the
+  migration — so a run killed before its last write left exactly that shape.
+  `accept` reported that the migration had been moved into
+  `.theurian/migrations/` and that no action was needed beyond opening a pull
+  request, while `.theurian/migrations/` held nothing and the drafted knowledge
+  existed nowhere. The remedy discarded the draft.
+
+  Acceptance is a **best-effort diagnosis over untrusted input, not a
+  tamper-proof fact**: the proposal directory is contributor-controlled, so the
+  recorded `migrationId` is a claim (cross-checked by `itemId` against the
+  migration it names), a `evidence.json` that is present but unreadable is
+  answered as *indeterminate* rather than collapsed into "no record", and every
+  fallible branch points the reader at `.theurian/migrations/` first — no branch
+  emits an unconditional "no action is needed" or "draft it again", so none can
+  tell the author to discard work that may exist or duplicate a change that
+  already landed. Whether a migration is in place under the recorded id is read
+  from the same approved `MigrationSet` `migrate validate`/`apply` read — keyed by
+  the migration's inner id, not by a filename match — so `propose accept` cannot
+  disagree with the loader about what has landed, whatever a migration file was
+  renamed to or whether it is a symlink. The three states are kept distinct by
+  their exit codes: a migration in place under the recorded id — whether or not
+  the item cross-checks — exits 4 ("read before acting"), and only a recorded id
+  the loaded set holds *no* migration for exits 1 ("nothing landed, re-draft"), so
+  following exit 1 can never mint a duplicate of a change on disk. Absent
+  `evidence.json` (a legacy proposal, or
+  one interrupted before its evidence write) falls to inference over the
+  directory, which reads only the body shape the generator produces, so a
+  reviewer's notes or a `Thumbs.db` left beside an accepted proposal no longer
+  flips the verdict.
+
+- **A committed proposal could forge `theurian propose accept`'s own output**
+  ([#253](https://github.com/theurian/theurian/issues/253)). A proposal directory
+  arrives through a contributor's pull request, and a file name or a migration's
+  `contentFile` carrying `ESC [ 2 K` and a carriage return erases the line the
+  terminal has drawn and prints its own in place of it — reproduced printing this
+  command's own output under its own name, on both the refusal path and the
+  exit-0 **success** payload (`bodyFiles`, `migrationFile`). The CLI now escapes
+  every terminal-control character — the whole C0 block, `DEL` and C1 — at one
+  shared sink that every text-mode emitter routes each value and key through, so
+  no value any command prints, from any source, reaches a terminal with a raw
+  control byte. A value's own newline is escaped too (the output's structural
+  newlines are the emitters' own), while printable Unicode (a Japanese title) is
+  kept. The `--json` output was never affected.
+
+### Changed
+
+- **BREAKING — re-accepting an already-accepted proposal now exits 4, not 1**
+  ([#254](https://github.com/theurian/theurian/issues/254)). The published exit
+  code table documented 4 for "that migration is already in place", while the
+  natural route to that state — running `theurian propose accept` twice — exited
+  1 alongside "no such proposal", an interrupted draft, and a refused
+  `contentFile`. Exit 4 keeps its meaning and gains this case: *the knowledge
+  state refuses this move, so read it before acting*. It is not "already done" —
+  an approved migration set that cannot be read also exits 4, with the proposal
+  still waiting — and the published table now says so rather than promising that
+  1 always means nothing landed. Scripts that treat any non-zero exit as failure
+  are unaffected; one that special-cased 1 for "already accepted" must read 4.
+
+  Breaking by the compatibility table in
+  [`docs/protocol/plugin-core-compatibility.md`](../../docs/protocol/plugin-core-compatibility.md),
+  and `protocolVersion` is **not** bumped for it — a recorded, narrowly scoped
+  exemption on the same grounds as `system.capabilities.milestone`'s (#206),
+  written up under "Changing this contract" in
+  [`docs/protocol/mcp-tools.md`](../../docs/protocol/mcp-tools.md).
+
 ## [0.1.0.dev7] - 2026-08-19
 
 ### Added

{theurian-0.1.0.dev7 → theurian-0.1.0.dev9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: theurian
-Version: 0.1.0.dev7
+Version: 0.1.0.dev9
 Summary: Git-native engineering knowledge platform: versioned, traceable context for AI agents.
 Project-URL: Homepage, https://github.com/theurian/theurian
 Project-URL: Documentation, https://github.com/theurian/theurian/tree/main/docs
@@ -22,6 +22,7 @@ Requires-Dist: jsonschema==4.26.0
 Requires-Dist: pydantic==2.13.4
 Requires-Dist: python-ulid==4.0.1
 Requires-Dist: pyyaml==6.0.3
+Requires-Dist: referencing==0.37.0
 Requires-Dist: typer==0.27.1
 Provides-Extra: all
 Requires-Dist: mcp==2.0.0; extra == 'all'

{theurian-0.1.0.dev7 → theurian-0.1.0.dev9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "theurian"
-version = "0.1.0.dev7"
+version = "0.1.0.dev9"
 description = "Git-native engineering knowledge platform: versioned, traceable context for AI agents."
 readme = "README.md"
 requires-python = ">=3.13"
@@ -36,6 +36,11 @@ dependencies = [
     "pydantic==2.13.4",
     "python-ulid==4.0.1",
     "pyyaml==6.0.3",
+    # jsonschema's public reference-resolution API, imported directly for the
+    # no-network registry that keeps the installed migration schema offline
+    # (issue #235). A transitive dep of jsonschema, declared here because we
+    # import it -- ADR-0014's "import what you declare".
+    "referencing==0.37.0",
     "typer==0.27.1",
 ]
 

{theurian-0.1.0.dev7 → theurian-0.1.0.dev9}/src/theurian/__init__.py

@@ -8,7 +8,7 @@ plugin must never import them (ADR-0001, CP-2).
 
 from theurian.domain.compatibility import CURRENT_PROTOCOL_VERSION
 
-__version__ = "0.1.0.dev7"
+__version__ = "0.1.0.dev9"
 __protocol_version__ = CURRENT_PROTOCOL_VERSION
 
 __all__ = ["__protocol_version__", "__version__"]