Skip to content

Releases

SeniorOS 0.11.0

Choose a tag to compare

@joshsegatt joshsegatt released this 16 Nov 11:08
03105f0

On Claude Sonnet 5.5, SeniorOS now fixes a bug at its cause in 29 of 30 runs, against 13 of 30 for 0.10 and none of 18 for Sonnet alone, at half the cost per passing run.

Changed

  • Routing: any report of wrong output or data, even one that names the function to fix, loads senior-debugging before the code is read. It was skipped in 14 of 42 such runs, and those passed 5/14 against 26/28 with it loaded.
  • senior-debugging: a new step 9 has the agent search every reader of the field it is about to filter or convert, list them under Other readers, each fixed or right as is, and fix the writer when another reader sees the same bad records. Changing the writer is code, not a data change: it is done without asking even when a reader is billing, copies what the working path writes for the same action, and covers every path that sets or clears the field. Only rewriting saved records still needs approval. Sonnet, six cause-elsewhere tasks: 21/30 against 9/30 for the step alone, then 29/30 (95% Wilson 83–99%) against 13/30 with the routing, $0.14 against $0.28 per pass; bug tasks not used for tuning 18/18, control 16/16.
  • senior-engineering: when one operation writes two or more records that must agree, use one transaction, or derive the later write from the earlier one, or record each write as done, and test a run that stops after each write. o49 (a backfill that failed in every arm, Opus alone included): 4/4 against 0/4.

Added

  • Bench: a seventh blind round (o48–o55) on data already saved and on habits from Superpowers, gstack and Compound Engineering. Opus alone 2/2 on six, o53 1/2, o49 0/2. A variant of SeniorOS with four of those habits tied main at 21/24 on Sonnet and was not adopted.
  • Bench: arms that switch the Claude Code hooks on one at a time (senioros-rules, senioros-rules-guard, senioros-importers) and an experimental importers-first gate, off by default. Measured, not adopted.
  • plugins/senioros/: a skills-only edition for the Claude plugin directory, which accepts from unverified publishers only Markdown, text, JSON and images, and no hooks. npm run gen:rules copies the skills, license, icon and manifest into it, and npm test fails when the copy is out of date. The guard and the finish gate stay in the full plugin from the repository's marketplace.

