Skip to content

Onus v0.11.0

Latest

Choose a tag to compare

@github-actions github-actions released this 14 Oct 06:42
94a5aee

The manifesto's gaps, closed: every agent call checked and logged, scoped Onus Cloud tokens, escalations and a blocked channel, risk inputs and a learned model that only raise lanes, held-out suites from the map, a behaviour diff, coverage, the production loop, a human lane that waits for an owner, and one provenance record per change.

  • The door log and Onus Cloud's calls reach the provenance of changes made through Onus Cloud and CI (onus help provenance): an agent attaches its task's slice of the door log to its pull request with onus_cloud_attach_evidence (doorLog: true; the server cuts the slice from its own log) or onus cloud evidence <pull> --door-log --task <task> (--run is now optional). The slice is the run of entries from the task's first to its last (new schemas/door-log.schema.json). Through onus mcp --token it carries the door's inspection of the token it holds, never the token, so a change made through Onus Cloud by an agent that never escalated has its token on record (new token.source: attached, ranked below every other source). Onus Cloud passes these on once it keeps them; an older one refuses a door log on its evidence route.
    • onus ci pr gains --audit FILE, and onus provenance --audit reads the slice as well as a whole log. The chain is checked over the slice from its first entry; the record keeps the task's entries with doors.source: attached and whether they verified. A slice that does not verify is recorded as not intact, with the entries of the task it names and the reason in the doors gap; one of another task keeps no entries and the gap names both tasks. A slice is the agent's word, since anyone can build one that verifies: the doors gap stays, narrowed to say so. Its decisions on escalations count only when it verifies and is the change's, and Onus Cloud's decision is recorded over them whatever its state, the escalations gap naming any disagreement. A door log that does not verify, a slice or a whole log, no longer gives the token or the task. A door log that holds nothing of the change's task, or reaches a run that does not know the task, leaves the doors gap; onus ci pr gains --task.
    • onus ci pr and onus provenance gain --calls FILE: Onus Cloud's log of the calls made under the task token (new schemas/cloud-calls.schema.json; the API's {"calls": [...]} with createdAt and credentialId is read too). The record sums them up in doors.calls, marked source: onus-cloud: totals, the counts for each route and scope by decision, the token ids, and every denial (at most 100). Calls that name no task are counted as the change's and shown as untasked; with no task known, the doors gap says every call given was counted. Calls alone leave the doors gap, narrowed: they are Onus Cloud's word, not the agent's door log.
    • onus ci pr --submission FILE takes the agent's own submission: the record keeps its token (token.source: agent-submission) and the escalations it lists, when it is for one of the pull request's commits.
    • The action gains a submission input, and otherwise finds one on the records branch at submissions/<pull request number>.json or submissions/<head commit>.json, for ci pr and, through the new onus provenance --agent-submission FILE, for the provenance rebuilt at close. Both take only its token and escalations, and only when it is for one of the pull request's commits. onus ci records pull copies those into the records folder, and a push keeps whatever else is on the branch. onus help ci says what the action cannot know: the token itself, the door log, and what Onus Cloud keeps.
    • Onus Cloud keeps the slices agents attach and passes one cut at the head with --audit (the change's task's, and the first attached, so a later slice cannot displace the agent's), the calls made under the change's scoped token with --calls, and, when no escalation or slice gave the door's inspection, the scoped token's own with --token-inspection. Its pages label the token sources agent-submission and attached. Known gap: an attached slice is the agent's word, so the doors gap stays in every hosted run, narrowed to say so.
    • None of this input stops ci pr, and a door log or calls file that cannot be read stops onus provenance neither: each is a warning and a gap. Only the fields named are read from a call; the API's others (path, userAgent, credentialName) never are. A call with a token, or a field read that looks like one (an Onus Cloud token or API key, a PASETO, a Biscuit), is left out with a warning that names the field, never the value.
    • A token from the agent's submission is marked token.source: agent-submission and ranks below the door's word (audit, inspection): it is plain JSON, possibly from the records branch, so the record takes it on its word. The escalations it lists are recorded as granted until Onus Cloud says otherwise, and the escalations gap says they are its word. An attached slice cut at a commit that is not one of the change's (its head), or that names none, gives neither the task, the token nor any decision, and the doors gap says so. A door log is attached only to the pull request whose head in Onus Cloud is the worktree's commit, so an agent cannot attach its slice, and the other tasks' entries in it, to another change.
  • Provenance records the escalations and token Onus Cloud kept (onus help provenance): onus ci pr and onus provenance take --escalations FILE, Onus Cloud's escalations with their decisions (new schemas/escalation-decisions.schema.json), and --token-inspection FILE, the door's inspection of the task token ({task, rights, expires}, never the token). So a change made through Onus Cloud has its token and escalations on record instead of as gaps.
    • Each escalation keeps its decision, who made it and when, and Onus Cloud's id as cloudId. It is joined to the request the submission or the door kept. Its reason is the decider's, never why the agent asked.
    • The token comes from the inspection, widened by what Onus Cloud granted to the task, with the new source inspection. A token verified by the run, a submission's scope or the door log comes first.
    • Only the change's escalations are kept: those on its pull request, listed by its submission, kept by an earlier record, or filed at one of its commits, its branch or its pull request's head ref (new ref and commit); others only when they share the change's task. An escalation that names none of these never sets the change's task or its token.
    • A final decision from the submission or the door log stands against one Onus Cloud has not made. When both are final and differ, Onus Cloud's is recorded and the escalations gap names the disagreement.
    • An empty list from Onus Cloud is on record, so escalations is not a gap. An escalation that cannot be read is left out with a warning and a gap that names the field, never the value. An inspection ci pr cannot read is named in the token gap. Only a token given in place of its inspection stops ci pr, before anything is written.
    • onus provenance --escalations still reads a folder of requests, and fails on a path that does not exist. With a file and --submission-id, it reads the kept requests too. --verify checks the new fields like any other. Dates that do not exist, such as month 13, are no longer read as times.
  • Area history for one repository (onus help production): onus signals areas --repository owner/name counts only that repository's changes, and the signals tied to no change, as a classification of one of its changes reads them. Onus Cloud keeps one records folder per organisation and shows each repository its own areas this way.
  • The action waits for a review in the human lane, and an owner's approval is the one that counts (onus help ci, onus help lanes): with records: true, the action lists the pull request's reviews with the GitHub CLI, and the members of each owning team when its token can read them, and passes them to onus ci pr --reviews. It asks the owners onus ci pr names to review (GitHub's requested reviewers), each once per pull request. While a human-lane change has no review that counts, the job fails (new input wait-for-review, default true; new output review: waiting or approved). It also runs on pull_request_review, and after an approval re-runs the failed pull_request check for the head, so the human lane waits without Onus Cloud too. Add pull_request_review to the workflow's events and make the job a required check. The new lanes.approval says whose approval counts: owner (the default when the change has owners) counts only a person named as an owner or a member of an owning team; member (the default when nobody owns it) counts anyone with write access. The rule and the owners are read at the base commit: the owners of each changed file's component in the base onus.yaml (an explicit --config inside the repository is read at the base too), else CODEOWNERS at the base, rather than the report's hints.owners, which come from the head. So a change can neither loosen the rule nor name its own approver. New onus ci owners prints those owners, so a host can look up owning teams first. The rule applies in the human lane only; other lanes keep every approval with write access, for provenance. When an owner cannot be checked (a team whose members the reviews file does not list, or an email), or no owner but the author could approve, anyone with write access counts and the review's note says why. A name GitHub refuses to ask is a warning and a line in the comment. Reviews on closed pull requests do nothing. The --reviews file may now be {"reviews": [...], "teams": {"@org/team": [logins]}}. The review answer gains approval and note; the pull record and the outcome keep approval, and the provenance record approval.review. Changes requested by anyone with write access still stand. Hosts that passed reviews before see one change: a change with owners now needs an owner's approval, unless lanes.approval: member.
  • A behavior diff: the tests that reach a change, run at the base and at the head (ADR 0019, onus help environments, onus help reports): onus report --behavior runs the test files the maps link to the changed code (changed tests first, then tests of the changed files and of code depending on them, up to depth hops) at the base and at the head, each in an environment, with the command in onus.yaml's new environment.behavior {command, junit, budget, maxFiles, depth}, read from the base commit or --config. Head files with newly failing cases run once more, so a flaky case gets no row, and the base versions of edited tests run against the head's code. The cases become four rows per component, at confidence traced: behavior-newly-failing (blocked until a person approves the row), behavior-changed (a test edited to match changed behavior; rules of the game, so a person reviews it), behavior-newly-passing and behavior-output-changed. --behavior-budget bounds the time, --fail-on behavior exits 2 on a newly failing row, and the report gains a behavior block (schemas/semantic-report.schema.json) and a Markdown line and section saying what ran. A problem never fails the report: the status is skipped or partial with the reason. Every run is an evidence manifest; the cross run's records the base files written over the head's tree (overlay), and the judge never accepts such a run as evidence. onus env gains run_with (a timeout) and overlay in the library. The action gains behavior and behavior-budget inputs. Without --behavior the report is unchanged.
  • Held-out suites outside the repository, chosen from the map, and a rotating judge (ADR 0018, onus help lanes): a held-out suite is a directory holding held-out.yaml (schemas/onus-held-out.schema.json) and the files its checks need, given with --held-out DIR or ONUS_HELD_OUT to onus judge, onus ci pr, onus ui and onus mcp; one inside the repository's worktree is refused. Each check runs at the head commit with the suite at /held-out, in the test container only, never in the setup container. The judge picks the checks from the head map: a check that covers two components that interact (by code or by an event) with one of them touched runs first, then checks about a row's subject, a touched component, every change, and a neighbour; limit keeps the most relevant. The judge now stops at the first failure: within evidence at the first failing run, within held-out at the first failing check, and every later step is skipped with not reached: <step> failed, so reasons names one thing to fix. The judgment gains heldOut (counts only, never a check's id, command or output); what each check did goes to people as held-out.json from onus ci pr, onus judge --show-held-out and the lanes page of onus ui. onus_lanes shows agents only that held-out checks are configured. lanes.judges lists configurations (name, optional taste and heldOutLimit); the judge picks one from a hash of the head commit and the suite, records rotation, and its judge id becomes <name>@<hash>, so outcome summaries track each one; onus judge --judge-config forces one, which agents cannot, and onus_judge hides which one judged so an agent cannot amend until a lenient one comes up. Without judges the judge id is unchanged. New onus held-out check (with --repo, refused inside it) and onus held-out select validate a suite and show which checks would run for a change, and why. lanes.heldOut still runs, as the untagged check lanes.heldOut, with a note that agents can read it. onus ci pr's lane.md names the configuration that judged. The action gains a held-out input.
  • Coverage into the map and the report (ADR 0017, onus help environments, onus help reports): onus map, onus diff and onus report take --coverage <file> (repeatable): lcov, Cobertura XML or Istanbul JSON, told apart by their content, with absolute CI paths matched to map files. It applies to the head tree only, since line numbers belong to the commit the tests ran at. The map gains coverage (sources, covered and uncovered lines per file, and links from a test named by lcov TN: to the symbols it ran); coverage naming a line past the end of a file is left out with a note. The report gains coverage (changed executable lines, how many ran, the ranges no test ran and the changed files the coverage leaves out) and rows hints.coverage; rows whose changed lines did not run rank first among equals. The Markdown adds Tests ran: to the intent line, a "Changed lines no test ran" block and a per-row fact. Without coverage both are unchanged. environment.coverage keeps a run's coverage files as coverage artifacts, and onus report --evidence <run.json> reads those of runs at the head commit (origin recorded); a submission made without a report (onus ci pr, onus_submit) reads them from its evidence. A recorded file that is not coverage, such as an HTML report the glob caught, is left out with a note. tests.coverage lists worktree coverage files for the map server, which leaves out files edited since. onus_tests_for, onus query tests-for and onus_impact give each test a link (ran, static-ran, static, static-not-run), strongest first, and coverage with the target's executable and ran lines when its file was measured; onus_status and onus map show what the coverage holds. The opt-in lanes.inputs.coverage {minChanged, required, commands} sends a change that would auto-merge to the judge (source: "input") when its tests ran too few changed lines, it changes a runtime file the coverage leaves out, or it has no coverage when required. Recorded coverage counts there only when its run's command is one of commands, since an agent picks the commands it runs; recorded coverage from any other command sends the change to the judge. Each recorded source keeps its command. The action gains a coverage input (a glob), passed only when the checkout is the head commit, passes evidence to the report, and adds coverage to its metrics.
  • Production is the final judge (ADR 0016, onus help production): the records gain a third file, signals.jsonl, carried on the records branch like the others. onus signals ingest --records <dir> --file <file|-> keeps incidents, error spikes, latency, metrics, rollbacks, deploys and traces from monitoring and deploy tools (vendor-neutral JSON, schemas/production-signal.schema.json), each id once, ties each to a change by the change it names or by commit, and turns an incident or rollback tied to a change into its incident or rolled-back outcome (signal names it), so the agent setup's record counts it; a malformed signal, or a rollout one, fails the whole input. Every classification carries a rollout plan for its lane (built in: auto-merge canary 10/100, judge canary 5/25/100, human behind a flag 1/5/25/100, blocked none; lanes.rollout replaces a lane's), with metric guards and a stricter plan for a component with recent incidents, reverts or rollbacks. onus ci pr writes rollout.json, keeps the plan on the pull record, adds rollout and record.recentRollbacks to its summary and a Rollout: line to lane.md. onus ci rollout --percent --metrics decides promote, hold, rollback or complete for a deploy tool (exit 0, 3 or 2), records the stage and, on rollback, the rolled-back outcome; onus ci rollback records one decided elsewhere, and --planned (also on onus outcomes record) marks one done on purpose. A non-planned rollback keeps the agent setup out of auto-merge and counts against its components; onus signals areas prints each component's history with error spikes. Outcome summaries gain rolledBack. The provenance record's rollout gains status, percent, plan, stages and signals; onus provenance reads <records>/signals.jsonl or --signals. onus signals traces keeps the calls an OTLP export observed, and --traces reads signals.jsonl too: a call the map had only guessed (inferred, low) that production observed becomes traced. The action passes the records' signals to onus report --traces, gains the outputs rollout-strategy and rollout-plan, and with rollout-percent (on deployment_status or workflow_dispatch) runs onus ci rollout and sets rollout-decision. onus ui's outcomes gain areas and each agent setup's recentRollbacks. New schemas: production-signal.schema.json and rollout-metrics.schema.json. change and attributedBy on a stored signal are Onus's: ingest drops a posted attributedBy, and a posted change that is not on record, with a warning. A planned rollback counts against no one: it stays a merged change in the track record and a clean one for onus lanes train, and a rollback after it counts. onus judge prints the final lane's rollout beside its classification; onus ci rollout --repo/--config gives a change recorded before plans its lane's plan from lanes.rollout and its components' history; onus signals traces --repo names the services that are the repository's components. The provenance record's track record gains recentRollbacks. Upgrade every binary that pushes the records branch together: an older onus ci records push rebuilds the branch from the files it knows and drops signals.jsonl, and stored signal lines are read strictly, so a binary older than a signal field fails on lines that carry it.
  • A learned model that only raises lanes (ADR 0015, onus help lanes): every classification now carries features, a fixed set of numbers describing the change (rows of each kind, blast radius, dependent components, size, novelty, sensitive code, map confidence, test reach, evidence, and the problems of the components it touches and of its agent setup). onus ci pr keeps them on the pull record, onus ci closed copies them onto the outcome, and reverts, incidents and audits keep them; onus outcomes record --classification <file> copies them by hand. The new onus lanes train --outcomes <file> fits a class-balanced logistic regression to the changes that had an incident, were reverted or rolled back, had an audit miss or were caught, against merges that stayed clean for --settle-days (14). It is deterministic (the same records in any order give the same file), prints how a first fit did on a held-out fifth (AUC, and the share raised and problems caught at each threshold), and refuses with "too little data" below 50 changes or 10 problems. With --config and --out it runs outside a repository. Commit the file and set lanes.learned (model, judge: 0.6, human: 0.85): onus classify, onus judge, onus ci pr, onus ui and onus_submit read the model from the base commit and raise a lower lane to the judge or a person at those risks, with a model reason naming the top factors and the model. It never lowers a lane or blocks, and a missing, stale or unreadable model leaves the lane to the rules, with learned.status and note saying why. onus ci pr --model <file> uses a model from elsewhere, such as Onus Cloud's; its summary gains risk and lane.md a Learned risk: line. A change to a *lanes-model.json file is a rule of the game (lanes-model-changed). /onus caught from someone with write access is now recorded (caught: true on the outcome, or on the pull record while it is open; the answer gains recorded), and the action pushes the records for it.
  • One provenance record per change (onus help provenance): every change carries the record of why it was allowed through: the intent (its sha256 and the report's intent check), the agent and model and how they were recognised, the task token it held (task, rights, expiry and a fingerprint, never the token), the evidence, the escalations and their decisions, the lane with every reason and the policy's hash, the judge's verdict and steps, who or what approved it (policy, judge, person, override, pending or none), the rollout (every outcome in order, the merge commit, the audit), the door log's decisions for the task with whether its hash chain is intact, and gaps, what it cannot vouch for and how to fill it. onus ci pr writes provenance.json beside the submission; the new onus provenance rebuilds it from the records (--from keeps an earlier record's facts from while the change was open), from a submission kept by onus ui or onus mcp (--submission-id), a token, the audit log and escalation requests, and --verify checks its digest. The format is the new schemas/provenance.schema.json. onus ci closed --merged-by <login> keeps who merged it on the outcome (mergedBy); the action passes it and gains the output provenance. Submissions keep the token's expiry and fingerprint.
  • Accuracy checks and what /onus caught said (onus help ci): /onus accuracy ok, /onus accuracy wrong <row> <what is wrong> and /onus accuracy missed <what the report left out> let a person with write access say whether a report was right; a row is its number in the table (from 1) or its id. onus ci comment answers with verdict, row, note and by, and records nothing; with the new --report <file> it checks the row against the report and turns a row number into the row's id, and refuses a row the report does not have. /onus caught <note> is answered with the note and who said it (by). Both are for a hosted service to keep, such as Onus Cloud's Metrics page. The action reacts to /onus accuracy with 👍 or 😕 and no longer pushes the records for it.
  • Audits of what merged without a person (onus help lanes): a share of the changes approved without a person (auto-merge, or the judge's approve) is sampled for a person to audit after they merge: the new lanes.auditAfterMerge (default 0.05), chosen by onus ci closed from a hash of the merge commit, so nobody knows beforehand. The outcome records "sampled": true; nothing in the comment, the check or the log says so. onus outcomes audits lists what waits for a person and the audit log, and onus outcomes audit --change … --by … --result ok|miss [--note …] records an audit; /onus audit writes the same record, with a structured audit: {by, at, missed, note}. onus outcomes summary gains awaitingAudit, total.sampled and sampledMissRate, the miss rate of the random sample. auditRate is unchanged: it sends would-be auto-merges to a person before merging. Pull records gain auditAfterMerge; records written before it are never sampled.
  • The human lane waits for a person's review (onus help ci): onus ci pr --reviews <file> reads the pull request's GitHub reviews and decides whether the human lane is satisfied: a counted approval of the head commit, from someone with write access who is not a bot and did not open it, and no outstanding changes requested. Reviews that do not count are listed with the reason. It prints a review key (required, satisfied, approvedBy, changesRequestedBy, owners, request, ignored), and lane.md gains a Review: paragraph. The owners to ask are those of the rows that need a person, from onus.yaml or else CODEOWNERS, each asked once per pull request. Report rows gain hints.owners; pull records gain requested and reviewedBy, and outcomes reviewedBy, so a human-lane merge with nobody's approval shows.
  • Built-in risk inputs for lanes (ADR 0014, onus help lanes): every change is also classified by how many other components depend on what it changed (blastRadius, 3 or more → judge), code no test exercises and no trace has observed (tests, → judge), rows on parts of the map Onus could not resolve (confidence, → judge), and the reverts, rollbacks and incidents of the components it touches in the last 90 days (history, a revert → judge, an incident → human). They are on by default, set under lanes.inputs, and only raise a lane. New hard floors: third-party code new to the repository goes to a person, a new dependency never auto-merges, and an edit to the code of a contract declared in onus.yaml is a rule of the game (a new declared-contract-edited row when nothing else reports it). Each reason is listed with source: "input" or "floor" and the ids of its rows (rows). Reports gain hints.dependentComponents (with the components named in hints.dependents; for a component's internal row, the users of the functions and classes whose lines changed) and hints.tested (tested, traced or untested, per file), shown in the evidence per row. A new SDK folded into a new-external-service row keeps new-package:<name> when it is new to the repository. Pull records and outcomes gain components (root for code outside every component), filled by onus ci pr and kept by onus ci closed, reverts and incidents; onus outcomes record --component sets them by hand. onus classify and onus judge take --change owner/repo#N to count only that repository's history and leave the change itself out; onus ci pr does this, at the time given by --at. onus ui classifies reports with the history too.
  • Narrow Onus Cloud tokens, escalations and maps from the CLI (onus help cloud): onus cloud token create|list|revoke mints scoped tokens (one organisation, some repositories, some of env:read, env:run, evidence:write, pulls:read, map:read, escalation:write, 60 seconds to 24 hours), and ONUS_CLOUD_TOKEN makes the CLI use one and nothing else. onus mcp signed in with a login no longer sends the login with agents' calls: it mints a scoped token for the worktree's repository and the task on first use (--cloud-repo, --cloud-ttl; --cloud-token to give one). Under a task token, a call that names a repository must name that one, --cloud-repo's when the remote is not GitHub's. New MCP tools: onus_cloud_token (a narrower token for a sub-agent), onus_cloud_map (a question to the map Onus Cloud keeps, answered by the CLI and filtered to the task's read scope) and onus_blocked (the safe exit: a broken test, a contradictory spec or an impossible task, reported with evidence). Signed in, onus_escalate and onus_blocked file the request in Onus Cloud, which assesses it on the default branch; onus_escalation {id, wait} follows it. On a grant, onus mcp mints the token itself, with the root key it holds (--key), from the request it kept and never from the answer: Onus Cloud never mints, and a request file changed after it was filed mints nothing. Without the key, the answer gives the operator onus escalation grant … --id <id> --scope <right>, which mints only when the file still holds that request and asks for exactly the scopes Onus Cloud granted. Signed out, with --key and --trusted-repo (a checkout whose files the agent cannot edit), the policy decides from that checkout's map and onus.yaml; without it, a person does. The CLI does the same with onus cloud escalate|escalation|blocked, and onus cloud map answers onus query's questions from the hosted map (cached by commit). A 403 for a missing scope says how to get it.
  • Questions to a map file (onus help commands): onus query --map <file> answers any map question from a map JSON file instead of a worktree: one from onus map --json, from the new onus report --head-map-out <file> (the head's map the report was computed against), or one downloaded from Onus Cloud. - reads stdin. A map of another schema version is refused. The new onus query overview gives every component with its owners, labels, files, lines, what it uses and what uses it, and the links, events, contracts and rules between them (schemas/map-overview.schema.json); onus ui's component graph is built from it, so the local and hosted views cannot drift apart.
  • Escalations assessed without minting (onus help scopes): onus escalation assess <request> --repo <trusted checkout> --reproduce-at <commit> applies the auto-grant policy and prints the decision and reasons, with no token, key or audit entry; exit 0 when policy would grant it, 3 when a person decides. The test command comes from the new onus.yaml tests.command ({test} is the test file), and the image and setup from environment:. Requests carry owners, who a person-decision goes to: the people who own every component the asked paths reach, by the components' paths, so a file that does not exist yet counts and asking for more never adds one. There are none (an admin decides) when no one owns it all, when part of an asked path is in no component (onus.yaml, CI workflows), or when a right is not a path. A request that asks for nothing, such as a broken-test report, goes to the owners of the files its evidence names. The sensitive labels of the files the evidence names always count. A failing test is run only when its reference is a plain path to a test file that exists at the commit and the test command names it ({test}); a request's failing tests get 15 minutes in all, image pulls and setup included. A test that is not run, or is stopped, sends the request to a person. onus escalation decide checks the same, believes no reproduced or run the request file carries on any evidence (nor does onus ui show one), and refuses a request changed after it was filed. What a run saw is not part of a request's id, so an assessed request can be assessed again.
  • Every agent call checked at the door and logged (onus help agents, onus help scopes): onus mcp checks each tool call against its task token (expiry on every call, then the tool's own rule) and writes it to the hash-chained audit log: the tool, a digest of its arguments, the token's task and id (never the token), the agent, the decision and why. A refused call says which right is missing and how to ask for it. Environments, their runs and hosted environments belong to the task that made them; onus_run_test takes no setup under a token; a tool without a rule is closed. onus mcp --audit <file> puts the log where the agent cannot write; the default log in the worktree goes in .git/info/exclude so a commit does not pick it up. A log that cannot be written refuses the call. Under a token, onus_cloud_pulls lists only the worktree's repository, and map answers leave out a short name's candidates in unreadable files. The gateway also logs refused passwords and every fetch. Appending to the log no longer reads the whole file.
  • Granted escalations, verified: onus_submit takes escalations, and onus submit --escalation (with --key-public, and --escalations-dir) and onus ui verify each id: the request is unchanged, for the task, and granted with a root-signed token minted for that request and holding what it asked for. A granted token names its request, so onus_escalation sees a grant wherever the person logged it. When it reports a grant, onus mcp uses the granted token from then on, unless its own token was narrowed and the grant would drop that narrowing.
  • The agent from the token: a task plan can name its agent (agent: {tool, model, config, team}); the token carries it, and submissions and log entries made under it use it instead of what the agent declares. A misspelt field in agent: is an error.
  • The map skips .onus/, where Onus keeps its records, so the audit log and submissions do not make it stale.
  • Onus Cloud from the CLI (onus help cloud): onus login signs the CLI in as you (a one-time code approved in the browser, the device authorization grant), onus logout revokes it, and ONUS_API_KEY stands in for it in CI. onus cloud env create|run|list|show|log|destroy builds hosted environments from a pushed commit on Onus Cloud's machines and records each run there; onus cloud evidence attaches a recorded run to a pull request, where the judge checks it against the recording; onus cloud pulls|pull reads governed pull requests and their lanes; onus cloud status|use shows and picks the organisation. When the CLI is signed in, onus mcp adds the same as onus_cloud_* tools for agents.
  • Records written after the fact keep their time: onus ci pr --at <seconds> and onus ci closed --at <seconds> record a pull request and its outcome at the moment they happened instead of now. For catching up on history: a hosted service backfilling a repository's merged pull requests, or a CI system replaying them.
  • Edit onus.yaml in onus ui: a form for components, labels, boundary rules, contracts, lanes, events and external services, tests and the environment, beside a YAML editor and the onus init suggestion. Edits are checked as you make them (the same loading the map does, packs included), shown as a diff before saving, and written so that only the changed lines change: comments, alignment and quoting stay as written. Saving refuses a config that does not load and a file changed on disk since it was opened, writes atomically and rebuilds the map at once.
  • onus ci pr records a judge configuration only when the judge decided; onus outcomes summary counts byJudge from judged changes only. Before, every pull record carried the judge configuration, so human-lane, auto-merge and judge-off changes were counted against it, including in records already written.
  • onus ci records push keeps a line written twice, in any records file. An approval and the check it re-runs can write the same pull record in the same second, and the merge with the branch dropped the second one. Two runs that each wrote the same line still keep one copy.

Install

brew install onushq/tap/onus
curl -fsSL https://onushq.com/install.sh | sh

Or in a workflow: uses: onushq/onus/action@v0.11.0. Each archive is attested: gh attestation verify <archive> --repo onushq/onus.