Skip to content

Releases

v0.2.12

Choose a tag to compare

@github-actions github-actions released this 14 Nov 15:46
Immutable release. Only release title and notes can be modified.
v0.2.12
3636a79

Release v0.2.12

Date: 2026-11-14

Adds draft secret-surface boundaries and extends library implementation profiles and qualification-harness rules.

Highlights

  • The secret-surface standard
    and SecDR-0002
    define value-free control, observation, MCP and graphical surfaces, explicit
    secret input ports, local CLI/TUI output custody, child and helper boundaries,
    protected file outputs and adopter non-disclosure controls.
  • Repository classes 0.1.2 and
    ADR-0018 extend
    Profile A/B adoption to unsuffixed library+CLI toolkits, document legacy Go
    module cutover and Rust-generated native/WebAssembly TypeScript delivery,
    and retain shared conformance requirements for native Rust/Go twins.
  • Qualification harnesses require independent pack authority for retained-run
    verification, contained subject execution, and separate correctness,
    containment, migration-divergence and telemetry results.

Adoption notes

The secret-surface standard (0.1.0) and repository-classes standard (0.1.2)
remain draft; SecDR-0002 and ADR-0018 remain proposed. Pin an exact release or
commit when adopting these documents.

Explicit caller-named environment inputs and local CLI reveal/export outputs
are separately bounded local data-plane paths. They do not authorize control,
MCP or graphical adapters to receive or forward secret values. Adopters must
verify their own input, output, helper and child-process custody controls.

Repository declarations and class checks remain manual while the planned
taxonomy schema and checker are unshipped. This release changes documentation;
it does not qualify an existing secret-handling product, language binding or
qualification harness.

What a release carries

A Crucible release is a GPG-signed annotated Git tag. It publishes no assets,
so there are no SHA256SUMS or SHA512SUMS files to verify. See
release security.

References

v0.2.11

Choose a tag to compare

@github-actions github-actions released this 13 Nov 21:52
Immutable release. Only release title and notes can be modified.
v0.2.11
9945588

Release v0.2.11

Date: 2026-11-13

Adds the proposed, experimental filesystem-access/v0 contract for portable access relative to a held directory object.

Highlights

  • The filesystem access standard defines
    root-relative names, trusted root acquisition, containment/v0 and
    no-links/v0, bounded reads/listings, exclusive creation, and held-handle
    identity. It distinguishes physical link resolution, mount boundaries,
    reference lifetimes, and per-operation observation points.
  • The schema bundle includes
    operation-specific requests/results, capability reports, admitted and
    observed names, and 62 declarative recipe cases.
  • The repository controls
    exercise schema shapes, logical outcomes, mutation witnesses, and bounded
    native primitive availability. ADR-0020
    records the proposed contract boundary.

Adoption notes

Pin an exact release or commit when adopting this experimental v0 contract.
Validate each runtime cell for its OS, filesystem, backend, operation, profile,
observation point and adversary level. Unsupported requested guarantees require
refusal without fallback.

Schema validity, logical corpus agreement and primitive availability are separate
from production resolver qualification. This release does not qualify concurrent
replacement resistance, Windows reparse handling, mount-boundary enforcement,
or a consumer implementation.

What a release carries

A Crucible release is a GPG-signed annotated Git tag. It publishes no assets,
so there are no SHA256SUMS or SHA512SUMS files to verify. See
release security.

References

v0.2.10

Choose a tag to compare

@github-actions github-actions released this 11 Nov 15:10
Immutable release. Only release title and notes can be modified.
v0.2.10
24c8920

Release v0.2.10

Date: 2026-11-11

Adds a pinned physical Parquet fixture corpus for durable-index/v0, completes the independent logical reader, and tightens durable-record framing and schema validation controls.

This release binds physical fixtures to fixed logical rows, extends independent
logical scenario coverage, and updates the repository's schema-validation
toolchain. durable-index/v0 remains experimental; these fixtures and controls
do not by themselves qualify a physical reader, writer, or storage runtime.

Highlights

Durable-index physical fixtures and logical reader

  • Adds 26 Parquet fixtures and six NDJSON twins under the
    Parquet inventory fixture corpus.
    The corpus covers ZSTD and UNCOMPRESSED codecs, data-page versions 1 and 2,
    both signed and absent size_bytes annotations, multiple row groups, and
    an ordered two-member split of the fixed logical oracle. Twenty negative
    fixtures carry named refusals.
  • The baseline physical fixture controls
    verify the inventory, exact byte lengths and SHA-256 pins, raw logical-row
    schema checks, logical row semantics, and member-set parity. Parquet decoding
    is separate, bounded evidence; the baseline does not decode the members.
  • Extends the independent TypeScript logical reader
    across all authored logical scenario categories, including byte-bound
    bindings, complete projection graphs, cutovers, cross-member rows, and strict
    parsing, with mutation and inventory controls. Structural schema validation
    remains in the Python/goneat gate.
  • Clarifies in the durable-index contract
    that discovery compilers resolving path segments or partitions to an exact
    finite union of literal prefixes emit canonical unicode-prefix/v0 plans.

Durable-record and schema validation

  • Rejects blank and whitespace-only durable-record NDJSON journal lines at
    ingest, including writer-abort and reopen paths. Adds ancestor-seal refusal
    controls for unauthenticated closers and non-current live ancestor journals.
  • Constrains timestamp seconds in the durable-record/v0 and v1 schemas so
    :60 remains a schema-stage refusal across validator profiles, while the
    semantic timestamp checks remain in place. The
    v0
    and v1
    contracts describe the supported timestamp and validator profiles.
  • Updates schema controls for exact JSON-number decoding, format validation,
    Unicode and parser refusals, and validator report metadata. Pins Goneat
    v0.6.8 and the v0.5.15 glibc runner for repository checks.

