crucible-bench 1.1.0__tar.gz

crucible_bench-1.1.0/ARCHITECTURE.md

@@ -0,0 +1,220 @@
+# crucible: architecture
+
+crucible is the cognition organ of the constellation: it tests a thesis against evidence and emits a
+verdict you can re-check. This document is the map of how it is built and why. It grows as the organ
+does; sections describe what is shipped.
+
+## The one shape: a grounded `Verdict`
+
+Every judgment crucible makes reduces to one shape: a verdict per claim, computed from a measurement,
+never asserted.
+
+```python
+def verdict_for(claim: Claim, measurement: Measurement | None) -> Verdict: ...
+```
+
+A measurement records a deviation from what the claim predicts and a tolerance. The verdict is a
+pure function of that record: within tolerance is MATCH, outside is DRIFT, absent or unmeasurable is
+UNVERIFIABLE. There is no model in this step, so the verdict recomputes from the stored record and a
+confident assertion has no effect on the rechecked result. UNVERIFIABLE is fail-closed: an axis that
+cannot be measured is never read as holding.
+
+## The receipt: `Claim`
+
+Every claim carries a content hash, so a tampered claim is caught by re-hashing.
+
+```python
+@dataclass(frozen=True, slots=True)
+class Claim:
+    id: str            # defaults to sha256[:16]
+    text: str          # the assertion
+    falsification: str  # the observation that would refute it
+    sha256: str        # content hash binding (text, falsification)
+```
+
+`make_claim` computes the hash; `Claim.verify()` re-hashes and confirms it still matches. A claim
+with no falsification condition can only ever be UNVERIFIABLE: nothing would settle it.
+
+## The thesis and its seal
+
+A `Thesis` is a set of claims with a re-checkable seal over them (sorted, canonical JSON, sha256),
+mirroring Gather's digest seal. The seal folds in the title, the disposition, and each claim's id and
+content hash, so swapping a claim's content, relabelling its id, or flipping the disposition breaks
+the seal; reordering does not, because a thesis is a set. The disposition being sealed is what lets
+the publication gate trust the label.
+
+## The witnessed assessment
+
+An assessment folds the per-claim verdicts into a record with its own seal, and it persists the
+verdicts and the measurements alongside, so the seal has a preimage on disk rather than fingerprinting
+discarded data. `verify_assessment` recomputes every seal from the stored arrays (the verdict seal
+from the stored verdicts, the measurement seal from the stored measurements, the record seal from the
+fields that bind both); it is not a tautology. `recheck_assessment` goes further: from the thesis and
+the stored measurements it re-derives each verdict via `verdict_for` and confirms the stored verdicts
+are exactly what the pure function yields, so a verdict that was asserted rather than computed is
+exposed even when its seals are internally consistent. The CLI surfaces this as `crucible verdicts
+--verify`. The seal proves integrity, not authorship: a fully consistent re-forge (every field and
+seal rewritten together) is out of scope without a signature, and the docs say so where a user meets it.
+Summary counts are not trusted as labels; verification re-derives them from the verdict rows.
+Assessment and verdict rows also carry the thesis disposition, and the disposition participates in
+the assessment and verdict seals so publication posture is visible in witnessed outputs.
+
+Measurement rows persist and seal claim binding, deviation, tolerance, method, `measured_at`,
+evidence, and optional `recheck` descriptors. When a descriptor is present, it is included in the
+measurement seal; when absent, legacy rows keep the original replay shape and are skipped by
+oracle-level replay. `recheck_measurements` is the oracle-level hook: a caller provides replay
+functions keyed by descriptor `oracle`, and crucible compares the replayed measurement inputs to the
+stored row. The shipped CLI still re-derives verdicts from stored measurements; external callers can
+now also re-run descriptor-bearing measurements. `crucible recheck REGISTRY` exposes the descriptor
+plan for the latest assessment, `--template FILE` writes a replay pack skeleton for the verifier to
+fill, and `--pack FILE` checks a finished oracle replay pack against those sealed measurement rows
+without creating a second verdict path. If a replay pack carries the template assessment block, the
+block must match the selected thesis id, assessment seal, and measurement seal before replay starts.
+
+`render_assessment_report` turns the same sealed record into a deterministic Markdown artifact. It
+does not change the verdict contract or decide anything new; it gives an operator a readable surface
+over the counts, seals, integrity checks, verdicts, evidence, and recheck descriptors. The CLI exposes
+this as `crucible report REGISTRY`, defaulting to the latest assessment.
+
+`crucible batch` is a runner over the same primitives, not a second judgment path. A manifest lists
+thesis jobs and chooses either explicit measurements or a substrate oracle per job; the command
+records each assessment into one registry and can write one Markdown report per job. The batch layer
+coordinates throughput while leaving claim receipts, measurements, verdicts, assessment seals, and
+report rendering unchanged.
+
+`crucible run` is the single-thesis operator surface over the same path. It runs the null steelman,
+loads either explicit measurements or a table substrate, records the witnessed assessment, reloads the
+latest registry record for a disk recheck, and can write both the Markdown report and a JSON run
+record. With `--bundle DIR`, it writes `DIR/spec.json`, `DIR/run.json`, `DIR/report.md`, and
+`DIR/review.md` as a cleanroom review packet. The run record names packet artifacts relative to the
+packet root, not by local workstation path. Review verifies those path fields before verifier
+handoff. It does not introduce a second source of truth: the
+assessment and verdict rows remain the authority, and the run record is the session envelope around
+them.
+
+## The seams (the impure and the optional)
+
+crucible's core is pure standard library. Optional edges live behind a Protocol seam with a Null
+default, exactly as Gather isolates its synthesizer.
+
+- **Steelman** (`Steelman` protocol): independent adversaries propose refutations. The default
+  `NullSteelman` surfaces the claim's own stated falsification as the standing test and invents
+  nothing; custom edges plug in to generate independent refutations. Adversaries propose what to
+  measure; the measurement decides. `steelman_thesis` stamps each refutation's source from the
+  producing steelman's name, so the label is the producer's.
+- **Measure** (`Measure` protocol): the sound-oracle edge that decides a claim against a substrate.
+  The default `NullMeasure` measures nothing (UNVERIFIABLE); the deterministic `TableMeasure` computes
+  a claim's deviation from a predicted value over a provided substrate (offline, no model). A real
+  oracle (the Telos verifier, or a symbolic or proof oracle for abstract math) plugs in through the
+  same shape, and `verdict_for` decides from the `Measurement` it produces. This is where the verdict
+  is grounded.
+- **Refine** (`refine_thesis`): the continuous loop that measures a thesis, grades each claim by its
+  normalized margin, computes harmonic-mean cohesion, reflects the weakest claim, and re-iterates via
+  a caller-provided adjuster. It never returns `correct` unless every claim has enough margin and the
+  margins are cohesive; if the budget is spent it reports the weakest claim.
+
+The core imports neither the Null nor any model, so the package keeps zero third-party dependencies.
+
+## Subprocess seam adapters
+
+`SubprocessSteelman` and `SubprocessMeasure` are optional stdlib adapters for configured commands.
+They exchange one bounded JSON request/response over stdin/stdout, enforce a timeout, and reject shell
+strings so arguments are not re-parsed by a shell. By default they pass only a minimal environment,
+discard stderr, and terminate children whose stdout grows past the response cap. A child process may
+propose a challenge or report a deviation, but crucible stamps the claim identity, claim hash, and
+producer name locally. The verdict still follows from `verdict_for`; a subprocess cannot assert MATCH.
+
+## Telos artifact interop
+
+`TelosMeasure` consumes the Telos engine's `telos.witnessed-artifact/v1` protocol without importing
+Telos. The artifact carries a compact certificate and a `recheck` descriptor naming a verifier. A
+caller supplies a verifier registry; crucible re-runs the named verifier, compares the reproduced
+verdict to the carried verdict, and turns that live result into a normal Measurement. Reproduced
+`verified` becomes a MATCH input, reproduced `refuted` or a drifted carried verdict becomes a DRIFT
+input, and a missing/unregistered/unverifiable proof becomes an UNVERIFIABLE input. That keeps the
+interop on the same spine: trust the proof, not the emitter. When the Telos artifact is well-shaped,
+the produced Measurement persists a `telos:<verifier>` recheck descriptor so later assessment replay
+can re-run the same oracle from the stored row.
+
+## Gather/index interop
+
+`GatherDigestMeasure` consumes Gather's digest contract directly: a list of evidence receipts and a
+seal recomputed from those receipts. A caller maps a crucible claim to the receipt fields it expects
+to exist. A verified digest with that receipt becomes a MATCH input; a verified digest without it
+becomes a DRIFT input; a malformed or missing digest becomes UNVERIFIABLE. This makes "show me the
+evidence receipt" a measurable claim.
+
+`IndexMeasure` consumes `index.verification/1` records directly. The record carries an index claim,
+the canonical hash of the graph pack it was computed against, and a carried verdict. crucible is
+given the graph pack by hash, replays the supported structural claim (`exists` or `depends`), and
+maps the reproduced result into the same Measurement spine. It does not import index, execute index,
+or trust the carried verdict without replaying the pack.
+
+## Drift tracking
+
+The continuous loop needs an honest account of what changed between rounds. `drift_track(previous,
+current)` compares two witnessed assessments of the same thesis and classifies each claim as held,
+moved, improved, or regressed. Numeric margins decide improvement and regression. Unrankable
+transitions, such as UNVERIFIABLE to MATCH, are reported as moved rather than silently promoted.
+The CLI exposes this as `crucible drift REGISTRY`, comparing the latest two stored assessments.
+
+## Publication gate
+
+Assessment and export are deliberately separate. A fenced thesis may be registered and assessed
+locally, but the public export edge applies `gate_check` and refuses anything with a fenced
+disposition or an explicit fenced/restricted marker in the title, claim text, or falsification. The
+exported contract omits runtime metadata and carries only the title, disposition, thesis seal, and
+content-hashed claims needed for public re-checking. This gate is a mechanical disposition and marker
+guard, not a semantic content classifier.
+
+## The registry
+
+A `Registry` is durable, content-addressed storage for theses and their assessments, mirroring
+Gather's corpus: claim bodies at `objects/ab/cdef...` keyed by the claim hash, a `theses.jsonl`
+catalog, and an `assessments.jsonl` history. `verify()` re-hashes every stored body and reports
+MATCH / MISSING / CORRUPT, so the verdict's proof stays durable over a growing registry.
+
+`registry_ops` reads across that store without changing the storage contract. `registry_stats`
+summarizes thesis counts, claim bodies, dispositions, assessment history, skipped invalid latest
+rows, and the latest verified verdict posture per thesis. `search_theses` recalls theses by scope
+text, thesis status, and latest verified verdict status, falling back past invalid tail rows instead
+of trusting or hiding history. `prune_objects` identifies orphaned claim bodies and is dry-run by
+default; deletion requires an explicit apply path and validates the object root plus each object path
+with the registry realpath guard before unlinking it. The registry rejects duplicate thesis ids with
+different seals and refuses symlinked storage paths, so content-addressed writes stay inside the
+registry root.
+
+## Verifier separation
+
+The review loop is intentionally clean. A verifier receives the original spec/readiness docs and the
+artifact under review. It does not receive the worker's context, reasoning trace, or intermediate
+steps. If success cannot be evaluated from that minimal state, the spec is not checkable yet and the
+readiness artifact needs work before release. For run packets, `crucible review BUNDLE` makes that
+rule executable: extra context files fail the packet before any verifier judgment begins, and
+`run.json` must declare passing embedded integrity checks, `report.md` must match the assessment
+artifact rendered from `run.json`, `run.json` artifact path fields must remain packet-relative,
+and `review.md` must match the canonical cleanroom instructions.
+
+## Determinism and the zero-dependency core
+
+Clocks are injected everywhere time is recorded; iteration is sorted; JSON is canonical
+(`sort_keys`, `ensure_ascii=False`). So an assessment replays and a seal recomputes. The core is pure
+standard library. A custom edge may pull in whatever it needs, but only behind a seam, and only at
+the impure edge.
+
+## Protocol interoperability (the dual mandate)
+
+crucible stands alone and serves the constellation at once. At the 1.0 flagship floor, the
+standing-alone half and the published contract are shipped: a sealed assessment and its verdicts,
+re-checkable from disk, that a downstream organ reads to learn a thesis's standing. It also includes
+protocol adapters for Telos witnessed artifacts, Gather witnessed digests, and index verification
+records. These adapters consume documented JSON contracts without importing sibling internals. Shared
+primitives, such as the `refine` loop, are integrated natively rather than taken as third-party
+dependencies, so reuse never costs standing alone. Seams default to Null, so the absence of a peer is
+a quieter capability, never a failure.
+
+## Peer composition
+
+crucible composes with the rest of the constellation (telos, index, forum, gather) through clean
+protocol seams; it does not absorb or get absorbed. The sealed assessment is the contract a
+downstream reader consumes. This is why crucible is a peer organ, not a feature of index or of refine.