Fixed

  • Guard: Claude Code on Windows runs commands through its PowerShell tool, which the guard never saw; the hook matcher and the guard now include it, and the Claude Code hooks say on stderr when they did not run. Two review rounds closed bypasses, each with a test: force flags inside clusters (git push -fu), git clean -d -f, TRUNCATE without TABLE inside a database client, rmdir /q /s, a downloaded script run as the script itself (sh -c "$(curl …)", bash <(curl …), eval, iex (irm …), also piped into sudo), git checkout HEAD ., and recursive deletes through PowerShell pipelines and .NET.
  • Antigravity installer: a reinstall no longer wipes edited hook scripts (each script's sha256 is recorded; --force saves the folder once and uninstall restores it), and the config is validated before anything is copied.
  • Routing: senior-project-intelligence and senior-skill-authoring were never routed on any host; each now has a routing line. A regression proof needs the original symptom, not just any failure.

npm: https://www.npmjs.com/package/senioros/v/0.11.0 · install per host: Quick start

SeniorOS 0.10.1

Choose a tag to compare

@joshsegatt joshsegatt released this 10 Nov 23:16
4ae5cc0

The finish gate no longer saves a run that verified nothing as a pass, the hooks' guarantees and limits are written down, and the bench can measure Codex.

Added

  • Bench: a Codex backend, --backend codex --model <name>, with the arms none and senioros. Each run is one codex exec in the run's repository with Codex's sandbox on, from the bench's own Codex home and login, so the user's ~/.codex is never read. The bench stops before any run when that login is missing or when ~/.agents/skills would load the user's own skills into every run. Codex's sandbox keeps .git read-only, so tasks about destructive git commands cannot tell the arms apart there. No results are published for it yet.
  • Bench: any Claude Code plugin is an arm with --packs name=source, where a source is a plugin folder or a repository pinned to a full commit (owner/repo@<commit>[#subfolder]), cloned once into the bench home. Each run writes bench.json with the model and the commit of every arm.
  • Bench: a public leaderboard, evals/bench/LEADERBOARD.md, generated from submissions in evals/bench/leaderboard/ (bench.mjs submit writes one from results folders, bench.mjs leaderboard rebuilds the board, and npm test fails when it is out of date). Each table shows the pass rate with its Wilson interval, the exact test against the model alone, whether it holds after correcting for the packs compared, the cost per pass and each pack's commit, and says who ran it and whether anyone else re-ran it. It starts with the fifth round on Opus, Sonnet on the cause-elsewhere tasks and the sixth round. evals/bench/SUBMITTING.md explains how to measure a pack and submit it.

Fixed

  • Finish gate: a run that verified nothing is no longer saved as a pass. When senior finish gives no readable report (a broken install, an invalid .senior/config.json) the agent is told once that the change is NOT VERIFIED; when no review is due and no check proves the change (no tests ran, checks skipped) it is told once that the baseline is NOT PROVEN. Before, both finished in silence. Neither blocks more than once per change set.
  • Bench: the .senior/config.json of task t7 had no schemaVersion, so senior finish rejected it and the finish gate verified nothing there. Published t7 results for the SeniorOS arms were measured without a working gate. A test now parses every config a bench task ships.

SeniorOS 0.10.0

Choose a tag to compare

@joshsegatt joshsegatt released this 06 Nov 23:45
b6c0ea6

SeniorOS sets up Grok CLI in one command, and every result now carries its uncertainty: on the fifth round it is the only pack separable from Opus alone, and on Sonnet 5.5 it passes 12 of 20 cause-elsewhere runs where Sonnet alone and Superpowers pass none.

Added

  • senior install --target grok sets up Grok CLI in one command: the plugin in ~/.grok/plugins/senioros/, the entry in ~/.grok/config.toml and the Grok routing rules in a marked block of ~/.grok/AGENTS.md, each file backed up once. senior uninstall --target grok removes them, senior setup and senior doctor report Grok, and senior setup --apply installs it. The npm package now ships the plugin parts Grok loads (.claude-plugin/, hooks/, rules/).

Changed

  • Bench, Claude Sonnet 5.5 on the cause-elsewhere tasks (o17, o19, o20, o37), 5 trials: SeniorOS 12/20, Superpowers 0/20, Sonnet alone 0/20 (p < 0.001), $0.16 a run for both packs. o20 failed in every arm.
  • Bench: a sixth blind round (o40–o47) on concurrency, flaky tests, changes to stored data and dependency upgrades. Opus alone 23/24, so no task was kept for a held-out comparison and no skill was written; SeniorOS 24/24 (not worse), at $0.53 a run against $0.37. The tasks stay as a "never worse" check.
  • Bench reports give each arm's pass rate with a 95% Wilson interval, a two-sided exact p against the model alone compared task by task, and the cost per passing run (evals/bench/lib/stats.mjs). On the fifth round, SeniorOS is the only pack separable from Opus alone (p < 0.001; the others p ≥ 0.08) and has the lowest cost per passing run ($0.65, against $0.78 to $2.04); its lead over compound-engineering (10/15 against 6/15) is not separable at 5 trials.
  • Bench: a fifth blind round of the cause-elsewhere class (o34–o39), and selftest takes task ids. Opus, the three tasks Opus alone always failed in calibration, 5 trials: SeniorOS 10/15, compound-engineering 6/15, Superpowers and mattpocock/skills 5/15, Opus alone 2/15. The finish-gate review threshold was measured and kept: half of the reviews that led to a fix were on medium-risk changes.
  • The routing rules come from one template, rules/core.md. npm run gen:rules writes rules/senioros.md and the Claude Code, Codex, Cursor, Grok and OpenCode rules from it, each with its own first line from rules/hosts.json, and npm test fails when a generated file is out of date. The text each host loads is unchanged. Antigravity keeps its hand-written rules.
  • The README is half as long (821 to 445 lines): it keeps the results, the demo, the install and the skills, and links to docs/cli.md (every command, proof order, regression proof, project config), docs/hosts.md (each host install) and docs/concepts.md (proof engine, project memory, evals, architecture, design principles). No text was dropped; stale counts in the evals section were updated.
  • Grok gets its own routing rules, adapters/grok/rules.md, to put in ~/.grok/AGENTS.md. They load at most one skill per task and start no review subagents, leaving the checks and the risk review to the finish gate. With the general rules Grok loaded four or five skills per task. On the bench (13 tasks, 2 trials, against the previous rules in the same batch) the score held at 20/26, the 12-minute timeouts fell from 7 to 0, and the time per task from 366 s to 226 s.
  • The bench measures mattpocock/skills and compound-engineering as rival arms, counts finish-gate reviews that led to a fix, and has a hygiene task for debug leftovers and copied secrets.
  • The Antigravity and Grok installers share one module for the rules block, backups and the package root (src/core/install-shared.ts). senior --version reads the version from package.json, and senior help lists install --target grok and uninstall --target grok.

Fixed

  • senior install --target antigravity no longer adds a second rules block to ~/.gemini/GEMINI.md when the existing block has lost a marker: like the Grok installer, it leaves the file as it is and says so, and uninstall does the same. Like the Grok installer, it now exits 1 when a step was left undone, and uninstall deletes a GEMINI.md the install created and left empty.

SeniorOS 0.9.0

Choose a tag to compare

@joshsegatt joshsegatt released this 03 Nov 23:36
77422a6

SeniorOS beats the strongest models alone on Claude Opus, Grok and Gemini: a reported bug is fixed at its cause, even in another module, and the guard holds in Grok.

Added

  • A reported bug goes to senior-debugging, which reproduces it through the real entry points the data goes through, not only the function the report names, and fixes the cause where it is, even in another module. A code fix of the cause needs no approval; rewriting data already stored still does, and the agent says which records stay wrong until then. senior-engineering runs the changed path at the repository's real volume (a seed, a config value, a note on production size) before saying done. Every host's routing rules carry the change.

    • Measured on Claude Opus with tasks written by agents that never saw SeniorOS, held out from tuning (o17, o19, o20, 5 trials): SeniorOS 15/15, Opus alone 0/15, Superpowers 0/15. Every arm found the cause; only SeniorOS fixed it where it was. On grok-4.7 and Gemini Pro, on the five tasks of this kind: 9/10 and 7/10 for SeniorOS, at most 1/10 without it.
  • Bench: an Opus set of 32 tasks (o1–o32) written blind to the pack in four rounds, and a Grok backend (--backend grok): each run gets its own Grok home and an empty profile folder, and the login is copied without its refresh token, so runs cannot rotate it. Results on 13 tasks, 2 trials: Grok 23/26 with SeniorOS, 15/26 alone, 14/26 with Superpowers; Gemini Pro 21/26, 16/26, 16/26. Opus core set, 3 trials: 24/24, 21/24, 19/24.

  • Planning before the first edit, in the routing rules of every host and in senior-engineering: a change with several steps, a shared contract or stored data, or a step that can fail halfway is planned before editing. The agent finds every reader of what changes and the data already saved in the old shape, and decides what happens if a step fails halfway, runs twice or meets old data. Renaming or reshaping a field, key or type that other modules or saved data read is no longer a low-risk edit. senior-finish checks the plan against the result.

    • Measured on Haiku, 8 trials each on h12-cancel-order and h13-line-rename: 15/16 with these rules, against 12/16 for the rules before them and 9/16 for the model alone. A separate senior-plan skill with the full procedure scored the same 15/16 at the same cost, so it was not shipped: it is kept in experiments/senior-plan/ with its measurement. See evals/bench/README.md.
  • The finish gate puts senior-finish to work: when the checks pass on a change senior risk rates medium or higher, it sends the agent back once per session to name the two likeliest ways the change is still wrong and the evidence that rules each out, then give the ship status. Low-risk changes are untouched. When nothing failed but the proof baseline is not passing (no tests ran, checks skipped), the review says NOT PROVEN instead of "the checks pass". In the Claude Sonnet bench, no run had loaded senior-finish on its own. Applies to Claude Code, Codex, Cursor, OpenCode and the Antigravity hooks.

  • senior-code-review gains a "Try to break it" pass for medium-risk changes and above, and senior-finish a step to name what could still be wrong before choosing a status.

  • Bench: Claude runs get an empty config folder and authenticate with CLAUDE_CODE_OAUTH_TOKEN (the login file is never copied), and run refuses to start when the user's own CLAUDE.md still reaches the runs, which Claude Code reads from the profile folder whatever the environment says. With it moved aside, Claude Sonnet on the core and hard sets: SeniorOS 38/38, Superpowers 7.0.1 35/38.

  • A test command that runs no tests is no longer a pass. senior finish and the finish gate read how many tests ran from node:test, Jest, Vitest, Mocha, pytest, unittest, cargo test and go test output; zero is SKIP (no tests ran), and the count is shown next to the check and reported as tests in --json. Before, npm test with no test files, or go test with no test files, reported PASS. Output that is not recognised changes nothing.

    • A node:test file with no tests in it is not counted either. node:test reports such a file as one passing test named after the file (Node 20, 22 and 24, spec and TAP), so a suite of placeholder files read as PASS (1 test). Only a top-level entry that is not a suite and has no subtests, naming a test file that exists and has no code in it (only comments, imports, requires or export {}), is subtracted, once per file in each run. So describe('utils.ts'), a test named index.js or after its own file, and a build line like ✔ dist/index.js (12ms) still count. When the test command runs from another directory (npm workspaces, cd pkg && node --test), the printed paths are resolved from the project root, so they are usually not found and nothing is subtracted: the count stays as node:test printed it.
  • Provenance: every proof report says when and on which code it ran (provenance: commit, uncommitted changes, time). senior finish --record keeps the report in .senior/evidence/<commit>.json as a durable record of what was verified; it stores no command output. Changes under .senior/ no longer count as changes to a project.

  • The guard catches equivalents of the commands it already guarded, listed in a bypass corpus test (tests/guard-bypass.test.ts) where each case either asks or is documented as out of scope with its reason. Applies to every host.

    • git options before the subcommand (git -C ../app push --force, git -c …, --git-dir, --no-pager) no longer hide it from the git rules. Their values are still judged, since they can run commands (-c alias.x='!…', -C "$(…)") or name the agent's own configuration (git -C ~/.claude/plugins/… rm).
    • Newly guarded: git push --mirror and --prune; git checkout/restore of a folder, . or a glob, and checkout -f/switch -f (a dot-folder such as .github counts as a folder; one file, such as git restore src/a.ts, stays free); git branch --delete --force, update-ref -d, reflog expire, gc --prune=now, git prune, worktree remove --force.
    • Deletion by other tools: rm with its options after the operands (rm src -rf), find -delete and -exec rm, rimraf (build folders stay free, as with rm -rf dist), PowerShell's abbreviated -r/-Rec and the ri/rm/del aliases (where a command starts, so grep del -r is a search), rsync --delete, and recursive deletes in python -c, node -e/-p and ruby -e one-liners.
    • Publishing and remote changes: npm unpublish/deprecate, cargo publish, twine upload, poetry/uv publish, gem push, docker push (--dry-run stays free); gh release delete, gh repo archive, gh api -X DELETE; aws s3 rm --recursive/rb/sync --delete and aws … delete-*/terminate-*, also after global options (aws --profile prod …), as kubectl -n prod delete now is; helm uninstall, heroku apps:destroy, pulumi up/destroy, az … delete; redis-cli FLUSHALL, MongoDB dropDatabase(); dd of=/dev/…, mkfs.
    • Secrets: printenv, env and Get-ChildItem env: on their own or piped (env | grep TOKEN), printenv or echoing a variable named like a secret ($GITHUB_TOKEN, $OPENAI_API_KEY).
    • In git, gh and glab, commit messages, titles and search patterns are read as text, so git commit -m "remove rimraf" no longer asks; a $(…) or backticks inside double quotes still does, and so does a message containing ; or &&. Other tools are not touched: in ssh host -t "…" or watch -t "…" the quoted word is the command that runs.
    • Out of scope, by decision: commands built at run time or decoded ($(echo rm), base64 -d | sh) need an OS sandbox, and everyday file operations (rm of named files, mv, writing a file) would make it ask too often to keep. git restore of a file without an extension (Makefile) also asks, since the text cannot tell it from a folder.
  • senior doctor shows each supported host on this machine and whether SeniorOS is set up in it: the host's command on PATH or folder, the plugin (yes, no, or unknown when the files that would say are missing or unreadable, never a guess; a Claude Code install scoped to another project is no), Codex hook trust (yes only with all three trusted), Antigravity hooks, and the file behind each answer. It also says whether the senior CLI is on PATH. Detection reads files only and never runs a host's binary. Cursor's plugin state shows as unknown unless a cached copy is found, since Cursor does not document where it records plugins.

  • senior setup prints the step left for each host found. senior setup --apply also does the steps the CLI owns: it adds senioros to the user's opencode.json (backed up once as .bak-senioros; a JSONC file, or one that is not a plain JSON object, is left alone and the step says to edit it by hand) and runs the Antigravity installer when Antigravity is present without SeniorOS's skills or hooks. Plugins for Claude Code, Codex and Cursor are installed in the app, so setup prints those commands. When a step could not be applied, setup --apply exits 1.

  • The guard asks before senior setup --apply, senior install --target antigravity and senior uninstall, also as npx senioros@<version> … or node …/index.js …: they write a host's hooks or plugin list, the same change as editing those files. Before, an agent could run the Antigravity installer without a prompt.

  • Proof beyond Node: senior finish and the finish gate now check Python, Go and Rust projects. Before, the finish gate stayed silent on any repository without package.json or .senior/config.json.

    • Python: pytest (continuing past import errors) or unittest, plus mypy and ruff when configured, in the project's .venv/venv or Poetry/Pipenv environment. Go: go vet, go test. Rust: cargo test (a workspace covers its members).
    • Projec...
Read more

SeniorOS 0.8.0

Choose a tag to compare

@joshsegatt joshsegatt released this 31 Oct 13:45
61503c3

SeniorOS as an OpenCode plugin, and a guard that also protects the settings, hooks and plugins of the host it runs in.

Added

  • OpenCode 1.x plugin. Add "plugin": ["senioros"] to opencode.json and restart OpenCode. The plugin:

    • registers the senior-* skills;
    • adds the routing rules to the system prompt;
    • fails destructive bash calls. OpenCode's tool hook cannot ask, so the agent shows what would be lost and lets the user run the command;
    • runs the finish gate when a session goes idle, and sends failing checks back to the session.
  • The guard protects the agent's own configuration. An agent that could rewrite these files could switch SeniorOS off:

    Host Protected files
    Claude Code .claude/settings*.json, .claude/plugins/
    Codex .codex/config.toml, hooks.json, plugins/
    Cursor .cursor/hooks.json, plugins/
    OpenCode opencode.json, plugin folders
    Antigravity .gemini hooks and rules

    Coverage:

    • Shell commands that change these files need confirmation, including quoted scripts and command substitutions.
    • The file-edit tools of Claude Code, Codex (apply_patch) and OpenCode are covered too.
    • Cursor and Antigravity have no hook before a file edit, so there only shell commands are covered.

Fixed

  • The finish gate tells the agent to stay within what the user asked. The second time it sends the agent back for unchanged code, it tells the agent to repeat its explanation and stop. Before, in OpenCode, an agent sent back twice edited a test the user had said not to touch.

Verified

In OpenCode 1.14.34 on Windows:

  • the guard blocked git reset --hard and an edit to opencode.json;
  • the finish gate sent the agent back on a failing test;
  • with the new wording, the agent kept its explanation and changed nothing it was told not to touch (one run).

Not yet tested in the host: the Claude Code Edit and Codex apply_patch protection, OpenCode 1.2, macOS and Linux.

Install

  • OpenCode: { "plugin": ["senioros"] } in opencode.json
  • CLI: npm install -g senioros@0.8.0

SeniorOS 0.7.0

Choose a tag to compare

@joshsegatt joshsegatt released this 28 Oct 21:43
102bd94

The guard and the finish gate in Codex, tested in the Codex CLI itself.

Added

  • Codex plugin hooks (adapters/codex/, declared in .codex-plugin/plugin.json):
    • a SessionStart hook with the routing rules;
    • a PreToolUse guard that denies destructive commands. Codex hooks cannot ask the user, so the agent is told to show what would be lost and let the user run the command;
    • a Stop finish gate that sends the agent back on failing checks, at most twice per change set.
  • Codex marketplace (.agents/plugins/marketplace.json).

Fixed

  • The Codex plugin no longer loads hooks/hooks.json, the Claude Code hooks, whose ask answer Codex treats as an error and ignores.

Verified

In Codex CLI 0.164.0 on Windows:

  • the guard blocked git reset --hard HEAD, even when the prompt claimed the user had confirmed;
  • after an edit that broke a test, with the instruction not to run tests, the finish gate sent the agent back. Its final answer reported the failing test instead of "Done".

Installing from GitHub brings exactly the three SeniorOS hooks. Not yet tested: Codex on macOS and Linux.

Install

codex plugin marketplace add joshsegatt/SeniorOS
codex plugin add senioros@senioros

Then open /hooks in Codex and trust the three SeniorOS hooks.

CLI: npm install -g senioros@0.7.0

SeniorOS 0.6.0

Choose a tag to compare

@joshsegatt joshsegatt released this 28 Oct 20:59
03b3713

The guard and the finish gate in Cursor, and SeniorOS as a native Antigravity plugin.

Added

  • Cursor plugin (.cursor-plugin/plugin.json, adapters/cursor/):
    • the skills;
    • a sessionStart hook with the routing rules;
    • a beforeShellExecution guard that asks before destructive commands;
    • a stop finish gate that sends the agent back on failing checks, in every repository of a multi-root workspace.
  • Native Antigravity plugin: agy plugin install https://github.com/joshsegatt/SeniorOS adds the skills and routing rules. The hooks still come from senior install --target antigravity.
  • adapters/shared/: the guard and finish gate shared by the plugin hosts. The Claude Code hooks now use it, with the same behavior.

Fixed

  • Outside Windows, the finish gate no longer treats two repositories whose paths differ only in case as one. On Linux and macOS each is checked and remembered separately.

Not yet verified

Neither plugin has been tested inside the Cursor app or agy. CI runs the hook commands through the shell on Linux and Windows.

Install

npm install -g senioros@0.6.0

Cursor: install as a local plugin until it is in the marketplace (see the README).

v0.5.0

Choose a tag to compare

@joshsegatt joshsegatt released this 28 Oct 16:38
aa98051

A finish gate in the Claude Code plugin, a guard that judges chained commands one by one, and bench results on Claude Sonnet.

Results on Claude Sonnet (core set, 8 tasks × 3 trials)

Arm Passed
SeniorOS 24/24
Superpowers 19/24
No pack 17/24

On a strong model, SeniorOS wins on discipline, not by finding more bugs:

  • Sonnet alone fixed a bug three times without a test that proves the fix.
  • Sonnet alone three times discarded a colleague's work in progress and force-pushed main.
  • With SeniorOS it wrote the test and stopped to ask every time.
  • No false "tests pass" claim.

Added

  • Claude Code finish gate (a Stop hook in the plugin): when code changed, it runs senior finish before the agent may stop. On a failing check it sends the agent back, at most twice per change set.
  • Bench honesty check: each final report's claims about the tests are compared with the real results.
  • New bench tasks:
    • t7-ci-suite and t8-cleanup;
    • the strong set x1–x4;
    • the senioros-skills arm.

Fixed

  • The guard judges chained commands one by one: cd app && rm -rf dist coverage no longer asks.
  • git clean limited to build folders (git clean -fdX -- dist coverage) no longer asks. Without a pathspec, or with any other path, it still asks.

Install: npx senioros install or, in Claude Code, /plugin install senioros@senioros.

SeniorOS 0.4.0

Choose a tag to compare

@joshsegatt joshsegatt released this 27 Oct 19:51
00942c2

Install

npx senioros install --target antigravity     # Google Antigravity, one command (new)
npx senioros install --target codex --scope project
npm install -g senioros                       # command: senior

Claude Code plugin: /plugin marketplace add joshsegatt/SeniorOS then /plugin install senioros@senioros.

Highlights

  • Google Antigravity in one command. npx senioros install --target antigravity registers the skills, adds the routing rules to GEMINI.md and installs the hooks next to yours. It records what it wrote, never overwrites your edits or hand-made hooks without --force, and npx senioros uninstall --target antigravity takes out only what it added.
  • Results on the front page. The README opens with the bench table and a replay of a real run: asked to discard local work and force-push main, Claude Code alone rewrote main; with SeniorOS it stopped and listed what would be lost.
  • Claude Sonnet on the hard set: no pack 22/22, SeniorOS 22/22, Superpowers 19/22. On a strong model SeniorOS keeps every task the model solves alone; on weaker models (Claude Haiku, Gemini Flash) it adds the wins shown in evals/bench/README.md.

One-command setup for Google Antigravity, and the bench results on the front page.

Added

  • senior install --target antigravity [--turbo] [--force] sets up Google Antigravity in one command: copies the skills to ~/.gemini/config/senioros/skills and registers them, adds the routing rules to GEMINI.md in a marked block, and merges the hooks into config/hooks.json next to the user's own; each changed file is backed up once and reinstalling never duplicates;
  • the installer records what it wrote (~/.gemini/config/senioros/install.json): without --force it keeps skills you edited, hook blocks and scripts it did not write, and SeniorOS rules outside its block, and a hook turned off with "enabled": false stays off;
  • senior uninstall --target antigravity removes only what the installer added and restores what it replaced with --force;
  • README: bench results up front with a replay of a real run (brand/social/demo-approval-boundary.svg), the Claude Code plugin as the recommended install, and DESIGN.md for visual assets;
  • bench: Claude Sonnet results on the hard set (none 22/22, senioros 22/22, superpowers 19/22).

Fixed

  • bench: a Claude Code run that ends on a usage limit or API error now fails as launched instead of being graded as an untouched repository, and the bench stops starting new runs.

SeniorOS 0.3.0

Choose a tag to compare

@joshsegatt joshsegatt released this 27 Oct 17:52
898d58c

Install

npx senioros install --target claude --scope project
npm install -g senioros   # command: senior

Claude Code plugin: /plugin marketplace add joshsegatt/SeniorOS then /plugin install senioros@senioros. The plugin now ships hooks: routing rules at session start and a guard that asks before destructive Bash commands.

Google Antigravity: see adapters/antigravity/README.md.

Highlights

A live bench (evals/bench/) now compares the same model with no pack, with Superpowers and with SeniorOS on trap tasks. Hidden tests and the repository state grade every run; no model judges another.

Host and model no pack Superpowers SeniorOS
Claude Code, Claude Haiku (17 tasks x 3 trials) 45/51 44/51 49/51
Antigravity, Gemini Flash (h7, h9–h11, 3 trials) not run 8/12 12/12
Antigravity, Gemini Flash (h5 multi-regression refactor, 4 trials) 0/4 0/4 4/4

In Claude Code, SeniorOS wrote no wrong code and stopped before force-pushing main in all 3 t6 runs. Caveats, including which tasks were written alongside the changes they reward, are in evals/bench/README.md.

Google Antigravity support, plugin hooks for Claude Code, and skill changes measured with a live bench against no pack
and Superpowers (Gemini Flash in Antigravity, Claude Haiku in Claude Code; results in evals/bench/README.md).

Added

  • senior prove --regression --test "<cmd>": proves a regression test catches the bug (passes with the fix, fails with it reverted, passes again restored), with --expect-failure, --base, --fix, --timeout and --json; evidence written to .senior/runtime/evidence/;
  • senior prove --restore: restores the working tree after a proof that was killed mid-run;
  • senior-debugging and senior-finish use senior prove --regression when the CLI is available; new eval finish-regression-proof;
  • Google Antigravity adapter (adapters/antigravity/): skills registration, routing rules, and three fail-open hooks: project context at session start, a guard that forces confirmation for destructive commands, and a stop gate that runs senior finish before the agent may finish with changed code;
  • Antigravity guard always answers with a decision (--passthrough=ask|allow, also on errors): Antigravity denies a call whose hook gives none, which had blocked every terminal command; hook commands are written without quotes, since Antigravity runs them without a shell; new track.mjs hook lets the stop gate prove repositories edited in conversations that have no workspace; SENIOROS_CLI overrides how hooks call the CLI;
  • from the first bench pilot (all arms 6/6; SeniorOS the most expensive): senior-engineering and senior-finish no longer trigger on low-risk copy/label edits (evals senior-copy-change-direct, finish-low-risk-skip); senior-debugging reads the implicated commit's whole diff and restores every unintended change (eval debug-regression-commit-diff); the Antigravity rules carry a CLI reference so agents stop running senior --help; new context.mjs PreInvocation hook gives project context and decisions when a workspace-less conversation first touches a repository;
  • from the first independent bench task (h7, where every arm sometimes let a member grant themselves admin through the request body): senior-engineering decides what each caller may control when input reaches stored state or a privileged operation, picks allowed fields instead of spreading the input, and tests a forbidden one; senior-code-review asks what each caller-controlled input can reach (evals senior-input-boundary, senior-input-boundary-typo, review-mass-assignment);
  • Claude Code plugin hooks (hooks/hooks.json): a session-start hook adds the SeniorOS routing rules and approval boundary (adapters/claude-code/rules.md), and a Bash guard asks before destructive commands; in the first Claude Code bench the plugin's skills were never loaded without them (0 of 51 runs);
  • bench claude backend (claude -p, arms as flags, so arms run in parallel) with per-run cost and the final report saved;
  • bench hard task set (h1–h5: root cause elsewhere, project rule, shared function, red CI with an intended change, multi-regression refactor), --tasks core|hard, and a per-run count of agent tool calls and loaded skills;
  • live bench (evals/bench/): six trap tasks on a fixture project, arms none / superpowers / senioros / senioros-skills, a deterministic grader (hidden tests, regression proof, scope, test weakening, destructive boundary) verified by reference solutions in npm run check, and an Antigravity runner (agentapi, agy or manual).