Upgrade notes

  • Consumers of the durable-index corpus can verify the new fixed members and
    logical twins with the repository controls. Physical decoding and complete
    graph evidence remain separate requirements for R2/W1/W2/W3 qualification.
  • Durable-record consumers should retain ingest framing and semantic timestamp
    checks when updating schemas or validator versions. Existing v0 validation
    remains supported for historical streams.

What a release carries

A Crucible release is a GPG-signed annotated Git tag. It publishes no assets,
so there are no SHA256SUMS or SHA512SUMS files to verify. See
release security.

References

v0.2.9

Choose a tag to compare

@github-actions github-actions released this 08 Nov 14:43
Immutable release. Only release title and notes can be modified.
v0.2.9
0e1e5f9

Release v0.2.9

Specifies the durable-record/v1 retention policy for retired-record body reclamation, designated body-removal stream recovery, and detached canonical stream-seal artifacts; adds the draft identity-evidence/v0 native-process-observation:v0 provider profile; and hardens the RFC 8785 JCS and RFC 3339 instant helper scripts.

This release completes the durable-record/v1 external-body lifecycle surfaces
for policy-bound reclamation of body bytes referenced only by retired records,
quarantined designated body-removal stream recovery via successor journals, and
detached verified stream seals across continuation chains. It also adds the
draft native-process-observation:v0 provider profile under
identity-evidence/v0 and hardens the repository's RFC 8785 canonical JSON and
RFC 3339 instant validation helpers.

Highlights

durable-record/v1 retention policy for all-retired-record body reclamation

  • Eligibility rules and deterministic refusal precedence. Updates
    docs/standards/durable-record-v1-contract.md
    and adds
    schemas/durable-record/v1/removal-eligibility-request.schema.json
    to define when a store may remove external body bytes (digest, length) that
    historical records have referenced once every referencing record across the
    store is retired. Enforces deterministic Precedence 1 -> 2 -> 2b -> 3 -> 4 -> 5
    refusal ordering: designated-stream placement, request/journal wire and domain
    preflight, and target incarnation lifecycle transition eligibility (1,
    refusing ingest, numeric_domain, shape, instant_spelling,
    body_removal_stream, or body_lifecycle), store-wide stream coverage,
    quarantined_designated_streams predecessor-chain completeness, valid cuts,
    and observable continuation ancestry (2, refusing protection_unavailable),
    same-store temporal ordering requiring decision_time >= e["at"] across
    validated cuts (2b, refusing journal_time), active local preservation holds
    and conservative continuation/sealed-ancestor hold dominance (3, refusing
    protected_use), unretired referencing records across latest or superseded
    revisions (4, refusing still_referenced), and policy-bound {id, version}
    removal authorization verification when the referenced set is non-empty (5,
    refusing removal_authorization).
  • Store-wide exclusion fence re-verification. Requires removal_eligibility
    to be evaluated under the store-wide body-removal exclusion fence before
    appending body_removal_started and before any retry_unlink attempt on an
    open removal.