crucible_bench-1.1.0/CHANGELOG.md

@@ -0,0 +1,290 @@
+# Changelog
+
+All notable changes to crucible. Versions follow semantic versioning; each minor release is built
+behind a feature branch and reviewed before merge.
+
+## Unreleased
+
+- CLI compatibility: `python -m crucible` now dispatches the normal Crucible CLI, so source
+  checkouts, MCP hosts, IDE harnesses, and automation runners can use the same command surface as
+  the installed `crucible` script.
+- Creative measurement gate: adds `crucible measurement-gate PACKET [--criteria FILE]` and the
+  `crucible.measurement_gate` MCP tool for verifying Telos histogram, dither, Gaussian-splat,
+  clustered-lighting, and audio-spectral measurement packets without exporting raw pixels, assets,
+  prompts, tool arguments, or full payloads.
+- Gate verdicts: keeps `decision_outcome` (`allow`, `require_review`, `block`) separate from
+  `verification_verdict` (MATCH, DRIFT, UNVERIFIABLE) and emits normalized failure codes for operator
+  alerting, including raw payload leaks, cluster budget overruns, dither-pattern gaps, provenance
+  gaps, pixel-dimension mismatches, and audio-spectrum gaps.
+- MCP parity: expands the stdio MCP server beyond status/doctor/assess/recheck to host-call the run, review, report, batch, registry, drift, refine, and verdicts workflows through the existing CLI contract.
+
+- Enterprise readiness: adds `docs/ENTERPRISE-READINESS.md` for context envelopes, action receipts, readability gates, and host-neutral operation.
+- Operator surface: the status payload now advertises shared Project Telos CLI/MCP/plugin/IDE/TUI/app contracts for enterprise, research, creative, scientific, and education workflows.
+
+Presentation and operator-surface housekeeping for Project Telos parity.
+
+- README: brings Crucible up to the shared five-flagship presentation shape with title-case product naming, current CI badge, consistent navigation, and a current-status block.
+- Status copy: updates the visible status from the old 1.0 flagship floor to the 1.1 operator floor.
+- Status payload: exposes the primary workflow commands, current operator commands, integration surfaces, presentation freshness, MCP tool names, and the 1.1 operator-floor summary under `native`.
+- MCP tools: records native availability for `crucible.status`, `crucible.doctor`, `crucible.assess`, `crucible.measurement_gate`, `crucible.recheck`, `crucible.run`, `crucible.review`, `crucible.report`, `crucible.batch`, `crucible.registry`, `crucible.drift`, `crucible.refine`, and `crucible.verdicts`.
+
+## 1.1.0
+
+Operator run surface.
+
+- CLI: `crucible run THESIS --registry DIR (--measurements FILE | --substrate FILE)` runs the
+  steelman, measurement, witnessed assessment, and disk recheck path as one session.
+- `crucible run --json` emits a complete run record with thesis metadata, refutations, assessment,
+  verdicts, disk recheck status, and optional report path.
+- `crucible run --report FILE` writes the deterministic Markdown assessment report for the same
+  witnessed assessment, while `--out FILE` writes the JSON run record with exclusive creation.
+- `crucible run --bundle DIR` creates a self-contained cleanroom review packet containing
+  `spec.json`, `run.json`, `report.md`, and `review.md`, refusing pre-existing packet directories.
+- Bundle run records carry a machine-readable verifier boundary: cleanroom mode, allowed packet
+  inputs, excluded worker context, and the checkability rule for underspecified specs.
+- CLI: `crucible review BUNDLE` validates the cleanroom packet before verifier handoff, including
+  required files, absence of extra context, verifier boundary metadata, and spec/run agreement.
+- CLI: `crucible recheck REGISTRY [--template FILE] [--pack FILE]` lists descriptor-bearing
+  measurement rows, writes replay pack templates, and validates finished oracle replay packs without
+  creating a second verdict path.
+- Replay packs that return the template assessment block are checked against the selected thesis id,
+  assessment seal, and measurement seal before oracle replay starts.
+- Cleanroom review now recomputes the expected `report.md` artifact from `spec.json` plus `run.json`
+  and fails closed when the human report is tampered or stale.
+- Cleanroom review now also checks that `review.md` is the canonical verifier instruction sheet, so
+  packet-local instructions cannot widen the verifier's context.
+- Bundle run records now use packet-relative artifact names, avoiding local workspace paths inside
+  cleanroom verifier packets.
+- Cleanroom review now validates those `run.json` artifact path fields and fails closed if they are
+  absolute, local, or renamed away from the packet-relative contract.
+- Cleanroom review now requires `run.json` to declare passing embedded integrity checks before
+  verifier handoff.
+
+## 1.0.0
+
+Stable flagship floor.
+
+- Assessment integrity now seals verdict margin and grounds, and `recheck_assessment` rejects stored
+  verdict rows or summary counts that do not re-derive from the thesis and measurements.
+- Measurement rows now persist and seal `measured_at`, and Telos-backed measurements persist a
+  `telos:<verifier>` replay descriptor so oracle-level reassessment checks a real stored row.
+- Drift and registry status/search now use the latest verified assessments, falling back past invalid
+  tail rows instead of trusting or hiding history.
+- Registry body verification now reports non-file or unreadable object paths as CORRUPT instead of
+  raising, and registration rejects pre-existing non-file object paths.
+- Registry prune now applies the registry realpath guard before scanning or deleting object paths, so
+  escaped, symlinked, or junctioned object roots are refused before unlink.
+- Assessment and verdict records, CLI JSON, and Markdown reports now carry the sealed thesis
+  disposition, keeping publication posture visible in witnessed outputs.
+- `refine.margin()` is public and reused by grading, matching the documented normalized-margin
+  contract.
+- Index/Gather interop canonical hashing now uses unescaped sorted JSON (`ensure_ascii=False`) for
+  non-ASCII graph-pack content.
+- The registry rejects duplicate thesis ids with different seals, refuses symlinked storage paths,
+  and keeps object writes on unique temp files inside the registry root.
+- Batch manifests keep thesis, measurement, and substrate paths inside the manifest bundle; path-like
+  missing refs fail closed without rejecting dotted registry ids; report writes use index-prefixed
+  filenames and exclusive creation.
+- Subprocess-backed edges use a clean default environment, discard unbounded stderr, write stdout to a
+  temporary file, actively terminate children that exceed the response cap, and still reject shell
+  strings.
+- CLI JSON loaders reject non-object top-level payloads with clean errors, ambiguous claim text refs
+  are rejected, and refine thresholds reject negative or non-finite values cleanly.
+- Release workflows remove manual PyPI dispatch, pin external GitHub Actions by commit SHA, and
+  install pinned build tooling plus the pinned build backend from `requirements-release.txt`.
+- README and readiness docs record the clean verifier rule: verifier receives only the original spec
+  and artifact, never the worker context or reasoning trace.
+
+## 0.14.1
+
+Batch hardening patch.
+
+- Batch report filenames now include the manifest job index, so duplicate or colliding job IDs do not
+  overwrite earlier reports.
+- Batch thesis, measurement, and substrate references now fail closed when a manifest-relative or
+  absolute file is missing instead of falling back to the caller's current working directory.
+
+## 0.14.0
+
+Batch assessment workflow.
+
+- `crucible.batch_cmd`: adds a manifest runner that assesses multiple thesis jobs into one
+  content-addressed registry.
+- Manifest jobs accept either explicit measurements or a substrate oracle file, preserving the same
+  grounded measurement -> verdict spine as the single-thesis commands.
+- CLI: `crucible batch MANIFEST --registry DIR [--reports DIR] [--json]` emits a row per job and can
+  write one deterministic Markdown report per assessment.
+- Readiness coverage now runs the batch command through the bundled example thesis surface.
+
+## 0.13.0
+
+Markdown assessment reports.
+
+- `crucible.report`: adds `render_assessment_report`, a deterministic Markdown renderer for one
+  witnessed assessment and its thesis.
+- Reports include assessment/thesis seals, outcome counts, integrity checks, per-claim verdicts,
+  measurement evidence, optional recheck descriptors, and unmeasured claims.
+- CLI: `crucible report REGISTRY [--index N] [--out FILE]` renders the latest assessment by default
+  and can write the Markdown body to disk.
+- Public API: exports `render_assessment_report`.
+
+## 0.12.0
+
+Measurement recheck descriptors.
+
+- `Measurement` now accepts an optional `recheck` descriptor, preserved at the end of the dataclass so
+  existing positional construction stays compatible.
+- Assessments persist and seal `measured_at` plus `recheck` descriptors when present; legacy
+  assessment rows without descriptors keep their previous replay shape and still verify.
+- `recheck_measurements` replays descriptor-bearing measurement rows through a caller-supplied oracle
+  registry and reports checked, skipped, missing, mismatched, and failed replays.
+- `recheck_assessment(..., measurement_replayers=...)` can include an oracle-level measurement replay
+  result alongside the existing seal/thesis/verdict re-derivation checks.
+- Public API: exports `recheck_measurements`.
+
+## 0.11.0
+
+Gather/index protocol interop preview.
+
+- `crucible.ecosystem_measure`: adds `verify_gather_digest`, `receipt_matches`,
+  `verify_index_verification`, and `canonical_sha` for consuming sibling-product JSON contracts
+  without importing sibling packages.
+- `GatherDigestMeasure` maps a verified Gather digest plus receipt selector into a crucible
+  `Measurement`: receipt present -> MATCH input, receipt absent -> DRIFT input, malformed or missing
+  digest -> UNVERIFIABLE input.
+- `IndexMeasure` maps an `index.verification/1` record plus supplied graph pack into a crucible
+  `Measurement`: reproduced MATCH -> MATCH input, reproduced REFUTED/DRIFT -> DRIFT input, missing
+  or unreplayable pack -> UNVERIFIABLE input.
+- Public API: exports `GatherDigestMeasure`, `IndexMeasure`, `verify_gather_digest`,
+  `verify_index_verification`, `receipt_matches`, and `canonical_sha`.
+
+## 0.10.0
+
+Telos witnessed-artifact interop preview.
+
+- `crucible.telos_measure`: adds `verify_telos_artifact`, `is_telos_artifact`, `check_content`, and
+  `TelosMeasure` for consuming `telos.witnessed-artifact/v1` envelopes through the Measure seam.
+- `TelosMeasure` maps a re-run Telos verifier result into a crucible `Measurement`: verified -> MATCH
+  input, refuted or drifted -> DRIFT input, absent or unregistered proof -> UNVERIFIABLE input.
+- Public API: exports `TelosMeasure`, `verify_telos_artifact`, `is_telos_artifact`, and
+  `check_content`.
+
+## 0.9.0
+
+1.0-readiness hardening.
+
+- Examples: the bundled demo and JSON examples are now regression-tested through the public CLI.
+- CLI surface: help output is covered for the shipped commands and registry actions.
+- Docs: adds a release-readiness checklist for the 1.0 review gate.
+
+## 0.8.0
+
+Optional subprocess-backed seam adapters.
+
+- `crucible.subprocess_edges`: adds `SubprocessSteelman` and `SubprocessMeasure`, stdlib-only adapters
+  for configured commands that exchange bounded JSON over stdin/stdout.
+- Safety posture: commands must be argv sequences rather than shell strings; request and response
+  sizes are bounded; timeouts are enforced; claim identity and producer labels are stamped locally.
+- Public API: exports `SubprocessSteelman` and `SubprocessMeasure`.
+
+## 0.7.0
+
+Registry operations for a growing corpus.
+
+- `crucible.registry_ops`: adds `registry_stats`, `search_theses`, and `prune_objects` for registry
+  health, recall, and object-store hygiene without changing the durable storage contract.
+- CLI: `crucible registry stats`, `crucible registry search`, and `crucible registry prune` summarize
+  the corpus, search by scope/status/latest verdict, and report orphaned claim bodies. Prune is
+  dry-run by default and deletes only with `--apply`.
+- Public API: exports `registry_stats`, `search_theses`, and `prune_objects`.
+
+## 0.6.0
+
+Publication-gated thesis export.
+
+- `crucible.gate`: adds `gate_check`, `export_guard`, and `export_thesis`. Fenced disposition and
+  explicit fenced/restricted markers fail closed at the public export edge.
+- CLI: `crucible export THESIS` emits the public thesis contract for publishable theses, resolves
+  thesis ids from a registry with `--registry`, and refuses fenced theses with a clean error.
+- Public API: exports `gate_check`, `export_guard`, and `export_thesis`.
+
+## 0.5.0
+
+Drift tracking across witnessed assessment rounds.
+
+- `crucible.drift`: compares two assessments of the same thesis and classifies each claim as held,
+  moved, improved, or regressed. Numeric margins decide direction; unrankable transitions such as
+  UNVERIFIABLE to MATCH are reported as moved.
+- CLI: `crucible drift REGISTRY` compares the latest two stored assessments, with human and JSON
+  output and clean errors for too-short or mixed-thesis histories.
+- Public API: exports `DriftRow`, `DriftReport`, and `drift_track`.
+
+## 0.4.0
+
+The refine loop: margin, cohesion, reflection, and re-iteration over a thesis.
+
+- `crucible.refine`: a zero-dependency refinement primitive with graded criteria, harmonic-mean
+  cohesion, reflect-weakest feedback, and fail-closed handling for broken generators, adjusters, and
+  non-numeric measurements.
+- `refine_thesis`: points the primitive at a thesis and a `Measure` oracle, grading each claim by its
+  normalized measurement margin and returning a `RefineReport` with final verdicts and the cohesion
+  trajectory.
+- CLI: `crucible refine <config.json>` runs ordered substrate rounds, stops on a cohesively verified
+  thesis, or reports the weakest claim when the budget is spent.
+- Public API: exports `GradedCriterion`, `Reflection`, `RefineOutcome`, `RefineReport`, `cohesion`,
+  `refine`, and `refine_thesis`.
+
+## 0.3.0
+
+The measure seam: a sound oracle decides a claim against a substrate. This is where the verdict is
+grounded, the half the differentiator names.
+
+- `crucible.measure`: a `Measure` protocol and a `MetricSpec` (the value a claim predicts, the
+  tolerance, the substrate key to observe, and the metric). `verdict_for` already consumes the
+  `Measurement` an oracle produces, so there is still no model in the verdict step.
+- `NullMeasure`: the standing default, produces no measurement (UNVERIFIABLE); it invents nothing.
+- `TableMeasure`: a deterministic, offline oracle. The deviation is the absolute or relative
+  difference between the observed value (from the substrate) and the value the claim predicts. An
+  unknown claim or a missing observation is UNVERIFIABLE, fail-closed. The shape a real oracle (the
+  Telos verifier, a proof or type checker) plugs into.
+- `measure_thesis` runs an oracle over every claim in a thesis.
+- CLI: `crucible measure <thesis> --substrate FILE` measures each claim and witnesses the verdicts; the
+  oracle-produced measurements re-derive from disk via `verdicts --verify`.
+- Refactor: the registry-inspecting commands moved to `crucible.registry_cmd` so no module exceeds the
+  size budget.
+
+## 0.2.0
+
+The steelman seam: adversarial refutation as a pluggable shape, the conjecture-and-attack half of
+judgment.
+
+- `crucible.steelman`: a `Steelman` protocol and a `Refutation` (the proposed attack plus the
+  measurable test that would settle it). Adversaries propose what to test; they do not decide.
+- `NullSteelman`: the standing default. Deterministic and invents nothing: it surfaces the claim's own
+  stated falsification as the test, or flags a claim that states no falsification as unrefutable.
+  Custom refuters plug in through the same protocol.
+- `steelman_thesis` runs a steelman over every claim in a thesis, returning the proposed tests in
+  claim order, ready to feed the measurement step.
+- CLI: `crucible steelman <thesis>` prints each claim's challenge and the test it proposes.
+
+## 0.1.0
+
+The P1 foundation: the verdict spine and the witnessed, re-derivable record.
+
+- `crucible.claim`: a `Claim` carrying a content-hash receipt over its assertion and falsification
+  condition; `make_claim` computes it and `Claim.verify()` re-hashes to catch tampering.
+- `crucible.thesis`: a `Thesis` with a seal binding its claims, title, and disposition (so a fenced
+  thesis cannot be relabelled publishable undetected); the seal is over the set, so reordering is not
+  a change.
+- `crucible.verdict`: the differentiator. `verdict_for` is a pure MATCH / DRIFT / UNVERIFIABLE
+  decision from a `Measurement`, with no model in the verdict step. UNVERIFIABLE is fail-closed
+  (no measurement, an unmeasurable deviation, a non-positive tolerance, an unfalsifiable claim, or a
+  measurement bound to a different claim all read as UNVERIFIABLE, never as holding).
+- `crucible.registry`: a content-addressed registry. Claim bodies are deduped and traversal-guarded;
+  `verify` reports MATCH / MISSING / CORRUPT; `verify_seals` catches a swapped or relabelled claim a
+  body check would miss; a tampered thesis is refused on load; re-registration is idempotent.
+- `crucible.assess`: a witnessed `Assessment` that persists its verdicts and measurements.
+  `verify_assessment` recomputes the seals from the stored data; `recheck_assessment` re-derives each
+  verdict from the thesis and the measurements, so a verdict cannot be asserted, only computed.
+- `crucible.cli`: `register`, `assess`, `registry list|verify`, and `verdicts [--verify]`.
+- Zero third-party dependencies; an offline `examples/demo.py`; ruff and mypy clean.

