Skip to content

v0.4.0

Latest

Choose a tag to compare

@github-actions github-actions released this 03 Nov 21:59
· 2978 commits to main since this release

Booley, until now "the open-source agentic RTL IDE", now describes itself as
the open-source Agentic Development Environment (ADE) for FPGA and ASIC
development. Only the positioning changed: it is the same product, and the
package, CLI and name stay the same. Goal Mode replaces Ticket Mode, and you
can try Booley in a browser through a free GitHub Codespaces demo.

Major features

  • Goal Mode replaces Ticket Mode. Ticket Mode was too heavy, took too
    long to set up and brought too many bugs. Goal Mode runs inside your own
    agent session: open one in the Sandbox and type /booley-goal <request>
    ($booley-goal in Codex). The agent turns the request and the Project's
    Goalsets into Goals, such as SIM:sim_core or REVIEW:rtl_bugs, and
    works on a Goal Branch in its own linked worktree.
    Every Goal is mandatory, and only a human can approve a Goal change. Clear
    the chat and type /booley-goal start to do the work; the same command
    resumes after a crash or reconnection. Finish produces a Review Package and
    a Session Summary, and the agent ends with their paths.
    • Flow and Specialist results count as Goal evidence only when they come
      from Goal-bound MCP calls. goal_status, booley goal status, the
      Dashboard and the Review Package show every Goal, its evidence and any
      open review findings. With no active Goal, status shows the last ended
      Goal and its Review Package.
    • Relative SIM, SYNTH and FPGA Goals measure a baseline at the Goal's base
      commit in a background Job. Status shows baseline → current (delta, %)
      and, for each frozen Test Run, how it changed since the baseline. Baseline
      Jobs run the Project's .booley/hooks/post-setup hook first and never
      delay your own runs.
    • A Review Goal names one target or paths. After you fix a clean
      review's findings, reviewer --verify [--waive ID "reason"] re-checks
      only those findings.
    • [project].protected_inputs lists extra tracked files, globs or
      directories, such as a Makefile or firmware, that a Goal must not
      change. Editing one discards affected evidence and blocks Finish until you
      restore it.
    • booley worktree new <name> creates a worktree under .booley/worktrees/
      with submodules filled in offline. Goal Mode uses it, and you can use it
      for parallel work. It works in Stealth Mode and with a Paired Checkout.
  • Free GitHub Codespaces demo. Click "Open in GitHub Codespaces" in the
    README Quick Start or on https://booley.dev/demos/ and run a Goal on the
    PicoRV32 demo with nothing installed. The demo fits GitHub's free monthly
    Codespaces allowance; the first start takes 3 to 4 minutes. After a GitHub
    sign-in, booley-demo-claim gets sponsored GPT-6 Luna tokens, or you can
    sign in with your own Claude or ChatGPT account. https://booley.dev/demo/
    lists the limits.
  • Sandbox Dashboard. booley dashboard shows Sessions and Jobs, each in
    its own window with its own selection, scroll and history. Sessions are
    grouped by whether their agent is working, waiting for a tool call, or
    waiting for you, as reported by Claude Code and Codex hooks in the Sandbox
    Image. Jobs show their EDA tool, CPU time and peak memory, and can be
    filtered. Sessions and Jobs have short handles such as S17 and J-SIM25
    that booley chat also uses. Navigate with the arrow keys, Enter and Esc; a
    terminal at least 120 columns wide gets a preview pane. Report, artifact
    and evidence paths open in the editor on click. The Dashboard opens in its
    own editor tab when you attach VS Code to a Sandbox or open a Codespace.
  • Test Variants and seeded Test Runs (#1233). tests.toml declares extra
    run-time configurations of a Test as Test Variants
    ([<target>.variants.<test>]: arguments, environment and a required
    default), and every Test Run of a seeded Target has a recorded seed. A
    Test Run is written test[+variant][@seed].
    • booley flow sim --test and the sim MCP tool accept test,
      test+variant, test@seed, test+variant@seed and test[+variant]@xN
      for N drawn seeds. --seed N|random (MCP seed) sets or draws the seed
      of every selected Test Run.
    • Booley passes the seed: +verilator+seed+<seed> on Verilator, cocotb's
      seed variable on Cocotb Targets, and the new tests.toml seed template
      on Verilator and Icarus. An Icarus HDL-testbench Target without a seed
      template is unseeded and refuses seeds. A Target can set default_seed.
    • Reports list every Test Run and print a rerun command, with its seed, for
      each failure. simulation.json gains test_runs[] rows. Coverage runs
      accept every selector form and merge their Test Runs.
    • Pre-Sim Commands receive BOOLEY_TEST_RUN_NAMES, and for a single Test
      Run BOOLEY_TEST_RUN_NAME, BOOLEY_TEST_VARIANT and BOOLEY_TEST_SEED.
      Doctor prints how each Simulation Target seeds its Test Runs.
    • Simulation and coverage Goals take the same selectors, @xN included.
      Goal Mode freezes the exact Test Runs at entry, so later tests.toml
      edits cannot change what a Goal requires. A failed Test Run stays failed
      until the code changes.
  • booley.dev. Booley has a project site at https://booley.dev/ with
    Demos and Videos pages, a blog, and application note AN-001, "Same AI agent,
    same chip bug: 56 minutes with a shell, 21 with the right tools". The user
    docs live there too, split into smaller pages with search (press /), an
    "On this page" outline and light and dark themes.
    Links Booley prints, the README and PyPI point there. Old
    boldaxolotl.github.io/booley/ links redirect; links into a section that
    moved open its old page.

Regular features

  • BOOLEY_AGENT_APP=auto (hand-written Sandbox specs, such as a Codespace)
    picks the agent app at every start: Claude, then Codex, then a configured
    gateway, then Claude with its login offered. Specialists, the MCP server,
    booley chat and Doctor follow that choice, and Doctor says why. auto
    outside a Sandbox is refused.
  • Sandboxes without the egress proxy. Host config.toml [sandbox] egress = "unproxied" (default proxy) runs Sandboxes on a plain Docker
    network; it cannot be combined with an egress_allowlist. Host Bootstrap
    then stops running the proxy and removes it once no Sandbox uses it.
    In-Sandbox Doctor WARNs sandbox.unproxied; host Doctor WARNs
    host.sandbox-egress-mismatch for a running Sandbox in the other mode.
    After changing the setting, run booley init --seed and rebuild.
  • Live Flow progress. booley flow synth|fpga|sim|lint shows a compact
    status row with the Flow, Target, step, elapsed time and latest tool output,
    with one row per parallel lane. Redirected output gets timestamped
    [booley-progress] heartbeats. -q/--quiet shows only the verdict and
    errors. Synthesis and FPGA runs end with a per-Target table (Δ columns with
    --baseline), and Simulation ends with a Test, Result, Cycles, Time and
    Build table.
  • booley resources. Booley records each Flow command's peak memory,
    temporary-directory size, CPU and wall time in
    .booley/runtime/resources/history.json. booley resources [--json]
    prints min, median and max per Target, phase and Test Run. Each Flow
    command now gets a private TMPDIR that is removed afterwards.
  • B-Wave clock analysis. The new bwave overview prints the sampling
    clock's verdict, any stretches where it stops, and trace metadata. Literal
    find and sample triggers skip cycles inside a clock stop unless you pass
    --include-stopped, and --sample-mode pre-edge reads values just before
    each edge. signal, wave and distance gain --format json.
  • bwave gui now drives VaporView 1.6.0 through a Viewer Bridge that the
    Booley Sandbox Integration extension runs in every attached window, instead
    of VaporView's WCP port. Scoped views keep groups, radix and color
    suffixes, --time markers, --cursor, --append and readback; markers are
    read back too. With several windows attached, a command targets the window
    whose terminal you typed it in. -t or --cursor without signals only
    moves the time window and markers. VaporView now installs from the Sandbox
    Image, with no network and no auto-update.
  • B-Wave -s globs also match relative to the common scope bwave list
    prints: with # scope: TOP.tb, -s 'dut.*' finds TOP.tb.dut.*. A glob
    that matches nothing suggests the full-path glob that would.
  • The MCP server picks up booley.toml and custom-endpoint changes without a
    Sandbox restart. Disabled Flows and Specialists leave the tool list,
    re-enabled and custom tools appear, and clients are told to reload. An
    invalid configuration fails closed.
  • booley init --scaffold --synth-mode logical|physical sets the scaffold's
    ASIC synthesis mode (default physical; a logical scaffold has no SDC).
    booley init --scaffold <name> --stealth keeps the scaffold's cores under
    .booley/cores/, so nothing Booley-authored reaches the RTL repository.
  • booley projects forget <root> lists the Docker images, state volumes,
    containers and networks the Project still holds, with sizes. --purge
    removes its unused images and state volumes, including the agent login copy
    and history, and says why it kept anything. booley init removes Project
    images its rebuild replaced.

Quality of life

  • booley doctor groups checks under section headers with one status glyph
    and ends with problem tables and one bold verdict line. Init, bootstrap,
    auth --status, feedback list, eda … list, flow/specialist
    listings, goal status and booley targets print aligned tables, and
    booley cheat fits the terminal. Piped output is plain; --json is
    unchanged.
  • booley targets adds a group row per .core file, a ✓ Doctor column, and
    a FLOW column listing the Booley Flows that can drive each Target.
  • Project commands accept -C/--project PATH, and Flows and Specialists take
    --timeout DURATION in human units. Commands that need a Project refuse up
    front outside one.
  • When --target is omitted, flow sim, lint, synth and fpga pick the
    only eligible Target and say so; with none or several they exit 2 and list
    the eligible Targets.
  • Flow and Specialist --help uses CLI spelling, groups options into Common,
    Output, Flow-specific and Expert sections, says what each default does, and
    ends with an example.
  • booley help matches booley --help, which groups commands by where they
    run. Bare booley on the host prints help and a getting-started hint.
    booley cheat lists its sections; --all prints everything, and --goals
    includes the Goal catalog.
  • booley --version shows the commit date, for example
    booley 0.4.0 (d4c94dc35, 2026-10-26).
  • booley chat passes extra arguments to the agent CLI, for example
    booley chat resume --last (Codex) or booley chat --resume <id> (Claude).
  • The Dashboard and CLI show durations as 10m 00s, ages as Started 10m ago
    and local clock times. JSON and report fields are unchanged.
  • booley init on an unmodified clone of a published booley-prj-* Project
    reports the Project ready instead of sending you to /booley-setup.
  • Setup's Step 0 asks its questions in plain English with a hardware glossary
    and one confirmation block for the defaults; "Keep Booley out of your git
    history?" sets Stealth Mode. Bootstrap warns, with install links, when
    neither Claude Code nor Codex is on the host.
  • Project Setup's Memory Timing Surrogate guidance now requires every read-data
    bit to depend, through registers, on the memory's write data, address and
    enables, and adds a no-pruning probe. A surrogate built under the old rule
    can let synthesis delete logic and understate area and Fmax: re-run setup's
    surrogate validation and fix any surrogate that fails.
  • In a Codespace or any Sandbox without a seeded host agent config, Claude
    Code and Codex skip onboarding, login and folder-trust prompts when a
    credential is present, and no longer try to update themselves.
  • Local Sandboxes install the Verilog-HDL and Live Preview extensions from the
    Sandbox Image; before, the locked-down network blocked them. VS Code's Chat
    side bar is closed once per workspace, and Codespace startup files open
    with their associated editor, so a getting-started Markdown file opens
    rendered.
  • Cost readouts price gpt-6-astra, gpt-6-luna and claude-haiku-5-5 at
    their own rates; they used to show $0.00 or the Haiku 4.5 price. Unknown
    gpt-* models are costed at the Astra rate.
  • Doctor adds WARNs for: Git excludes hiding Project inputs
    (project.inputs-ignored), a copyto input that overwrites another file
    (sim.runtime-input-collision), a Sandbox Git identity that differs from
    [agent.git] (sandbox.git-identity-override, sandbox.gitconfig-identity),
    oversized MCP handle maps (handles.map-size), and a Stealth scaffold whose
    cores are still tracked (stealth.scaffold-core-tracked). Many directory
    symlinks to one ancestor now produce one FAIL with examples.
  • In a Codespace on the demo gateway, a missing gateway token is a Doctor WARN
    instead of a FAIL. With an explicit BOOLEY_AGENT_APP, it still fails.
  • Mutation Tester --dry-run explains how --count auto was computed.
  • Job reports carry per-Target coverage percentages and up to 20 lint
    findings, so MCP clients need not open the full reports.
  • Persistent pipx, uv tool and ordinary wheel venv installs can be the
    canonical host installation. The README leads with pipx.
  • The user docs were rewritten for the engineer using Booley, with an Install
    guide and a new Specialists page, and checked against the code.
  • The RISC-V Sandbox Image ships the unprivileged and privileged ISA manuals
    from upstream release 20250508, as riscv-isa-unprivileged.{pdf,html}
    and riscv-isa-privileged.{pdf,html} under /opt/riscv-docs. References
    to riscv-isa-manual.{pdf,html} must name a volume.

Bug fixes

  • A Project whose .booley is a symlink, as in a GitHub Codespace or a
    Booley Directory kept in its own clone, now works throughout: Sandbox start,
    Targets and Stealth cores, Simulation and coverage (including agent sim
    calls), synthesis, Goal Mode, Pre-Sim hooks, deep Doctor and the
    Specialists. Only the .booley entry itself may be a link.
  • Goal worktrees and booley worktree new fill in the Project's git
    submodules offline, so baseline checkouts no longer fail with "submodule …
    not found in source Project".
  • sim with relative Cycle Count limits now works: it no longer fails
    planning with .baseline-wt-... already exists or prerequisite identities must be unique, builds the baseline in the baseline checkout, and can meet
    the limit.
  • booley session refresh no longer aborts on an untagged Docker image, and
    session up no longer fails with "Sandbox Project identity disagrees" or
    re-runs automatic Doctor on every start. session commands from a linked
    worktree find the owning Project's Sandbox.
  • booley init --check and --check-only list everything a full init would
    do, with a matching exit code. booley bootstrap --check-only runs every
    safe check and exits 1 for pending work, 2 for a blocker. A failed
    line-ending step names the real cause.
  • booley init and other writers into Sandbox-writable paths no longer write
    through a symlink, keep numbered backups (.1, .2, …), write atomically
    and never widen file modes.
  • Reviewer runs and booley feedback no longer leave a versioned Booley
    Directory dirty once the booley init ignore backfill in Upgrade notes is
    committed.
  • The Mutation Tester no longer leaves a mutant in your RTL after a cancelled
    or killed run, and no longer moves testbench directories out of the live
    worktree. It passes a Target's copyto inputs, plusarg defaults and env
    to every run, applies a qualified --target's Criterion settings, and
    handles testbench tags on symlinked sources.
  • Verilator and Icarus no longer kill themselves with exit 143 when Booley is
    PID 1, which showed up as COV_RAW_FILE_MISSING.
  • str and file vlogparams reach Yosys, sv2v, Verilator and Icarus as
    strings. Vivado refuses a string override before running. Cached results
    that used string parameters are invalidated.
  • ASIC synthesis no longer fails when Yosys warned about a combinational loop
    that its final check no longer finds; the warning becomes a WARN.
  • Lint, synthesis and FPGA runs over several Targets no longer show one
    Target's log under another.
  • A background sim Job polled through MCP reports its live stage instead of
    staying at starting. Losing one work item's Job Slot in a parallel
    Simulation Campaign stops only that item, and a passed item no longer fails
    with heavy lease lost. Parallel tests' progress lines stay under their
    own test.
  • After a cocotb 2.x batch times out, finished tests keep their real
    outcomes, without duplicates. A traced Cocotb run on Verilator records
    verilator as its simulator.
  • A traced Icarus run with trace_args set no longer exits 2, and it no longer
    reports TRACE_OK for a stale trace file.
  • In Stealth Mode, flow sim --trace works for a Target from a
    repository-native .core.
  • A bare-string [flows.sim].pre_run_commands is refused in preflight instead
    of being split into characters. Immutable-mode Pre-Sim Commands run in the
    Project Root as documented, including with run_cwd; a hook that relied on
    the old directory should cd "$BOOLEY_RUN_CWD".
  • tests.toml sections match Targets by identity: a qualified key serves only
    its core, a bare key serves Targets without one, and Doctor fails duplicate
    or dead keys.
  • Compiler-cache settings no longer fail Simulation when booley.toml is
    unreadable. Without BOOLEY_COMPILER_CACHE_ROOT, builds run uncached with a
    warning. Verilator make_options and Make variables such as OBJCACHE and
    MAKEFLAGS are no longer rejected.
  • Templated run_cwd cleanup removes the empty parents Booley created and no
    longer leaves run-lock files.
  • B-Wave: physical time bounds and tokens convert exactly and pick the right
    clock edge, including on phase-offset clocks; wave --async windows are no
    longer empty; synchronous find, sample and distance use clock-edge
    values and ignore glitches between edges; --format json carries the same
    warnings as text output.
  • Doctor no longer stops with a TypeError when the activity hooks or
    Dashboard extension are missing or when a Target has untagged C/C++
    harness files; it WARNs instead. Doctor's attached-window checks now run.
    In a Codespace it accepts ~/.ssh/authorized_keys and a symlinked
    BOOLEY_DIR. Host doctor --deep no longer fails simulation checks on
    Booley's own /booley-project alias.
  • Deep Doctor warns when a simulation bad overlay fails to build and requires
    a behavioral failure to accept it. It no longer blocks on the expected
    upgrade-review warning.
  • The Reviewer no longer fails when a Claude agent reports findings through
    ReportFindings more than once.
  • Text-only Codex Specialists such as coverage_analyst no longer need the
    model in the Codex models cache. When Codex exits early, Booley reports
    Codex's error instead of BrokenPipeError.
  • Interactive Claude Code no longer moves long Booley MCP calls into the
    background after 120 seconds.
  • Nested Codex homes link the real login instead of copying it, so token
    refreshes reach it; temp directories from killed runs are swept.
  • booley auth checks permissions before writing and no longer reports
    success before failing.
  • A command that cannot start prints command not found (127) or
    permission denied (126) instead of a traceback. Start notices appear only
    after the process starts.
  • Quiet image builds print each progress line once.
  • Booley MCP servers that Booley starts for its own agents no longer appear
    in the Dashboard.
  • The idle reaper keeps a Sandbox while an editor or terminal is attached.
    Session commands reuse VS Code-owned Sandboxes and refuse to tear them down.
  • Elab-only Simulation of standalone modules is no longer confused by /* or
    // inside string literals.
  • Feedback IDs stay unique across processes.
  • Booley finds VaporView and VS Code settings under ~/.vscode-remote
    (Codespaces) and ~/.vscode-server-insiders.
  • booley projects prune-keepers prints Nothing to release. when no keeper
    is eligible.
  • On Windows, reads and writes of Job, Simulation, Session, Goal and Doctor
    files retry through brief sharing errors instead of reporting the file
    missing, so Campaigns, baselines and cancellations no longer fail spuriously.

Internal work

  • Ticket Mode was removed (about 128,000 lines). Shared Flow loading, agent
    execution and waiver storage moved to their active owners;
    booley.ticket_board is gone.
  • Simplification campaign: Goal Records, campaigns, coverage, image
    lifecycle, the CLI parser and MCP were slimmed, and formats that no release
    ever wrote were removed.
  • The Codespaces demo's sponsored tokens go through an OpenAI-compatible
    gateway. Inside a Sandbox, BOOLEY_PRIMARY_AUTH=gateway with
    BOOLEY_GATEWAY_URL and BOOLEY_GATEWAY_TOKEN or
    BOOLEY_GATEWAY_TOKEN_COMMAND routes Codex, booley chat and Codex
    Specialists through it. This is plumbing for the demo.
  • QA missions were reworked for Goal Mode, and CI drives the PicoRV32 demo
    through a Goal.
  • CI: test timing and failure evidence, a guard against suppressed
    assertions, sharded Ubuntu suites, a narrower job set for docs-only PRs, and
    a weekly worktree-mount acceptance job.
  • Designs: Goal Mode and the Dashboard (ADRs 0067, 0068), Test Variants (ADR
    0072), the Result Cache (ADR 0076), and one worktree per Interactive session
    (ADR 0082, proposed).

Upgrade notes

  • Ticket Mode is gone. booley run and booley board print a pointer to
    /booley-goal and exit 2; the Ticket skills are replaced by /booley-goal.
    Doctor WARNs tickets.leftover-board on nonempty
    tickets/{board,state,logs,locks,waiver-candidates}: keep what you need,
    then delete them. tickets.leftover-guidance covers ticket_creation.md
    and ticket_defaults.md; move edited rules into Goalsets. tickets/history/
    is untouched. [developer], [developer.auto_retry] and
    [jobs].max_tickets are ignored; Doctor WARNs until you delete them.
  • The Booley Directory is now .booley/. Use BOOLEY_DIR and
    booley.runtime.booley_dir. Run full booley init in each existing
    clone before pulling
    a Project's rename commit; it migrates the old
    directory and repairs linked worktrees and Paired Checkouts. Stop running
    Sandboxes first. init --check and Doctor report a pending migration.
    Review and commit the tracked renames in each checkout; init does not stage
    them. If a pull already left both .booley_project/ and .booley/, init
    refuses unchanged. Do not git add -A: removed old ignore rules may expose
    local runtime, Goal and worktree state. Stop consumers and back up both trees
    and Git state. If the new directory holds only current tracked files, park
    it intact at a unique location outside every checkout, and keep the old
    directory and its worktrees. Then reconcile the parked tracked inputs into
    the old directory by hand, without overwriting local state, and run full
    init with only the old directory present. Verify tracked inputs, Goal
    inspection and both repositories' worktree registrations before retiring
    any backup. Booley never deletes or merges these trees itself. An
    interrupted migration keeps its journal: if a retry reports changed Git
    identities, HEADs or conflicting files, stop other writers, preserve the
    trees, Git metadata and journal, and reconcile the named conflicts before
    rerunning init. Do not delete the journal, prune worktrees or reset history
    to get past verification.
  • Refresh every Sandbox after booley bootstrap --update: run
    booley init, then booley session refresh in each Project. The Sandbox
    now carries its image ID and is refused at start until refreshed. The
    refresh brings the Dashboard hooks, the bundled VaporView 1.6.0 and VS Code
    extensions, and drops the Claude Code, Codex and Tcl VS Code extensions;
    the agent CLI in the terminal is the agent surface. Doctor reports any
    remaining drift.
  • Seeded Targets now default to seed 1 (#1233). Verilator and Cocotb runs
    that name no seed use seed 1 instead of the simulator's default, so
    random stimulus can change. Set default_seed to keep another seed.
    Icarus HDL-testbench Targets are unchanged until they declare a seed
    template.
  • tests.toml is stricter (#1233). Rerun booley doctor after each fix
    until it loads:
    • A Test name must not be empty or default, start with -, exceed 512
      bytes, or contain whitespace, a control character, +, @, <, >, a
      quote or a backslash. A Test appears at most once in tests and once in
      skip.
    • A Target section accepts only tests, test_list, skip, select,
      env, seed, default_seed and variants.
    • env may not set MODULE, TESTCASE, TOPLEVEL, TOPLEVEL_LANG,
      RANDOM_SEED, LIBPYTHON_LOC, PYTHONPATH, LD_LIBRARY_PATH, or any
      BOOLEY_*, COCOTB_*, PYGPI_* or GPI_* name. Use default_seed
      instead of RANDOM_SEED.
    • select must contain {index} or {name} and may not start with ++
      or +-.
    • Empty pre_run_commands entries, empty toplevels and copyto
      destinations outside the run directory are refused.
  • Simulation paths changed (#1233). Run directories and coverage run IDs
    are named by Test Run, so seeded Targets gain @seed
    (tests/reset@1/, run:001:reset@1). Read paths from report.json and
    simulation.json instead of building them.
  • 0.3.0 Simulation and Coverage Campaigns are no longer read (#2342,
    #2421). Resume, inspect, prune, analyze and Cycle Count baselines stop with
    an error naming the directory; delete it by hand or collect again. You can
    delete .runtime/campaign-child-executions/.
  • Simulation grading (#1233): an infrastructure stop is graded error;
    Mutation Tester scores can change now that runs use the Target's plusarg
    defaults and env; one request runs at most 1000 Test Runs of a Target.
  • Doctor fails .core flow_options.defines, which no Flow ever applied;
    declare vlogdefine parameters instead and re-plan Campaigns that used it.
  • [models.roles] accepts only reviewer, mutation_tester and
    coverage_analyst. Delete developer, recovery, triage_report and
    tb_coder pins; Doctor and agent commands refuse them. The hidden
    tb_coder Specialist is removed.
  • --work-dir, --project-root and --timeout-ms still work but print a
    notice; switch to -C/--project and --timeout. The hidden top-level
    --board/-b, --cheat and --doctor flags are removed. goal,
    session, feedback, cleanup and upgrade are no longer listed in
    top-level help; booley cheat --skills shows them.
  • Scripts that grep Doctor's [PASS] or === X === text, or init's [!!]
    and [XX] markers, must change; use --json where available.
  • B-Wave JSON output is schema revision 2. Literal match counts change on
    gated clocks.
  • Under [agent] auth = "auto", Sandboxes forward an exported
    ANTHROPIC_API_KEY, which bills per token. Set
    [agent] auth = "subscription" to avoid that.
    booley auth --status and Doctor fail when the selected credential is
    missing.
  • With a symlinked .booley, run booley init once to pin its target, and
    booley init --repin-booley-dir after you retarget the link. Doctor FAILs
    project.booley-dir-pin otherwise.
  • Rerun booley init in each checkout and commit its ignore backfill for
    Specialist reports and state. New non-Stealth Projects keep Goal history
    eligible for commits; init never stages or commits it.
  • Booley adds a Dashboard task to .vscode/tasks.json; opt out with
    [sandbox].dashboard = false. A tracked tasks.json is left alone.
  • Doctor treats unreadable sibling Git attributes as unknown policy;
    git.attributes-policy-unknown can stay a WARN on older Git, and
    init --check exits 1 until it is resolved or waived. Existing
    git.line-endings-unreadable waivers do not cover it.
  • booley cleanup apply --run-id <id> removes the whole Setup run root;
    booley cleanup record and its --digest, --retention and
    --cache-disposition options are removed. Delete run roots from older
    versions by hand.
  • Coverage finds RTL files without coverage points by a lexical scan; the
    Analyst's zero_point_sources view drops discovery_status,
    comparison_status and unusable_findings.
  • Deep Doctor keeps only the latest attempt; deep_status drops
    last_success, checks and latest-attempt-not-qualified.
  • Native-only coverage pruning deletes the whole native/ directory. Delete
    any .native-pruned/ left by an older interrupted prune before retrying.
  • Hook files retired by booley init are renamed <name>.pre-booley.
  • Unbound Flow and Specialist reports omit criterion_key and
    criterion_met; read them as optional.
  • Doctor defers generated cocotb test IDs to run time.
  • Known issue (#1529): the Sandbox shares writable Git metadata, so a
    Developer Agent can plant commands that later run as you when host Git
    runs, including from Doctor. SECURITY.md lists precautions.