Skip to content

AOCI-CODE v0.2.0-rc3

Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 20 Nov 12:15
· 3 commits to main since this release

AOCI-CODE v0.2.0-rc3 is built from 0a00a2b952ca6f6c40556b0fc37d4230baac98ae.

The third 0.2.0 candidate makes the first build faster and folds in a week of
contributor fixes. A first build now issues three sibling batches by default
and falls back to one batch by itself when only one session takes them, so a
single Host loses nothing; on a 798-file real repository three sessions
finish in half the rounds. Ten contributor pull requests landed, among them
Database Evidence fixes, a Git-untracked source diagnostic, and a repair
Finding for a Code object sent as object_ref; init also warns in a
directory without Git.

Upgrading: a repository governed by v0.2.0-rc2 needs no migration. Three
Database Evidence fixes change the fingerprint of an affected table once
(PostgreSQL index direction, MySQL defaults kept verbatim, SQLite non-ASCII
identifiers): the first database verify after upgrading reports that table
as drifted, and the normal accept flow clears it. Use this binary on every
host that reads such a source: v0.2.0-rc2 refuses newly saved MySQL Evidence
that keeps a default it would have trimmed. Rolling back follows
docs/rollback.md; for such a source, also check out the formal assets
committed before that accept.

Changes:

  • aoci_update_entry names a Code candidate sent as object_ref: "code:<path>" as a repairable code_object_ref_requires_path finding that
    points to path, instead of routing it to Database binding and reporting a
    misleading Database batch or SHA error. Nothing is written and an attached
    Observe review is not recorded (#192, PR #197 by @dayebishouji).

  • aoci init in a directory with no Git repository warns that no ignore file
    applies (.dvignore, .hgignore and similar are not read), so build output
    is an index candidate, and hands the command that excludes directories
    before the first scan. docs/install.md states the consequence (#184).

  • pgx 5.13.0 (dependabot #195). It returns an error instead of panicking when
    a PostgreSQL server sends fewer row values than declared fields
    (GHSA-w9rp-vfrh-q8vv). No new modules; the license text is unchanged.

  • update-entry --preview no longer requires --source-sha256. The help
    text has always said the binding is required unless --preview is used,
    but the volume plan refused a binding-less preview with
    source_binding_required and then compared the source fingerprint against
    the empty binding. A preview without a binding now renders the proposed
    entry and writes nothing; a binding that is given is still checked, and a
    formal write without one is still refused (#191).
    Contributed by @cklxx in PR #194.

  • aoci scope status warns about Git-untracked sources that the index or
    Baseline already references, so a checkout does not publish an Entry its
    teammates' clones cannot see. --json adds git_untracked_paths when
    nonempty; the warning is advisory and the query writes nothing (#183, PR
    #186 by @dayebishouji).

  • A negated Git ignore rule such as !AGENTS.md keeps the path visible.
    git check-ignore -v reports the matching negative rule with success, and
    the path was treated as ignored, so init dropped its postimage for an
    unignored AGENTS.md (PR #187 by @Afloat16).

  • The fast Git HEAD reader defers to Git when an existing loose ref or
    commondir cannot be read as a plain file, instead of falling through to an
    older packed ref and binding the wrong commit (PR #189 by @Afloat16).

  • ledger.Recent keeps only the requested number of events in memory while it
    still counts corrupt lines across the whole file (PR #188 by @Afloat16).

  • Database Evidence fixes. PostgreSQL index keys record their direction, so an
    ASC to DESC change is drift (PR #190). MySQL column defaults are kept
    byte for byte, so ' active ' and 'active' no longer share a fingerprint
    (PR #193). SQLite identifiers that start with a non-ASCII character, or
    contain the dotless ı, are no longer read as keywords (PR #185). A new
    snapshot of an affected table changes its fingerprint once and follows the
    normal drift and accept flow. All three by @Afloat16.

  • A repository with a Database Volume reuses Overview deliveries. Such a
    repository took the live path on every chunk and proof call, re-running
    governance each time, because Database Evidence was thought to change
    without its bytes changing. Database governance reads only the accepted
    Database Baseline and the Evidence files, so the reuse guard now binds
    their digests; a changed file stops the reuse as a changed source does.
    Incremental (delta) Overviews become available to these repositories too.

  • A MongoDB source can be declared (contributed by @dayebishouji, PR #172,
    the declaration step of #135). database source add --engine mongodb --database-name app --credential-env AOCI_DB_APP_URI saves the source;
    its namespace is the database. Access, inspect, snapshot, and verify answer
    database_engine_not_implemented before any credential lookup or
    connection, and an enabled MongoDB declaration owes no Evidence or Database
    Volume, nor does a disabled one or a repository with only such
    declarations. A source id whose tables already carry Database Entries
    cannot be switched to MongoDB until they are removed. No driver is added.
    Earlier binaries refuse the engine, so every machine sharing such a
    repository needs this release.

  • The Attestation Challenge asks about important Entries and changes with the
    index. Each stratum drew by a fixed per-object key, so two deliveries of a
    slightly changed index asked nearly the same ordinals, mostly
    low-information files. Each stratum now draws its highest-C Entry, the tie
    broken by a key salted with the delivered identity; a delivery and its
    proof still draw the same targets.

  • A new Entry is written in path order inside its section. It was appended
    after the section's last Entry, so a new _a_test.py landed after
    sampling.py, moving the ordinal a reader cites. A section that was never
    in order is left as it is around the insert; new sections still go last.

  • The scope proposal init shows no longer lists directories Git ignores. A
    build or install tree under .gitignore crowded the five largest
    directories a person reads to decide the first scope, though nothing in it
    can enter the index.

  • Narrowing the scope before the first Entry is written no longer asks for
    approval. Every unauthored source leaving the Index role counted as a
    coverage reduction, so focusing a fresh repository on one directory went
    through a preview and a person's approval although nothing had been
    authored that could be lost. While the index holds no Entry such a change
    applies under the posture's ordinary rules; once one Entry exists a
    narrowing that drops an unauthored source waits for a person again.

  • An open cognition optimization pass can be replaced and is visible. A
    request with object_refs while a pass was open was refused as
    cognition_optimization_object_refs_only_allowed_on_initial_request, and
    the only way to close an unwanted pass was to submit its Entries as
    unchanged, which vouches for Entries nobody read. Now such a request
    replaces the open pass, changing no Entry, and reports dropped_open_pass;
    the dropped pass's issued batch is retired, so submitting it writes nothing;
    aoci status shows an open pass as open_optimization_pass.

  • The authoring contract states the R limit the write enforces. Under an
    enforced cognition budget, the default for new repositories, R is also
    limited by importance in UTF-8 bytes (C9 542, C8 422, C7-5 272, C4-1 152
    by default), tighter than the 360-rune FRAS limit the contract stated; a
    model learnt it only from a refused batch, half the batches of a first
    build in one report. The contract now carries the bands, so the first
    batch states every limit the write checks.

  • aoci_get_entries no longer answers with another file's Entry. A request
    was normalized before the lookup (trailing space trimmed, backslash read
    as a separator), so asking for a real file whose name ends in a space or
    holds a backslash returned the Entry of the file the normalized name
    denotes, with nothing in the answer to show it. The path as sent is now
    looked up first, and normalization serves only a path that names no other
    file. An answer line whose identity holds ], a quote, a backslash, or a
    control character writes it as a JSON string, so a reader can always find
    where the identity ends; every other line is unchanged. Reported by an
    embedding host.

  • A first build issues three sibling batches by default. Users reported the
    first build as the slow part, and the parallel batches that shorten it were
    off unless a team found the setting. code_cognition_parallel_batches now
    defaults to 3 (ceiling 4, 1 keeps one batch per Maintain), and under any
    value siblings are issued only for work one batch cannot hold: work that
    fits one batch, which is everyday maintenance, is the single batch it was,
    byte for byte. A Host that runs no subagents needs no setting and loses no
    speed: when a sibling has applied and the others were never handed to any
    session they are released, so one session alone gets a full first batch
    from then on and reaches aligned in the rounds it took before. The response
    that lists siblings says so, and its instruction line is now counted in
    the transport budget, which it was not. A sibling listing no longer carries
    target paths (batch_id, included, state only): they took a quarter of
    every batch. A repository that set the key keeps its value.

  • Parallel batches hold under real concurrency. Running three sessions at
    once on a real repository, which no suite did, found defects present since
    0.2.0-rc1 behind the off-by-default setting: a sibling that planned while
    another applied was refused as code_candidate_volume_preimage_stale
    (two sessions usually got through, three did not); two siblings taken at
    the same moment could lose one delivery record; a sibling that dropped an
    orphan left its transaction pending (code_parallel_applied_persist_failed);
    an update wave whose Entries stood unchanged never completed its plan; and
    a Maintain that failed to issue a batch answered aligned. Plan records are
    now read and written under the index lock, planning accepts any state the
    plan has been in while the write is still proven under the lock, a
    zero-write sibling and a delete are recorded, and an issuance failure is
    reported as one. The server that was handed a sibling answers the same one
    when asked again, as a single batch always was.

  • A batch that drops an orphan beside its Entries closes after an interrupted
    write. Cut between the Volume write and the Baseline, the same batch
    submitted again was refused as removal_target_missing, because the Entry
    it removes was already gone, and its transaction stayed pending with no
    request that could close it. The removal that landed is now recognised by
    the receipt of that write, and a batch that carried only removals closes
    the same way instead of answering cross_volume_write_not_supported, as
    does one that dropped a Code orphan beside Database Entries. While such a
    cut write is pending, another batch is refused with zero writes
    (entries_other_transaction_pending) instead of writing over the Volume
    the pending one must close on.
    Present since removals ride the batch (0.2.0-rc1), with or without
    parallel batches.

  • A batch no longer has to copy hashes back. An aoci_update_entry batch item
    may carry only its path (a Database item its object_ref) and its
    new_entry; the server completes source_sha256 and candidate_id from the
    issued batch that code_batch_id (or batch_id) names and checks them as
    before, so a source that changed after Maintain is still refused with zero
    writes. Copying them remains accepted and a wrong copy still answers its
    binding finding. On a first build this removes two 64-character values per
    candidate from every submission, and the copying mistakes that came with
    them. The runtime rules, the tool description, and the AGENTS block say so;
    run aoci init --agent <host> to refresh an existing AGENTS block. Only a
    field left out is completed, an empty value that was sent is refused as
    before; a batch nothing can be completed for records no Observe review
    either. An older server refuses the short form at its input schema.

  • A compaction reload can no longer be proven without being read. The Host
    confirmation echoes a SHA-256 that the first Chunk prints, and an unchanged
    index has the SHA-256 it had before: fetch Chunk 1 of the reload, submit the
    previous delivery's proof again, and the answer was confirmed, complete, and
    reliable. On a Legacy layout a session that requested no delivery at all
    got the same. A confirmation now counts only for a body the serving process
    has sent to its end as the current delivery of that Host session and
    requested scope; anything else is host_delivery_incomplete with
    server_delivery_complete: false, and the Host finishes the chain and
    confirms again. There is one current delivery per Host session and scope:
    a fresh request that is answered with a body replaces it, superseding every
    delivery the session held for that scope (their v2 cursors ask for a
    restart) with the proof halves remembered for it, so neither an earlier
    confirmation nor an earlier Attestation latches onto a reload or closes its
    attempt; a capacity stop, an empty delta, and a refused request send
    nothing and change no delivery (a refresh reason a refused request declared
    stays declared), and a proof or a continuation that was on its
    way when its delivery was replaced asks for a restart. Two MCP sessions of one server no longer prove each other's
    delivery. After a server restart a v1 cursor still returns its Chunk, but a
    confirmation needs a fresh request in the new process. Present since the chunked
    delivery was introduced; found by the project's own reviewers.

  • The Root overview can be authored. An index built by init, scan, and
    Maintain delivered #Global-Invariants: - with every Overview and had no
    way to write it: only the onboarding planner authored the Root. Once the
    index is aligned, Maintain and the final Apply now carry root_overview,
    an optional invitation, and aoci_update_entry takes
    root_overview {project, global_invariants, root_sha256}: two single lines
    (200 and 600 characters), written with the Baseline record of the Root as
    one receipted transaction that the next Maintain rolls forward if it was
    cut short. Alignment never depends on it; none is a valid answer. The
    tool surface stays nine tools; the input schema gains one optional object.
    Finish a pending root-overview.json receipt before rolling back to an
    earlier binary, which does not know its kind.

  • A merge of two branches that each maintained the index now has a named way
    out. Taking one side's .aoci/baseline.json alone left
    code_volume_unbaselined, and the blocked Maintain answered
    resolve_blocker with no command, naming an authoring finding as the
    blocker. It now answers restore_formal_assets_from_one_commit, the finding
    carries cause=changed_after_baseline, and next_commands holds the one
    git checkout {commit} -- <Root> <Meta> <Volumes> .aoci/baseline.json for
    this repository; after it, Maintain returns what the other side changed.
    The Guide's stop names the same, a pending Scope Change no longer hides
    the drifted Volume, and a Baseline still holding conflict markers answers
    with the same command instead of a bare internal code. No new command; troubleshooting documents the merge.
    Reported by aoci-agent.

  • Maintain on a Volumes v1 repository whose assets do not load (a Volume
    holding merge conflict markers, a missing Meta) answered the Legacy
    read-only stop and pointed at the migration. It now answers the load
    failure.

  • The delta base and the probe pass are each Host session's own. Two MCP
    sessions of one server shared them, so a session that had received no body
    could be answered an empty delta marked reliable on the strength of the
    other session's delivery and probe; it now gets the complete scope with
    delta_base_unknown. A stdio server has one session and is unaffected.
    Found by the project's own reviewers.

  • The runtime rules and the AGENTS block said that one object, Tag, or F
    mismatch fails the Attestation. The rule has long been the pass share: at
    least 80 percent of the ordinals fully correct with at most one object
    identity miss. Both now say so, in both locales.

  • The model's other self-reported numbers decide nothing either:
    coverage_percent, reported_entry_count, and reported_estimated_tokens.
    Coverage was a self-assessment with a threshold of 95 behind it; the Entry
    count and token estimate are printed in the delivered metadata, so matching
    them proved only that the model copied them. A passing Attestation now needs
    the current identity envelope, the Challenge, and no reported truncation;
    usable cognition needs confirmed delivery, that envelope, and no reported
    truncation. truncation_detected keeps its weight, as an admission against
    the reporter. The three numbers stay required, recorded, and shown, and
    their failure-reason tokens stay in the vocabulary but are no longer
    emitted. A report that passed before still passes.

  • system_mastery_percent decides nothing. It was a self-assessment with a
    threshold behind it: a model that answered the whole Challenge correctly
    and honestly reported less than 80 was graded cognition_assimilation: partial and model_cognition_usable: false, with no reason given, so the
    reliable way to pass was to report 80. The number is still required,
    recorded, and shown; complete assimilation and usable cognition now follow
    from confirmed delivery, the Challenge, and aligned governance alone (see
    the entry above for the other self-reported numbers). A person reading the number judges whether it is
    enough. No input or output field changes shape; a report that passed before
    still passes. Reported by a host that built scipy's index (A3).

  • A batch is sized by what it asks a model to read, not only by what fits the
    response. One batch used to name two ten-thousand-line files, and on five
    real trees the largest batch read 28,000 to 153,000 source lines against a
    median of 4,000 to 8,500. A Code batch is now also cut before its source
    passes 20,000 lines, and a larger file travels alone; first builds on those
    trees take 0 to 19 percent more rounds. authoring_batch reports
    source_lines and source_lines_budget, and scan and init print the
    total reading of the first build beside the round count (source_lines,
    source_lines_per_round in --json). The two wordings of how deeply to
    read, in the runtime rules and in the batch instructions, are now one
    sentence. Reported by a host that built scipy's index (A2); the machine
    reports the volume and does not judge the reading.

  • Dependency updates, none of which changes the release module set (26) or a
    license text: golang.org/x/sys 0.50.0, github.com/spf13/pflag 1.1.0,
    github.com/ncruces/go-sqlite3 0.37.0 with its go-sqlite3-wasm/v6
    6.5.35401 translation, and the sigstore/cosign-installer Action 4.1.3
    (Cosign 3.1.4). The SQLite driver now begins IMMEDIATE transactions by
    default; the catalog collector opens a read-only transaction, which stays
    DEFERRED, so collection is unchanged. The license gate's MIT-0
    recognition moves to the new translation version, same LICENSE bytes.

See docs/install.md and docs/supply-chain.md for asset verification.