crucible_bench-1.1.0/LICENSE

@@ -0,0 +1,78 @@
+crucible Fair-Source License, Version 1.0
+
+Copyright (c) 2026 Zain Dana Harper. All rights reserved.
+
+This license governs use of the accompanying software ("the Software", the crucible judgment organ). By using,
+copying, modifying, or distributing the Software, you accept these terms. The
+Software is source-available, not open source: the source is published so you can
+read it, run it, and build on it, while commercial use that competes with the
+project is reserved so the project can fund its own continued development.
+
+1. Definitions
+
+   "Licensor" means Zain Dana Harper, the copyright holder.
+
+   "You" means the individual or entity exercising rights under this license.
+
+   "Competing Use" means making the Software, or a modified version of it,
+   available to a third party as a commercial product or service that
+   substitutes for, or offers substantially the same functionality as, the
+   Software or any product or service the Licensor offers using the Software.
+
+2. Grant
+
+   Subject to your compliance with this license, the Licensor grants you a
+   worldwide, royalty-free, non-exclusive, non-transferable license to read,
+   run, copy, modify, create derivative works of, and redistribute the Software
+   for any Permitted Purpose.
+
+3. Permitted Purpose
+
+   A Permitted Purpose is any purpose other than a Competing Use. Permitted
+   Purposes include, without limitation: internal use within your organization;
+   personal use; evaluation; non-commercial education and research; and use in
+   providing professional services to a party that is itself using the Software
+   under this license.
+
+4. Reserved Commercial Use
+
+   A Competing Use is reserved to the Licensor and requires a separate
+   commercial license. This reservation is what funds the project's continued
+   development. To obtain a commercial license, contact the Licensor (see
+   Contact below).
+
+5. Conditions
+
+   You must retain, in all copies and derivative works you distribute, this
+   license, the copyright notice, and all attribution notices. You may add your
+   own notices to changes you make, so long as the origin of the Software is not
+   misrepresented.
+
+6. Trademarks
+
+   This license does not grant any right to use the Licensor's names, logos, or
+   trademarks.
+
+7. Disclaimer of Warranty
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT.
+
+8. Limitation of Liability
+
+   IN NO EVENT SHALL THE LICENSOR BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM,
+   OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+   SOFTWARE.
+
+9. Termination
+
+   If you breach this license, your rights under it terminate automatically. They
+   may be reinstated by the Licensor in writing.
+
+10. Contact
+
+    For commercial licensing or to report a security issue, open a private
+    security advisory at https://github.com/HarperZ9/crucible/security or reach the
+    Licensor via https://github.com/HarperZ9.

crucible_bench-1.1.0/MANIFEST.in

@@ -0,0 +1,6 @@
+include ARCHITECTURE.md
+include CHANGELOG.md
+include requirements-release.txt
+include docs/*.md
+include examples/*.json
+include examples/*.py