durable-record/v1 designated body-removal stream recovery and detached stream-seal

  • Successor-stream recovery (stream_opened.recovery). Extends
    schemas/durable-record/v1/journal-entry.schema.json,
    schemas/durable-record/v1/stratum-profile.schema.json,
    and docs/standards/durable-record-v1-contract.md
    with Option B1 designated body-removal stream recovery under
    runtime.incarnation_allocation: "prewrite_durable_ledger". Quarantines a
    damaged designated stream without in-place tail rewriting, binds the longest
    valid complete-group prefix (cut_seq, cut_digest,
    quarantined_image_digest) and runtime.quarantined_designated_streams
    predecessor chain, and reconciles every (digest, length) via the 19-row
    R1–R19 table (R1 -> R2 -> R3 -> R4..R19, adding recovery_incomplete to
    the closed refusal vocabulary).
  • Sticky post-recovery carry-forward and multi-hop replay. Preserves
    post-recovery publishing (R7, R9, R13, R19 — transitioning to
    integrity_loss if bytes disappear before republication, never reverting to
    removed or unpublished) and sticky integrity_loss (R6, R10, R16,
    R18 — remaining integrity_loss across clean cuts and subsequent recovery
    hops even if un-republished bytes reappear) until cleared by a new
    body_published(n') with n' > floor. Requires fresh removal_eligibility
    and authorization before re-issuing an abandoned R12/R13 removal.
  • Detached canonical stream seals (stream-seal). Adds
    schemas/durable-record/v1/stream-seal.schema.json
    and
    schemas/durable-record/v1/examples/stream-seal.example.json
    for detached RFC 8785 JCS stream seals binding store, capability,
    stream, cut_seq, cut_digest, effective_restriction_manifest_digest
    (closed {holds, retired, inherited} preimage), sorted/unique transitive
    ancestor_seals, trust_profile: {id, version}, canonical sealed_at,
    provenance, and authorization. Enforces authenticated closer and permanent
    write fencing across the exact transitive upstream boundary closure, zero raw
    trailing bytes, exact fenced cut length, and conservative sealed-ancestor hold
    checks in removal_eligibility.
  • Logical conformance vectors and mutation controls. Expands
    scripts/validate-durable-record-fixtures.py and
    scripts/test-durable-record-v1-controls.py by 183 conformance vectors, 17
    schema reject fixtures, and 107 AST mutation witnesses (to 395 vectors, 66
    schema reject fixtures, and 187 AST mutation witnesses).

identity-evidence/v0 native-process-observation:v0 provider profile (draft)

  • Standalone native process observation. Adds
    schemas/identity-evidence/v0/profiles/native-process-observation/
    (profile.json, evidence.schema.json, README.md, and platform examples)
    plus
    schemas/identity-evidence/v0/examples/native-process-observation.json
    for observing live OS process incarnation and context facts without requiring
    launch or handle possession evidence (status: draft).
  • Visibility vocabulary, namespace descriptors, and Linux /proc classes.
    Defines the seven-state fact visibility vocabulary (observed, not-present,
    inaccessible, unsupported, not-probed, error, unknown) mapped 1:1 to
    report capability status, host-scope and clock/user/PID-namespace descriptor
    semantics, three-class Linux /proc openat2 and magic-link resolution rules
    (keeping magic-link-leaf-not-mount-confined disclosed), u32/u64 integer
    bounds, pre/post incarnation bracketing, and fail-closed projection into
    local-process-session:v0, covered in
    scripts/test-identity-evidence-controls.py.

RFC 8785 canonicalization and RFC 3339 instant helper hardening

  • scripts/rfc8785-canonicalize.py and scripts/test-rfc8785-controls.py.
    Replaces recursive JSON parsing and JCS serialization with an iterative
    implementation enforcing explicit input bounds (--max-bytes, --max-depth,
    --max-object-members, --max-string-bytes), rejecting all 66 RFC 7493 §2.1
    Unicode noncharacters (U+FDD0..U+FDEF and U+..FFFE / U+..FFFF across
    planes 0..16, raw or \uXXXX escaped), surrogate code points, duplicate
    object keys, and out-of-domain integer tokens before arbitrary-precision
    expansion, and adding --check, --digest, --vector, --ndjson-array
    (--head N), and --sort-set CLI modes.
  • scripts/rfc3339-instant.py. Adds max_fraction_digits and
    reject_submicrosecond_nonzero options on parse_rfc3339 and exact
    arbitrary-precision fractional-second ordering in compare.

What a release carries

A crucible release is a GPG-signed annotated Git tag. It publishes no assets,
so there are no SHA256SUMS or SHA512SUMS files to verify. See
docs/security/README.md.

Upgrade notes

  • For durable-record/v1 adopters: Stores reclaiming body bytes referenced
    by retired records must evaluate removal_eligibility under the store-wide
    exclusion fence and verify policy-bound {id, version} removal authorizations
    alongside conservative continuation/sealed-ancestor holds. Stores enabling
    designated body-removal stream recovery must declare
    runtime.incarnation_allocation: "prewrite_durable_ledger" and keep
    runtime.quarantined_designated_streams equal to the successor
    stream_opened.recovery.previous_stream chain.
  • For identity-evidence/v0 adopters: native-process-observation:v0 ships
    at status: draft; projection into local-process-session:v0 fails closed
    with typed refusals when required session incarnation or scope facts are not
    observed.
  • For downstream repositories vendoring helper scripts: Re-pin
    scripts/rfc8785-canonicalize.py and scripts/rfc3339-instant.py to v0.2.9
    to pick up iterative JCS bounds, RFC 7493 noncharacter rejection, and
    sub-microsecond instant controls.

References

v0.2.8

Choose a tag to compare

@github-actions github-actions released this 07 Nov 20:34
Immutable release. Only release title and notes can be modified.
v0.2.8
3b0647d

Release v0.2.8

Defines durable-record (v0 and v1) RFC 3339 instant validation profiles and finite JSON Schema subset admission, deprecates durable-record/v0 for new producers, specifies the durable-record/v1 writer-owned incomplete-append abort boundary and runtime.incarnation_allocation, adds the draft opslead role, and adds workflow supply-chain, key-expiry, and local-path hygiene gates.

This release tightens durable-record (v0 and v1) timestamp validation and
schema-dialect admission, deprecates durable-record/v0 for new stream
production while preserving historical v0 verification, and codifies the
durable-record/v1 writer-owned incomplete-append abort boundary and
incarnation allocation modes (runtime.incarnation_allocation). It also adds
the supplemental draft opslead role prompt and introduces repository gates
for GitHub Actions SHA/digest pinning, release signing-key expiration horizons,
and local-path content hygiene.

Highlights

durable-record (v0 and v1) timestamp profiles, v0 deprecation, and finite JSON Schema subset

  • RFC 3339 instant validation profiles. Updates
    docs/standards/durable-record-contract.md,
    docs/standards/durable-record-v1-contract.md,
    scripts/rfc3339-instant.py, scripts/validate-durable-record-fixtures.py,
    and scripts/test-durable-record-v1-controls.py to enforce ASCII-only
    ([0-9]) RFC 3339 instant validation across every v0 and v1 timestamp
    position: year bounds 0001–9999 inclusive (0000 and UTC year
    underflow/overflow refused), proleptic Gregorian calendar validation,
    unconditional :60 leap-second refusal, and microsecond fractional precision
    (v1 requires 6 fractional digits with Z; v0 accepts Z or bounded
    ±HH:MM offsets < 24:00 and no nonzero digit beyond the sixth fractional
    place).
  • Per-position stage evaluation and v0 source/ancestor checks. Documents
    the per-position Stage 3 (shape) vs. Stage 4 (instant_spelling /
    semantic) evaluation trace, validates v0 journal at timestamps on every
    entry of observed v0 continuation source and ancestor streams (including
    entries beyond cut_seq), validates received v1 reconciliation
    attempted_at, window_covers_from, and window_covers_until positions, and
    adds AST position-deletion mutation witnesses for every timestamp check.
  • Finite JSON Schema Draft 2020-12 subset admission. Enforces a closed
    finite allowlist of JSON Schema Draft 2020-12 keywords across all v0 and
    v1 schemas and rejects sibling assertion keywords alongside $ref.
  • Deprecation of durable-record/v0 for new producers. Marks
    schemas/durable-record/v0/contract.json
    as "status": "deprecated" with "superseded_by": "contract: durable-record/v1".
    Existing v0 schemas, fixtures, and validator controls remain supported for
    verifying historical v0 streams and v1 continuations.

durable-record/v1 writer-owned incomplete-append abort boundary and runtime.incarnation_allocation

  • NDJSON framing and writer-owned incomplete-append abort gate. Clarifies in
    docs/standards/durable-record-v1-contract.md
    that every committed NDJSON journal entry line L ends with a single LF
    (0x0A) without CR (0x0D) and that an unterminated final line (including
    k = L - 1 missing only the trailing LF) refuses at Stage 1 as ingest.
    Codifies the completion gate for rolling back a provably incomplete write
    (0 <= k < L) in-process under continuous reader and writer exclusion:
    verifying SameFile descriptor identity on the truncate handle before
    truncating, truncating back to the recorded prior-cut byte offset, syncing
    the journal file and parent directory, verifying post-truncate byte length via
    fstat, and re-validating the prior complete cut (1..cut_seq).
  • Fail-closed handle poisoning and restart semantics. Requires any
    indeterminate commit (k == L followed by a failed fsync, EIO, uncertain
    write count, or lost exclusion) or any failure during the abort completion
    gate to poison the journal handle in-process against further appends or
    dependent body operations until reopen, and defines the disjunctive reopen
    oracle across crash points around truncate and fsync.
  • Incarnation allocation modes (runtime.incarnation_allocation). Adds
    optional runtime.incarnation_allocation ("effect_dependent" |
    "prewrite_durable_ledger", permitted only when
    deletion.external_bodies == "supported") to
    schemas/durable-record/v1/stratum-profile.schema.json,
    paired with schema reject fixtures and faultpoint controls in
    scripts/test-durable-record-v1-controls.py.

Operations Lead opslead role (1.0.0, draft)

  • Adds supplemental config/agentic/roles/opslead.yaml
    (1.0.0, status: draft, category governance, domains governance,
    coordination, and automation) and
    docs/catalog/roles/opslead.md for accountable
    stewardship of estate operating procedures, seat and identity lifecycle
    records, and operating-convention baselines, acting through explicit grants
    for any privileged step while handing coordination-tool operation to
    dispatch and credential, asset, and security-hardening operations to
    secops or a human custodian.

Workflow supply-chain pinning, signing-key expiration horizon, and local-path hygiene

  • Workflow supply-chain and permission gate (scripts/test-workflow-pins.sh).
    Verifies that every uses: reference in .github/workflows/*.yml is pinned
    to a 40-hex commit SHA with a # v... version comment, every container
    image carries an immutable @sha256: digest, and top-level and job-level
    permissions blocks stay within read-only defaults except for the release tag
    attestation job.
  • Release signing-key expiration horizon (check_release_key_expiry).
    Extends scripts/release-env.sh (wired into
    scripts/release-derive-anchors.sh and scripts/release-verify-anchors.sh
    and tested in scripts/test-release-identity.sh) to inspect
    docs/security/release-signing-keys.asc and config/release/pgp-key-id.txt,
    failing closed when the primary key or pinned signing subkey is expired,
    revoked, invalid, missing an expiration timestamp on derive, or carrying
    ambiguous binding signatures, and emitting a warning on stderr when
    expiration is within 30 days.
  • Local-path content hygiene (scripts/content-check.py). Scans git-tracked
    files for accidental local home paths, macOS/Windows/Linux temporary paths,
    and file:// URLs targeting local user directories, wired into make check.

What a release carries

A crucible release is a GPG-signed annotated Git tag. It publishes no assets,
so there are no SHA256SUMS or SHA512SUMS files to verify. See
docs/security/README.md.

Upgrade notes

  • For durable-record adopters: durable-record/v0 is now marked
    "status": "deprecated" ("superseded_by": "contract: durable-record/v1")
    for new stream production; new streams should target durable-record/v1 while
    retaining v0 readers/validators for historical streams and continuation
    sources. Verify that implementation timestamp parsers enforce ASCII-only digits
    ([0-9]), reject year 0000 (including after UTC offset conversion), and
    reject :60 leap seconds across both v0 and v1.
  • For durable-record/v1 external-body stores: Profiles with
    deletion.external_bodies: "supported" may now declare
    runtime.incarnation_allocation ("effect_dependent" or
    "prewrite_durable_ledger"; defaults to "effect_dependent" when omitted).

References

v0.2.7

Choose a tag to compare

@github-actions github-actions released this 02 Nov 21:26
Immutable release. Only release title and notes can be modified.
v0.2.7
0e34347

Release v0.2.7

Adds proposed identity-evidence/v0 and draft seat-spheres/v0 contracts, extends project-work/v0 with commitment and agent/run provenance fields, adds the draft advisor role, splits SPDX MIT/CC0-1.0 license files, and enforces pre-sign tagger identity.

This release introduces the proposed identity-evidence/v0 contract and four
categorical identity-assurance classifier dimensions, adds the draft
seat-spheres/v0 standing-delegation contract and companion model standard, and
extends project-work/v0 with requested_by, check_by, and agent and run
party kinds. It also adds the supplemental draft advisor role prompt, splits
root licensing into verbatim SPDX LICENSE (MIT), LICENSE-CC0 (CC0-1.0)
and NOTICE, requires pre-sign tagger identity and signing-subkey verification
in scripts/release-tag.sh, and tightens durable-record (v0 and v1)
wire-preflight ordering for large non-protocol integers.

Highlights

Proposed identity-evidence/v0 contract and identity-assurance classifiers

  • Contract and classifiers. Adds
    docs/standards/identity-evidence-contract.md,
    docs/standards/identity-assurance-classification.md,
    four categorical classifier definitions under config/classifiers/dimensions/
    (identity-binding, key-custody, execution-isolation,
    platform-evidence), and the schemas/identity-evidence/v0/ schema, example
    and vector bundle.
  • Observation and report model. Defines immutable observation and evaluated
    report snapshots with separate enrollment identifiers and key descriptors,
    directed execution-isolation boundaries, exact platform-property claim
    references, digest-pinned input_reports provenance, and per-event optional
    time_attribution.
  • Profiles and controls. Includes a local process/session launch-binding
    profile (profiles/local-process-session/) and an experimental 256 KiB /
    depth-16 wire admission profile (profiles/report-admission/) with shared
    wire vectors and batched logical/wire control scripts
    (scripts/test-identity-evidence-controls.py and
    scripts/test-identity-wire-controls.py).

Draft seat-spheres/v0 contract and model

  • Seat view and standing delegation. Adds
    docs/standards/seat-spheres-model.md and
    schemas/seat-spheres/v0/
    (contract.json, seat-view.schema.json, 4 positive examples, 40 negative
    reject fixtures and scripts/test-seat-spheres-controls.sh). A seat view pairs
    a closed seat function (builder, operator, steward, consultant,
    analyst) with optional reports_to, optional almanac_locator, and
    per-subject spheres[] (subject {kind, id}, closed relation lead |
    support | advise | assure | interested, optional allow/deny
    exceptions[] with required reason on allow, and optional since, note,
    cover, review_by, no_apply and expiring measures[]).
  • Rollup and project-work/v0 seam. Specifies read-time rollup rules,
    closed-by-default subject kinds (production, secrets, dns, identity),
    two-level delegation (standing sphere handoff vs. per-packet execution),
    longest whole-segment prefix selection for overlapping subject matches on a
    packet scope with ancestor advise/assure/interested retention, the
    usable project-work/v0 scope grammar subset (<= 63 characters per
    segment, <= 253 total, no . or _) vs. explicit profile mapping tables,
    and per-entry exceptions[].right uniqueness.

project-work/v0 commitment fields and agent / run party kinds

  • Packet commitment fields. Extends schemas/project-work/v0/ready-packet.schema.json
    with optional requested_by (person, role or agent counterparty; never
    unassigned or run) and check_by (strict RFC 3339 instant with a
    required T time part and Z or UTC offset; required on non-terminal
    run-owned packets).
  • agent and run provenance. Extends party records across
    ready-packet.schema.json, project-state.schema.json,
    progress-event.schema.json and control-record.schema.json with agent
    ({kind, id, role, display?}; id matches ^agent-[a-z0-9]+(-[a-z0-9]+)*$,
    role required as the hat worn for the work) and run
    ({kind, id, parent, expires, role?, display?}; canonical uppercase ULID
    id with run- prefix and leading 0–7, parent constrained to
    agent-id or person-id so runs cannot chain, and strict instant
    expires; allowed on packet owner and ledger actor, forbidden on
    requested_by, project-state.owner and control-record.decider).
  • Standardized person-id and semantic validation. Defines a single
    person-id rule (^[a-z][a-z0-9._-]{0,63}$, excluding reserved agent- and
    run- prefixes and leading @ handle punctuation) across all party and
    parent positions and adds
    schemas/project-work/v0/semantic-validation.md
    (SEM-P01 through SEM-P07 and SEM-CASE-01 through SEM-CASE-05).

Strategic advisor role (1.0.0, draft)

  • Adds supplemental config/agentic/roles/advisor.yaml
    (1.0.0, status: draft, category consulting) and
    docs/catalog/roles/advisor.md for client and
    stakeholder engagement guidance, problem framing and decision facilitation,
    with explicit boundary distinctions from analyst, strategist, entarch,
    cxotech and prodmktg.

SPDX license split, pre-sign tagger identity enforcement and durable-record oracle fix

  • SPDX LICENSE, LICENSE-CC0 and NOTICE. Replaces the combined Markdown
    explainer in LICENSE with verbatim SPDX MIT text (LICENSE) and verbatim
    SPDX CC0-1.0 Universal legal code (LICENSE-CC0), moves the dual-license
    scope boundary (CC0-1.0 for documentation, schemas, role prompts and
    conformance vectors/examples; MIT for executable scripts, CI workflows,
    Makefile and test harnesses), scope limitation and trademark notice to
    NOTICE, and sets package.json "license" to "(MIT AND CC0-1.0)".
  • Pre-sign tagger identity and signing-subkey enforcement. Adds
    require_signing_identity in scripts/release-env.sh and invokes it in
    scripts/release-tag.sh before any gpg call so
    THREELEAPS_CRUCIBLE_TAGGER_NAME, THREELEAPS_CRUCIBLE_TAGGER_EMAIL and
    THREELEAPS_CRUCIBLE_PGP_KEY_ID (^[0-9A-F]{40}!$) are required rather than
    warned-and-defaulted and verified against config/release/tagger-identity.txt
    and docs/security/release-signing-keys.asc before signing; runs
    scripts/verify-pinned-tag.sh immediately after tag creation; and includes
    .immutable verification in RELEASE_CHECKLIST.md.
  • Durable-record wire-preflight ordering. Updates
    scripts/validate-durable-record-fixtures.py to catch OverflowError
    alongside ValueError when materializing large non-protocol integer tokens
    above the IEEE 754 binary64 finite range and completes the document-wide
    Stage 1 (ingest) pass before Stage 2 (numeric_domain) protocol-integer
    checks regardless of object member order.

What a release carries

A crucible release is a GPG-signed annotated Git tag. It publishes no assets,
so there are no SHA256SUMS or SHA512SUMS files to verify. See
docs/security/README.md.

Upgrade notes

  • For project-work/v0 adopters (unstable v0/): requested_by,
    check_by and the agent/run party kinds are additive, whereas tightening
    person-id from an arbitrary 1..128 string to ^[a-z][a-z0-9._-]{0,63}$
    (excluding agent- and run-) rejects previously accepted values such as
    @maintainer-1, human@example.test, Human1, agent-human or 65-character
    ids. Adopters should keep historical ledger segments pinned to their
    write-time schema revision and remap legacy person ids via an explicit
    collision-checked identity-source mapping rather than blind in-place
    lowercasing or punctuation stripping.
  • For release tag operators: make release-tag now requires
    THREELEAPS_CRUCIBLE_TAGGER_NAME, THREELEAPS_CRUCIBLE_TAGGER_EMAIL and
    THREELEAPS_CRUCIBLE_PGP_KEY_ID (<40-hex>!) to be exported in the
    environment and verified against config/release/tagger-identity.txt and
    docs/security/release-signing-keys.asc before invoking gpg.

References

v0.2.6

Choose a tag to compare

@github-actions github-actions released this 30 Oct 19:56
v0.2.6
4676660

Release v0.2.6

Durable-record bounds protocol integers at 2^53 - 1 and batches schema validation; role catalog adds draft devsecops, mediaeng and creative prompts and refines secops.

This release tightens contract-defined integer positions across durable-record
v0 and v1 to the I-JSON safe-integer ceiling 9007199254740991
($2^{53} - 1$), formalizes raw-token numeric-domain preflight ahead of binary64
conversion, and batches durable-record schema validation through
goneat validate suite --format json. It also expands the agentic role catalog
with three supplemental draft role prompts (devsecops, mediaeng and
creative) and updates secops (1.1.0) to clarify security-tooling and
continuous-observation boundaries.

Highlights

Durable-record safe-integer wire domain and batched schema controls

  • Protocol safe-integer ceiling. All 53 contract-defined integer schema
    nodes across the 13 durable-record/v0 (record, journal-entry,
    write-receipt, stratum-profile) and durable-record/v1 (record,
    journal-entry, write-receipt, stratum-profile, protection-request,
    protection-receipt, export-request, export-result, body-state-request)
    JSON Schemas declare maximum: 9007199254740991 ($2^{53} - 1$, RFC 7493
    Section 2.2 / RFC 8785 Appendix B) as an explicit protocol interoperability
    restriction. Arbitrary record.payload numbers and the shared general-purpose
    RFC 8785 canonicalizer (scripts/rfc8785-canonicalize.py) are unchanged.
  • Four-stage wire evaluation order. Wire validation runs in ordered stages:
    ingest (RFC 7493 / RFC 8785 syntax, duplicate object-member refusal and
    finite IEEE 754 binary64 parseability), numeric_domain (exact safe-integer
    inspection on raw numeric tokens at protocol integer schema paths before
    floating-point rounding, accepting mathematically integral spellings including
    decimal fractions and canceled exponents within [0, 9007199254740991]
    without expanding huge exponents, while leaving safe negative integers and
    non-numeric JSON types to shape), shape (JSON Schema Draft 2020-12
    validation), and logical semantics.
  • Typed boundaries and counter exhaustion. Implementations MAY use wider
    internal integer types (int64, uint64) and MUST enforce the wire domain
    [minimum, 9007199254740991] at typed APIs, imports and journal boundaries.
    Counter increments (revision, seq, incarnation, and
    seq + group_size - 1) refuse exhaustion at 9007199254740991 without
    wraparound.
  • Batched schema suite validation. scripts/validate-durable-record-fixtures.py
    batches schema checks through goneat validate suite --format json with
    strict 1-to-1 (file, schema) membership and raises RuntimeError on parser,
    numeric-range, schema-load or runner failures so tool errors never satisfy
    negative schema assertions.
  • Control corpus. v0 adds 4 ceiling baseline/reject schema pairs, 1
    canceled-exponent baseline journal and 12 raw NDJSON numeric_domain /
    ingest reject fixtures; v1 grows from 172 vectors, 36 schema rejects and
    75 mutation witnesses to 200 vectors, 45 schema rejects and 76 mutation
    witnesses (including window-above-safe-max, canceled-exponent spellings and
    negative suite-error controls).

Supplemental role prompts (devsecops, mediaeng, creative) and secops 1.1.0

  • devsecops (1.0.0, status: draft, category automation).
    Repository-side security tooling, CI security gates, signing and verification
    automation, credential-lifecycle tooling and supply-chain pinning without live
    secret values, custodianship grants or signing authority.
  • secops (1.1.0). Distinguishes secops from devsecops and
    watcher, routes security-tooling remediation to devsecops while keeping
    general repository software remediation with devlead, and assigns continuous
    observation to watcher or detection tooling rather than a standing-privilege
    secops seat.
  • mediaeng (1.0.0, status: draft, category agentic). Deterministic
    audio, video, graphics, vector, DSP, codec and rendering pipelines with
    explicit signal, timing and color-space invariants, bounded stream/memory
    execution and shell-free external-encoder invocation.
  • creative (1.0.0, status: draft, category agentic). Structured
    musical arrangement, video editing, vector illustration and procedural media
    craft under human artistic direction, explicit asset/provenance hygiene and
    clean boundaries with mediaeng, uxdev, infoarch and secrev.

What a release carries

A crucible release is a GPG-signed annotated Git tag. It publishes no assets,
so there are no SHA256SUMS or SHA512SUMS files to verify. See
docs/security/README.md.

Upgrade notes

  • For durable-record/v0 and durable-record/v1 implementers: protocol
    integer fields (revision, length, seq, group/group_size,
    incarnation, window, counters, cuts and source pins) are bounded at
    9007199254740991. Journal readers and wire validators must inspect raw
    numeric tokens at protocol integer paths before floating-point conversion and
    map integral or safe-magnitude violations to numeric_domain; stores using
    int64 or uint64 internals must enforce [minimum, 9007199254740991] at
    API, import and journal boundaries and refuse counter exhaustion without
    wraparound. Existing journals and records whose protocol integers lie within
    [0, 9007199254740991] remain valid with unchanged digests.
  • For repositories vendoring durable-record controls:
    scripts/validate-durable-record-fixtures.py imports
    scripts/rfc3339-instant.py and runs batched schema checks via
    goneat validate suite --format json (goneat v0.6.5+).
  • For repositories vendoring role prompts: new supplemental draft prompts
    config/agentic/roles/devsecops.yaml (1.0.0),
    config/agentic/roles/mediaeng.yaml (1.0.0) and
    config/agentic/roles/creative.yaml (1.0.0), plus updated
    config/agentic/roles/secops.yaml (1.1.0), are available under
    config/agentic/roles/. schemas/agentic/v0/role-prompt.schema.json and the
    remaining canonical role prompts are unchanged.

References

v0.2.5

Choose a tag to compare

@github-actions github-actions released this 29 Oct 20:26
v0.2.5
8021d2c

Release v0.2.5

Role prompts add execution continuity; contract controls fix UTF-8 subprocess decoding and large integer body lengths.

This is a patch release. It adds no contract family and changes no schema or
contract specification. It updates three canonical role prompts with
execution-continuity guidance and fixes two control-script defects in
subprocess output decoding and integer body-length validation.

Highlights

Role prompt execution continuity

  • Shared continuity guidance. devlead (1.2.0), devrev (1.3.0) and
    uxdev (1.2.0) add a shared Execution continuity block in context and
    two mindset.principles entries: carry out the next authorized, in-scope
    action after each result; treat progress reports as intermediate updates
    rather than handoffs; name the blocking dependency, missing authority,
    unavailable capability or unresolved decision before yielding with unfinished
    work; continue independent in-scope work when a blocker affects only part of
    the task; investigate failed checks rather than treating them automatically
    as blockers; preserve verified state and the next authorized action across
    handoffs and resumes; and stop when the assigned outcome completes.
  • Role-specific loops. devlead carries implementation through required
    checks, correction of discovered issues and authorized review handoffs
    without bypassing independent review. devrev carries review through
    inspection, proportionate checks, an explicit disposition and re-disposition
    on revised packets without taking over implementation. uxdev carries
    interface work through implementation, observation and explicit reporting of
    unavailable devices or assistive technology as verification gaps.
  • Unchanged boundaries. Existing authority and does_not blocks,
    schemas/agentic/v0/role-prompt.schema.json and the remaining role prompts
    are unchanged.

Control script fixes

  • UTF-8 subprocess output decoding. Text-mode subprocess.run and
    subprocess.check_output calls across the contract and permission control
    scripts specify encoding="utf-8" and errors="replace" instead of the host
    locale's default encoding. Diagnostics containing non-ASCII or malformed
    bytes no longer fail under a cp1252 default on Windows; exit-code checks
    retain their behavior, and scripts/test-portability.py exercises stdout and
    stderr capture on zero and nonzero exits under a cp1252 fallback.
  • Large integer body lengths in durable-record/v1 controls. integral() in
    scripts/test-durable-record-v1-controls.py checks exact int values
    (value >= 0) before math.isfinite, avoiding OverflowError for integers
    above the floating-point range while continuing to exclude booleans, integer
    subclasses, negative integers, fractional floats, non-finite floats, null and
    text. Durable-record/v1 schemas, vectors and contract rules are unchanged.

What a release carries

A crucible release is a GPG-signed annotated Git tag. It publishes no assets,
so there are no SHA256SUMS or SHA512SUMS files to verify. See
docs/security/README.md.

Upgrade notes

  • For repositories vendoring role prompts:
    config/agentic/roles/devlead.yaml (1.2.0),
    config/agentic/roles/devrev.yaml (1.3.0) and
    config/agentic/roles/uxdev.yaml (1.2.0) carry updated context and
    mindset.principles entries. Re-vendor at this tag if adopting execution
    continuity.
  • For repositories pinning contract controls: re-pinning picks up
    locale-independent UTF-8 subprocess capture across the Python control scripts
    and large-integer length handling in
    scripts/test-durable-record-v1-controls.py.
  • Schemas, contract specifications and release toolchain pins are unchanged.

References

v0.2.4

Choose a tag to compare

@github-actions github-actions released this 28 Oct 18:46
v0.2.4
f49f7bd

Release v0.2.4

Durable-record/v1 records body lifecycle; release tag tooling closes four silent defaults.

This release adds journal entries that record the publication and removal of
bytes held by body references, so a removal leaves portable evidence that can
be told apart from loss. It also moves the checks that the v0.2.3 release made
by hand into the release scripts. The change to durable-record/v1 adds fields
and entry types; existing v1 records, digests and pins are unchanged. The v0
family and every other contract family are unchanged.

Highlights

Durable-record/v1 body lifecycle

  • Designated stream. A store whose profile declares
    deletion.external_bodies: supported names runtime.body_removal_stream,
    an ordinary v1 stream. The profile names one exactly when external bodies
    are supported. That stream carries only stream_opened and the three
    lifecycle entry types; a lifecycle entry anywhere else is refused.
  • Three entries. Each names a body by {digest, length} and an
    incarnation, a positive integer that strictly increases per body, with
    gaps permitted. body_published commits a publication. body_removal_started
    is written before any byte is removed and carries the decision: reason
    (retention, operator or rights_restricted), provenance and an optional
    authorization. body_removed is written after the bytes are observed absent;
    its at is completion time.
  • Transitions. A removal starts only from a live latest publication and
    completes only on that incarnation's open start. A later publication
    abandons an open removal. A completion or retry for an older incarnation is
    refused. A start alone is not evidence of removal.
  • Fencing and eligibility. Publication, removal and republication of a
    body are fenced by incarnation through their physical effects. Lifecycle
    entries grant no removal eligibility: removal must honor every applicable
    hold in every stream sharing the bytes, and physical removal stays
    fail-closed until a removal policy is specified.
  • Reader states. At a consistent cut, with an observation of the bytes that
    agrees with it, a body is available, integrity_loss, removal_pending,
    removed, publishing or unpublished. A failed or unknown observation is
    none of these.

New refusals are body_removal_stream, body_lifecycle and
body_observation; a new body-state-request schema describes the logical
state step. The v1 logical controls grow from 124 vectors, 25 schema rejects
and 53 mutation witnesses to 172, 36 and 75. Every v0.2.3 vector gives the same
outcome under this release. These are logical fixture controls: they qualify
no store, fencing, unlink ordering or concurrency.

Release tag tooling

  • Signing keyring. make release-tag refuses a signing keyring that is the
    default keyring by either gpgconf's homedir or the account home from the
    user database, and stops if either cannot be resolved.
  • Signer. Signing uses OpenPGP through gpg. The signing command pins
    gpg.format, gpg.program and gpg.openpgp.program on its command line,
    which overrides Git signing configuration from files and Git configuration
    environment variables. It uses gpg from the trusted PATH and exports
    GNUPGHOME from the validated dedicated-keyring input. A configured value
    the pin overrides, such as a global gpg.program naming a wrapper, is
    reported and does not stop the release; the step stops only if the pin
    would not take effect.
  • Push transport. make release-push-tag fetches, checks, pushes and
    confirms over https://github.com/3leaps/crucible.git, not origin. The org
    token direnv loads is the only credential, passed through gh's credential
    helper. git runs with an empty home, no global or system configuration, and
    no proxy, GIT_SSL_* or curl-trace environment. URL rewrites, extra headers,
    cookie files, proxy, TLS and credential-username settings are refused, and
    the refusal names only their kind and scope.
  • Read-only ruleset check. The release workflow reports a bypass list it
    cannot see as not checked, never as a match.
  • The one-time v0.2.3 tag ceremony section is removed from
    RELEASE_CHECKLIST.md; tags are made with make release-tag and
    make release-push-tag.

What a release carries

A crucible release is a GPG-signed annotated Git tag. It publishes no assets,
so there are no SHA256SUMS or SHA512SUMS files to verify. See
docs/security/README.md.

Upgrade notes

  • For durable-record/v1 implementers: a store that supports removing
    external bodies names body_removal_stream in its profile and records the
    lifecycle there. A store that does not support it needs no change. Existing
    v1 journals remain valid.
  • For release maintainers: run the release with an org .envrc above the
    repository that sets GH_TOKEN; the push no longer uses origin or a stored
    login.
  • durable-record v0 and every other contract family are unchanged.

References

v0.2.3

Choose a tag to compare

@github-actions github-actions released this 27 Oct 21:51
v0.2.3
0a93e24

Release v0.2.3

Durable-record/v1 gains continuation streams and restriction review.

This release adds a journal representation for reviewing restrictions on a
stream that re-records another stream's content, so that pending review
travels with the journal instead of living in implementation state. It also
clarifies four checks in the draft repository-classes standard. The change to
durable-record/v1 adds fields and an entry type; existing v1 records, digests
and pins are unchanged. The v0 family and every other contract family are
unchanged.

Highlights

Durable-record/v1 continuation streams and restriction review

  • Continuation. A v1 stream that re-records content from another stream
    declares continues on stream_opened: the source journal's capability
    (contract: durable-record/v0 or contract: durable-record/v1), its stream
    and a source cut. Each re-recorded appended or revised entry carries
    imported_from, the exact source pin it re-records.
  • Cut digest. A source cut is named by cut_seq, which ends a complete
    group, and cut_digest, the SHA-256 of the RFC 8785 JCS bytes of the source
    entries through that cut as one array. It binds history; it does not by
    itself prove the cut is current.
  • restrictions_reviewed. A new journal entry type, its own atomic group,
    covering the destination cut immediately before it. It binds the reviewed
    source cut, a digest of the effective source restriction manifest
    (qualified holds, retirements and inherited reviews), a digest of the
    destination's applied manifest, an authorization reference and provenance.
    A review's source cut may advance beyond the opening cut, provided the
    opening prefix is unchanged.
  • Serving fails closed. Serve, export and reuse of a continuation are
    refused as restrictions_pending until a current review exists. A later
    import, a destination tombstoned, untombstoned or retired entry, or a
    change in the effective restrictions of the source or any ancestor makes
    review pending again; ordinary destination content writes do not. The
    manifests describe effective state, not event history.
  • Observed sources are validated. Every observed source and ancestor
    journal is checked under its own family before its restriction state is
    used. An invalid or malformed source is refused as continuation.

New refusals are restrictions_pending and continuation. The v1 logical
controls grow from 92 vectors, 21 schema rejects and 34 mutation witnesses to
124, 25 and 53. Guards that have a vector but no single-guard mutation witness
are named in the checker.

These are logical fixture controls. They qualify no store. Mapping source
restrictions to re-recorded destination pins, authorization, authoritative
observation of the source, and serializing the currency check with release
remain adopter duties.

Repository classes clarifications (draft 0.1.1)

  • C5: a version subcommand with --extended is required; a
    --version flag alone does not satisfy C5. Each reporting verb is checked
    with --format json, or without the flag when JSON is its only output. A
    verb whose stdout is the transformed artifact is exempt if the CLI has a
    JSON reporting verb.
  • C3: test-only and harness variables count.
  • C4: a repo whose release ceremony needs host tools SHOULD also provide
    make doctor; it is not in the minimum target set.
  • P1: the @3leaps/ npm scope is the reservation. For PyPI, the README
    names the intended distribution.

What a release carries

A crucible release is a GPG-signed annotated Git tag. It publishes no assets,
so there are no SHA256SUMS or SHA512SUMS files to verify. See
docs/security/README.md.

Upgrade notes

  • For durable-record/v1 implementers: a store that re-records content from
    another stream declares continues, marks imports with imported_from and
    appends restrictions_reviewed before serving that stream. A store with no
    continuation streams needs no change. Existing v1 journals remain valid.
  • For classed repositories: a CLI needs a version subcommand to meet C5.
  • durable-record v0 and every other contract family are unchanged.

References