Skip to content

v0.3.3

Latest

Choose a tag to compare

@github-actions github-actions released this 16 Nov 12:42
· 12 commits to main since this release
507e19a

Added

  • Signed checks: the daemon runs the checks itself. A profile can set verify: [{name, run, timeout_ms?}]. After the agent's run, the daemon runs each command in the worktree itself (inside the run's sandbox under isolation: process), with pipefail, a timeout and a process-group kill.

    • What is recorded: the command, the real exit code, duration, the output's SHA-256 and a redacted tail, HEAD, and a hash of the working tree including untracked files. The hash is computed through a private index, so yours is never touched.
    • Signing and storage: records are signed with ed25519 and stored as .itervox/attestations/<issue>/<run>_<profile>.jsonl, each run sealed with its final tree. The key is .itervox/attest.key: gitignored, in the isolation deny list, and created only when a profile uses verify.
    • What "done" means: a failing or tree-changing check holds the run as input-required, naming the check and its exit code. For a require_evidence name that is also in verify, the agent's own evidence file is ignored, so the writer is never the judge.
    • Where to see them: GET /api/v1/issues/{identifier}/attestations (viewer scope) lists the records with verified and a reason. itervox attest verify <file.jsonl> [--tree DIR] checks the signatures and the tree.
  • Signed checks in the dashboard. The issue panel has a read-only Signed checks section, read from GET /api/v1/issues/{identifier}/attestations (viewer scope): each run's checks with their name, ok/failed and exit code (or timed out), duration, short tree hash and whether the record verifies (the reason when it does not), the run's seal status and the signing key id. An issue with no records shows an empty state; a daemon that does not serve signed checks shows nothing.

  • Safety guide and a full-permissions warning. A new Safety guide covers three things:

    • what an agent can do by default (approvals bypassed, no sandbox, open network);
    • how to confine it, from a disposable machine down to repository rules;
    • how to keep secrets out of reach.

    itervox doctor gains a Permissions section. It lists agent.command as (default) and every enabled profile, with its backend, its permission mode and its isolation, and prints a WARNING: naming the runs with full permissions. A run has full permissions when no operating-system sandbox wraps it and its permission mode does not confine its backend: bypass, or any mode on Cursor or a custom backend. The warning does not change the exit code.

  • Local models, and a doctor check for model servers. A new Local models guide shows how to point a profile's agent at a model server on your machine. Its example is colibri with ANTHROPIC_BASE_URL=http://127.0.0.1:8000 claude. The guide covers OpenCode and Codex, the timeouts to raise, and which jobs suit a slow model. itervox doctor gains a Model servers section. It probes every ANTHROPIC_BASE_URL, OPENAI_BASE_URL or OPENAI_API_BASE assigned in a profile command, lists the profiles using each server, and warns when one does not answer. The warning does not change the exit code.

  • Quota pools: a separate usage-limit breaker for a backend on another model server. A profile can set pool: <name> ([a-z0-9-]+). Its runs then use their own breaker, keyed claude/local (or claude/local@host on a worker host), so a limit on Anthropic no longer holds a Claude Code profile pointed at a local server, and the other way round. agent.backend_fallback.chain and the profile_map backend keys may name such a lane. With chain: [claude, codex, claude/local] and profile_map: {coder: {"claude/local": coder-local}}, a limited claude reroutes to coder-local and switches back as usual. A lane's backend must be supported and its pool valid, and a profile_map target must run that lane; config load fails otherwise. Profiles without a pool keep their keys and their backend_health.json entries unchanged. A pooled breaker shows as claude/local on the dashboard and can be cleared like any other.

  • Desktop app: model servers and GPU health. The app collects the model servers that every running project's profiles point at, from the daemon's new viewer-scope GET /api/v1/model-servers (URL, variable, profiles, pools, and whether runs go to SSH worker hosts; URL credentials redacted below admin). Every 30 seconds it checks those on this machine (127.0.0.1, localhost, ::1), with any HTTP answer counting as up. When a project lists a model server, it also reads GPU usage and memory through nvidia-smi. Both show in a Model servers section of the tray menu and a panel in the project rail. A notification fires when a server that was answering misses two checks in a row, and again when it comes back. URLs taken from a variable, servers on other hosts, and servers used only by profiles that run on SSH worker hosts are listed but not checked. The doctor check and the endpoint share one extraction (config.ModelServerUses).

  • Desktop app: Open in Browser. Each project's submenu (macOS menu bar, Linux and Windows tray) has Open in Browser next to Open Dashboard, with the same enable rule. It opens the dashboard in the default browser, logged in the way itervox open does (<dashboard>/?token=<token>, which the dashboard stores and strips), using the address and token Open Dashboard uses, a remote daemon's tunnel included. Only an http(s) address goes to the system opener, and the address is never logged or shown. It is disabled for a remote project reached through its host's hub, whose token is the app's own long-lived hub token.

  • Claude Code plugin. Install it with /plugin marketplace add vnovick/itervox, then /plugin install itervox@itervox. The plugin bundles itervox mcp, at viewer scope by default (switch to operator with /plugin configure), and eight skills:

    • setup: install and itervox init;
    • issue: agent-ready issues;
    • doctor: itervox doctor and config show;
    • ci: the GitHub Action and itervox run --issue;
    • deploy: cloud VM; it moved here from .claude/skills/deploy;
    • local-models: colibri, pool and fallback;
    • automations: automations, dependencies and stacked PRs;
    • operate: day-to-day work through the MCP tools. Guardrail approvals stay human-only.

    Run a skill as /itervox:<skill>. TestPluginSkillsNameRealCommandsAndFlags, TestPluginSkillsNameRealSettings and TestPluginVersionMatchesLatestRelease fail when a skill names a command, flag or setting the CLI does not have, or when the plugin's version drifts from the latest release. New guide: Claude Code plugin.

  • itervox config show ends with "How agents run". It shows the same per-profile summary after the settings table, so the command shows what the configured values add up to at dispatch, not only the values. --json is unchanged.

  • Lanes: an agent may change what CI checks, never how CI checks. The pre-push hook sorts every push by the paths it changes, against the merge base with the base branch. A push that touches the human lane (by default .github/**, .gitlab-ci.yml, .circleci/**, .itervox/** except handoffs, WORKFLOW.md, CODEOWNERS, test and coverage configs, .golangci.yml and Makefile) is held for operator approval, and the dashboard shows the pipeline files it changes. A path in guardrails.lanes.second_opinion lets the push through, but merge_pr refuses the PR until a reviewer on a different backend approves it. merge_pr always refuses a human-lane PR. Set guardrails.lanes.human: [] to turn the lane off. If the hook can't classify a push, it treats it as human lane. TestPrePushHumanLaneHoldsForApproval, TestSecondOpinionNeedsDifferentBackendReviewer and TestMergeRefusedForHumanLaneRun pin the behaviour.

  • Safer CI mode for the GitHub Action. A new step, Check the pipeline is out of the agent's reach, runs before the agent and refuses the run with exit 5, listing every refusal. It refuses when:

    • WORKFLOW.md, .itervox/settings.jsonc or .itervox/agents/ in the checkout differ from policy-ref (default: the repository's default branch), so the run's policy comes from the base branch, not from the branch being worked on;
    • policy-sha256 is set and WORKFLOW.md has another hash (the actual hash is printed);
    • the token is a classic token with the workflow scope;
    • deploy credentials are in the job's environment (AWS_SECRET_ACCESS_KEY, NPM_TOKEN, *_DEPLOY_TOKEN, …). Only variable names are read, never values, and the agent's own API keys are not counted. allow-env names variables to let through, such as the cloud keys an agent on Bedrock or Vertex needs.

    safe-mode: false turns each refusal into a warning, and dry-run reports without enforcing. The check is action/pipeline-check.sh, tested offline by action/pipeline-check_test.sh. The CI guide has a recommended setup: an agent job with contents, pull-requests and issues: write and no deploy secrets, and deploys from a separate workflow after the merge.

  • itervox doctor gains a Lanes section. It prints the guardrails.lanes globs in effect (the default marked, [] shown as off) and warns when the human lane or the guardrails are off. It also warns when a profile's verify check is defined by a file outside the human lane, for example make test with no Makefile in the lane, or pnpm test and package.json. It lists require_evidence names that no verify check runs as agent-reported, not daemon-run. None of it changes the exit code, and itervox config show prints the same section after "How agents run". TestDoctorLanesWarnsMakefileOutsideHumanLane, TestDoctorLanesOff and TestDoctorLanesSelfReportedEvidence pin it.

  • itervox referee: a CI referee for any agent and any CI. Shipped in every release as itervox referee <command>, and as a standalone referee binary for projects that do not use Itervox (cmd/referee, make referee or go install; both wrap internal/referee). itervox referee starts before .itervox/.env is loaded, so the checks it runs never inherit those secrets. An agent may change what CI checks, never how CI checks.

    • referee lanes --base <ref> sorts a pull request's files into human, second_opinion and auto (exit 20 / 10 / 0). The rules come from .referee.yml read from the base ref, never from the branch being judged.
    • referee audit reports changes that weaken checks: removed or renamed tests, added skips and .only, lowered coverage thresholds, continue-on-error: true or || true in CI config, --no-verify.
    • referee pin checks a policy file's sha256; referee keygen, run and verify sign check runs in the same record format as itervox attest verify.

    Any error exits 2, never 0. A composite GitHub Action (referee/action.yml) and a guide ship with it.

  • brew install vnovick/tap/referee: the referee as its own Homebrew formula. Each release now also ships referee_<os>_<arch> archives (tar.gz; zip on Windows) holding only the standalone referee binary, and a referee formula in the tap that installs just that binary. referee --version (or referee version) prints the release version. The itervox archives, their names and the itervox formula are unchanged; checksums.txt lists both sets of archives.

  • itervox hook: the guardrails in your own Claude Code and Codex sessions. itervox hook claude-pretooluse and codex-pretooluse read the tool call before it runs. Refusals are denied; approval commands and edits to human-lane files ask you first (Codex has no ask, so they are denied). A workflow that cannot be loaded asks. itervox hook install claude|codex merges the entry into the project or user settings and keeps your other keys. The hook reads the command before the shell expands it, so it is a convenience layer: the shims and the pre-push hook remain the enforcement.

  • Sessions: New session survives a daemon restart, and sessions stop properly. A session started with New session is tagged with tmux user options (@itervox-project and others). A restarted daemon re-adopts a session named itervox-<id> whose @itervox-project is its own project directory — never by name alone — up to the cap of 8. The session is controllable and stoppable again, and its tab says re-adopted after restart. Its guardrails come from the previous daemon process, whose token is gone: they still refuse locally, but pushes that guardrails.lanes must report are refused, and the tab says so. Stop session (admin, POST /api/v1/sessions/{id}/stop) presses the CLI's Ctrl-C (twice for Claude Code), waits up to 5 s, then runs tmux kill-session. Force stop kills at once. A hand-started session in a tmux pane with sessions.tmux_control gets the keys only, never a kill. Any other hand-started session shows how to stop it in its own terminal (Ctrl-C, or kill <pid>). Each stop is logged and fed as session_stopped. See Sessions.

  • Approval rules scoped to an environment. A guardrails.approval_commands entry may be {match, when_env}, held only when the environment matches, for example terraform apply when TF_WORKSPACE=prod*. The shim checks the real environment at exec time. Plain string entries are unchanged; a malformed object is a startup error.

  • Patches only: the daemon pushes (push: daemon). Set it on a profile (or agent.push for all of them). That profile's agent gets no forge or tracker credentials, and its shims and pre-push hook refuse git push and pull-request writes. After the run and its gates (after_run_required, verify, require_evidence), Itervox sorts the diff into lanes (a human-lane change waits for approval), pushes the commit with its own credentials and opens the pull request. With verify, only the tree the signed checks ran on is pushed. Needs guardrails.enabled; refused with agent.ssh_hosts. The default (agent) is unchanged.

  • Pipeline-guard demo. scripts/pipeline-guard-demo.sh and scripts/pipeline-guard-capture.mjs reproduce "an agent asked to fix a red build edits the pipeline instead" with a scripted agent doing real git work behind the guardrails: unguarded (pushed, green, tests still fail) and guarded (held in the human lane, signed check exit 1, code fixed, signed check exit 0). demo/pipeline-guard/RECORDING.md explains how to run it and how to record it with a real agent.

  • Docs: four new guides. Lanes, Signed checks, Pipeline-guard demo (how to run scripts/pipeline-guard-demo.sh yourself) and What's new in v0.3.3 (every feature since v0.3.1, with upgrade notes), linked from the sidebar, the Guardrails, CI and referee guides and Getting started.

  • Docs: screenshots in the guides. The Lanes, Guardrails, Signed checks and Pipeline-guard demo guides show each step as a numbered flow of dark/light dashboard screenshots (a held pipeline push, an approval on the phone, a failing then passing signed check); eleven more guides gain the current dashboard screenshots, and Agent profiles, Automations and Configuration replace their v0.2.0 ones. make guide-shots regenerates them from route-mocked Playwright specs in web/e2e/guide-shots/.

  • Fuzz tests for the guardrails and signed checks. FuzzDecide, FuzzMatchApproval, FuzzLanes, FuzzRecordVerify and FuzzRecordByteFlip, run with make fuzz (FUZZTIME, default 30s; not part of make verify); their seeds run under go test. scripts/guardrails-shim-latency.sh measures the git shim: about 8–9 ms per call at p50 on a loaded 4-CPU test machine.

  • itervox evals in the released binary. The profile evals no longer need a repository checkout: itervox evals recorded (free, no agent), ITERVOX_EVALS_LIVE=1 itervox evals live, itervox evals record and itervox evals promote are the commands make evals* runs, now shared through internal/evals/cli (cmd/itervox-evals stays as the contributor wrapper, so the Makefile targets are unchanged). Scenarios come from -fixtures DIR, else the project's .itervox/evals/fixtures, else the built-in scenarios embedded in the binary; record and promote write next to the fixtures and so refuse the built-in set. Reports go to .itervox/evals/ next to WORKFLOW.md, where Repo Analysis → Evals reads them; its empty state, the CLI reference and the Repo Analysis guide now name itervox evals instead of make evals.

  • itervox open: the dashboard, logged in. Opens the running daemon's dashboard in your browser (open on macOS, xdg-open on Linux, rundll32 on Windows) with its API token as ?token=, which the dashboard keeps and removes from the address bar; the token comes from ITERVOX_API_TOKEN, .itervox/.env or the auto-generated <logs-dir>/api-token. --print prints the URL instead and says on stderr that it contains a credential. itervox init's next steps point at it instead of .itervox/dashboard_url, whose URL has no token, and itervox doctor now says where the token is (API token:).

  • Docs: Agents in CI: fix the build, not the pipeline. The ideas behind lanes, guardrails, signed checks and referee in one page, linked from the referee guide and the README.

Security

  • Guardrail bypasses closed (found by the new fuzz tests):
    • git push --no-verif and git's other abbreviations of --no-verify no longer skip the guardrail hook;
    • git -c include.path=… and includeIf.*.path count as replacing the hooks, since an included file can set core.hooksPath;
    • gh pr -R owner/repo merge and glab mr -R … merge are refused as self-merges;
    • an argument with a literal * no longer slips past a * in an approval_commands pattern (gsutil rm 'gs://prod/**' against gsutil rm gs://prod/*).
  • Signed checks: a record verifies only with the exact signature encoding the daemon wrote. Base64's ignored trailing bits had let an altered sig still verify.

Fixed

  • Guardrails no longer refuse an agent's read-only git calls that disable hooks. Claude Code runs its own checks as git -c core.hooksPath=/dev/null … ls-files --error-unmatch -- …, and the shim refused every core.hooksPath override as hook_bypass (84 refusals in one minute, flooding the recent-failures list). The override is now let through for a fixed list of git builtins that run no hook — blame, cat-file, check-attr, check-ignore, check-ref-format, cherry, count-objects, diff-files, diff-index, diff-tree, for-each-ref, grep, log, ls-files, ls-tree, merge-base, name-rev, rev-list, rev-parse, shortlog, show, show-branch, show-ref, var, version — and dropped from what the shim hands git, so git and anything it starts still see the guardrail hooks. The subcommand is found by reading git's global options as git does (exact names, -c/-C with a separate value); an unknown or ambiguous option, --exec-path, --help, any other subcommand (commit, push, merge, rebase, checkout, status, diff, …), and a -c alias.* or config include next to the override stay refused. A guardrail refusal that repeats now coalesces into one recent-failures entry per issue and guardrail kind, with a count and the latest command.
  • The log redactor no longer masks whole absolute paths. A path such as a macOS temp directory (/var/folders/x8/<random>/T/<test>/001/…) mixes cases and digits across its segments, so the whole run looked like a random secret and became *** (TestHeadlessOnATTYDoesNotStartTheTUIOrPrintTheToken failed on macOS). An absolute path (a leading /, three or more segments, one of them a word) is now judged segment by segment, so only a segment that itself looks like a token is masked; prefixed keys, ?token=, Bearer values and a token used as a path segment are still masked, and a base64 secret that happens to contain / is still judged whole.
  • A held push no longer fails after agent.read_timeout_ms. While a guardrail approval is pending, the agent prints nothing, so the turn used to fail after 30 seconds and be retried. The idle read deadline is now suspended while the run waits for the operator and restarts in full from the answer, and a run waiting for an approval is not treated as stalled. agent.turn_timeout_ms still bounds the wait.
  • Tracker polling no longer resets the stall timeout. Every poll that found a running issue still in an active state (or an automation run, a reviewer on the completion state, or an in-place review continuation) stamped the run's last-activity time with the poll time. agent.stall_timeout_ms measures silence against that time, so an agent that produced no output was never stopped while the tracker kept polling. Only agent activity (worker updates) and an answered guardrail approval restart the stall clock now; the dashboard's "last event" time likewise reflects the agent, not the poll.
  • An automation run takes one turn. A helper on an issue in an active state kept taking continuation turns of the same prompt, up to agent.max_turns: an input_required helper answered with provide-input, then ran again and again (8 of 8 turns in one report). Every automation run (cron, input_required, issue_entered_state, pr_* and the other triggers) now ends after its first turn; a Sessions-panel message still gets it one more. Worker runs keep their continuation turns, and so does a rate_limited recovery run with auto_resume (it runs as a worker). The blocked run is resumed once, after the helper's exit.
  • The scaffolded input-responder only answers. Its SOUL.md and INSTRUCTIONS.md (itervox init) say its whole job is to answer the blocked agent's question once with provide-input, and that it never edits files, commits, pushes, opens a pull request or moves the issue; the issue's task in its prompt is the blocked agent's work. A responder had implemented the task itself, with a commit and a push. Existing projects keep their files; push: daemon on the profile refuses its pushes outright.
  • Automation chains keep their handoffs. With workspace.auto_clear on, an automation run's success cleared the issue's worktree and deleted its branch, although the issue was not finished: in an issue_entered_state researcher → implementer chain the researcher's committed handoff disappeared and the implementer started from a fresh worktree without it in ## Prior Agent Handoffs. An automation run's success now clears the workspace only when the issue is terminal by then, as the auto_clear docs already said.
  • blockers_resolved fires for Backlog issues. The documented backlog → Todo flow never fired: the per-tick dependency audit runs over candidates (active states) only, and the states scan that could audit a Backlog issue ran only after some other issue's blockers resolved, so a Backlog issue was never recorded as blocked and its unblock was never a transition. The off-loop dependency refresh now also runs that scan once per agent.dependency_audit_refresh_interval_ms (and on the first tick), over the rule's filter.states — plus tracker.backlog_states when the rule names no states or uses match_mode: any. A row the scan just read is not fetched again by ID in the same batch, which on GitHub (whose by-ID read leaves blocker states unknown) had discarded the scan's unblocked copy. Same for Linear, GitHub and local issues.
  • issue_entered_state fires for local issue files without created:. Moving a hand-written issue (no created:, which is optional) from Backlog into the trigger state never fired, because the poll cannot tell a move from a creation without a creation time. The local tracker now reports the file's modification time when it first read the file as its creation time; a state edit does not change it, and nothing is written to the file. A file written straight into the trigger state still does not fire.
  • An automation without profile is a config error. The parser skipped a rule with no profile (or no id or trigger.type) before validation saw it, so the daemon started without it and the compile summary said dropped=0. It is now refused at startup, on reload and by itervox doctor, with an error that names the rule (automation "unblock-backlog" requires profile), as the Settings automation editor already did.
  • A held pipeline push shows its files. The list of pipeline files now appears in the Needs-attention reply row and in the issue's Now panel. Before, it only rendered in the input-required panel, which a held push never reaches because its issue is still running.
  • A per-issue profile override survives a config reload. Editing WORKFLOW.md or .itervox/settings.jsonc reloaded the daemon and dropped every override set with POST /api/v1/issues/{identifier}/profile, so the issue showed agentProfile: null and its next run used the default profile. Overrides are now kept in .itervox/issue_profiles.json (runtime state, ignored by git), like the playbook choices, so they also survive a restart.
  • Dismissing an input request sticks. After dismiss-input, moving the issue back to an active state rehydrated the same unanswered question comment from the tracker and blocked the issue as input_required again. The dismissed question is now recorded by its comment (persisted in input_required.json), so that comment no longer blocks the issue; a new question still does.
  • A reply to a rehydrated input request runs the issue's profile. An input request rebuilt from a tracker comment carried no profile, so the reply resumed the default agent command. The rebuilt request now records the issue's profile, and a resume without an agent session uses the issue's effective profile (the operator's override, else an automatic switch, else the run's own). A reviewer's resume keeps its reviewer profile.
  • switch_to_profile reassigns the issue. When an operator had pinned a profile on the issue, a rate_limited switch ran the fallback run on switch_to_profile, but the issue's agentProfile and its next dispatch stayed on the pinned profile. A switch recorded after the pin now takes precedence until it is reverted (after a successful run or agent.switch_revert_hours), and the pin applies again after that. A pin set after the switch wins. backend_fallback reroutes follow the same rule.
  • The hub's phone view names the files of a held pipeline push. When an agent's push changes guardrails.lanes.human files, the approval on a phone now shows which files it touches:
    • the needs-attention card on /hub/m reads "Pipeline change · changes .github/workflows/ci.yml (+N)";
    • the issue page's approval card lists the files (up to 10, then "and N more") right above Approve and Reject, as the dashboard's "Pipeline change" notice does.
  • The lane matcher is polynomial in ** segments (it was exponential on deep paths), and a long run of git -C options is linear.
  • Editor suggestions are readable again. The @/{{ suggestion list and its description panel in the SOUL.md, INSTRUCTIONS.md and prompt editors used the translucent glass --panel after the redesign, so the text behind them showed through. They now use the opaque --surface with a shadow, as toasts do; the editor's search panel too.
  • itervox init --update writes a workflow that starts. A legacy profile with only a prompt: was migrated without a command, and the daemon then refused the workflow (agent.profiles.<name>.command is required in schema 2) with no warning from the migration. Such a profile now gets agent.command (the older daemon ignored a profile without a command, so its issues ran on agent.command), or its own backend's CLI when it names another one (backend: codex → codex), and the migration prints each command it set. Re-running init --update on a migrated project no longer fails over the first run's WORKFLOW.md.bak: it read the moved agent.deps_analyzer_profile from the front matter only, saw it unset and tried to migrate again; it now reads the settings files too, prints nothing to migrate and exits 0 without touching the backup. Its errors no longer carry the itervox init --update: prefix twice.
  • itervox init ignores .WORKFLOW.md.lock. In a repository without a root .gitignore, init and init --update added nothing, so the WORKFLOW.md edit lock (and WORKFLOW.md.bak) next to the workflow were left for git add . to commit. They now create the root .gitignore in a git repository. The other runtime files (daemon.pid, its lock, dashboard_url, HEARTBEAT.md, tokens.json.lock) were already ignored by .itervox/.gitignore.
  • itervox status and itervox stop count only daemons. They found a project's daemons by every process whose command line mentions itervox and whose working directory is the project, so a tmux session from Sessions → New session counted as a second daemon: tmux itself (-s itervox-…), its shell (guardrail shims on PATH) and the guardrail shims and pre-push hook, which are the itervox binary run as itervox guardrail-shim … git. Only the itervox binary started with no subcommand (or itervox demo) counts now, and itervox stop no longer signals those processes.
  • A settings-file reload names the file. A hand edit of .itervox/settings.jsonc (or the user or local settings file) logged reload: WORKFLOW.md changed — draining…; the drain lines now name the file(s) that changed.
  • The quickstart tests no longer fail on a machine running itervox. A daemon or hub on port 8090 made doctor's port warning fail TestQuickstart* (and make verify); the tests now stub doctor's port probe, and TestDoctorWarnsWhenAnotherProcessHoldsThePort keeps the check covered.
  • The desktop app's Projects menu names your projects. It listed nine fixed items, "Project 1" … "Project 9", however many projects there were. It now lists one item per project in rail order (at most nine), labelled with the project's name and carrying the ⌘1…⌘9 shortcut (Ctrl on Linux and Windows) that goes to it, and none when there are no projects. The menu is rebuilt when a project is renamed, added, removed, pinned, unpinned or reordered.
  • The desktop app no longer looks as if it never started. On a MacBook whose full menu bar hid its icon behind the notch, a first launch showed nothing: no Dock icon, no window. A first launch with no projects and no remotes now opens a welcome window that says where the icon is, warns about the notch and offers Add Project…; opening the app again while it runs (Finder, Spotlight) shows a window — the minimized one, the first running dashboard, or the welcome window with Start / Open for each project. Later launches with a project are unchanged.
  • Adding a remote while a daemon starts or stops no longer asks for its token. A daemon wrote .itervox/dashboard_url before its token file and its host registry record, and removed the record before that file on shutdown. In between, itervox status --all --json found it by process scan with a port but an unknown token and no token_file, so the desktop app's "Add remote" asked for a token it could have read. The daemon now writes dashboard_url last and removes it first, and status reads a registry record that appears while it scans.
  • Desktop app: the project tab strip is no longer hidden under the title bar (macOS). Tauri's default macOS title bar style turns on a full-size content view, so the content area started at the window's top edge: the 40-point strip sat behind the title bar and the dashboard, laid out at y = 40, covered what was left (a sliver of the tabs). Dashboard windows now use the transparent title bar style without a full-size content view, so the strip and the dashboard start below the title bar.
  • itervox doctor accepts a profile command that sets a variable first. ANTHROPIC_BASE_URL=http://127.0.0.1:8000 claude, as the Local models guide writes it, was reported as "agent command not found on PATH" and made doctor exit 1, although the daemon runs it. Doctor now reads the program the way the daemon does (config.FirstCommandToken: env assignments and an env prefix are skipped).
  • Memory → Promote shows the right diff in a project reached through a symlink. The diff compared git's toplevel (symlinks resolved) with the unresolved path, so a committed .itervox/memory.json was reported as "not committed yet" and shown whole.
  • Hand-started sessions run through a shell wrapper are recognised on macOS. ps reports a script started through its shebang as /bin/sh /path/claude; a claude or codex script run by sh, bash, zsh or dash now counts as that CLI, as Linux's /proc comm already did.
  • deploy/gcp/provision.sh --public works on macOS. bash 3.2 with set -u treats an empty array as unbound, so --public failed with NETWORK_ARGS[@]: unbound variable.
  • The Action's pipeline check runs under macOS sh. bash 3.2 read a case pattern's ) inside a command substitution as its end, so action/pipeline-check.sh failed with a syntax error on a macOS runner.
  • make verify passes on macOS. clockTicks moved to the Linux-only file that uses it (lint), check-no-bare-go.sh reads its allowlist without a command substitution (bash 3.2), check-deadcode.sh analyses the Linux build, and the tests that compared a /var temp path with the /private/var path the OS reports, the tmux rig among them, resolve it first. TestGuardrailApprovalHoldOutlastsReadTimeout gives the shim a 1 s read timeout (200 ms raced a cold exec on macOS).
  • Guardrails let the rest of Claude Code's own git calls through. After the read-only fix above, each guarded Claude run still logged about four hook_bypass refusals (in Recent failures): Claude Code's remote get-url, config --get/--list/config user.name and status --short, all with -c core.hooksPath=/dev/null. The read-only forms of remote and config are now allowed (a config or remote write is still refused), and status, diff and describe are allowed too: the override is dropped before git runs, so the post-index-change hook they can run still runs. Measured with a real guarded Claude run: 0 refusals (was 4). TestDecideAllowsClaudeCodesGitCalls replays the calls Claude Code makes, captured with a logging git wrapper.
  • itervox hook no longer fails silently when another itervox is first on PATH. The installed hook runs the bare itervox; an older one (no itervox hook) makes the hook fail, which Claude Code and Codex treat as non-blocking, so the guardrail did not apply. hook install now warns when the itervox on PATH is missing or is not the binary you ran, itervox doctor warns for each installed hook in that situation, and hook install --absolute writes this binary's path (the PATH path when it is the same binary). Switching between the two forms replaces the entry.
  • make desktop signs the app ad hoc unless APPLE_SIGNING_IDENTITY names a real identity, so a local build passes codesign --verify --deep --strict, as the release workflow's unsigned builds do.
  • Docs: the README and the 0.3.0 notes no longer promise a signed Mac app. They said the app is signed, notarized and updates itself, and gave brew install --cask vnovick/tap/itervox-app without a condition. The cask and the updater manifest are published only by a signed, notarized release; both now say so, as the Desktop app guide already did.
  • Docs: the Manual testing and Desktop app guides match the code. Manual testing uses the local tracker (init --tracker memory is gone), says how to find the dashboard's port (server.port: 0), puts settings in .itervox/settings.jsonc, corrects max_retries: 0 (unlimited), the handoff commit, the cron, input_required, pr_opened, rate_limited, issue_entered_state and blockers_resolved setups, and adds scenarios for lanes, signed checks, itervox hook, itervox referee, push: daemon, model servers, tmux sessions and itervox evals. The Desktop app install section says when a Mac build is signed (-unsigned files are not), that the Homebrew cask exists only after a signed release, how to open an unsigned build on macOS 15 and later, and that updates are off without an updater key.

Changed

  • Desktop app: project tabs across the top of the window, and the dashboard's own sidebar. Each dashboard window now shows its projects as a strip of tabs under the title bar, in place of the project rail on the left, with the dashboard under it at the full width. The tabs come from the same data as the rail (pinned first, then the hub's members, the daemons outside the hub and remote daemons by host, a thin divider between groups) and show each project's health dot, name, running count and a badge for questions and approvals waiting for you; the tooltip has the full status line and the ⌘ shortcut, and the shown project's tab is marked. A click shows a project in this window; ⌘/Ctrl-click or a middle-click opens it in a new one. Tabs are dragged into order within their group or moved with ⌥←/⌥→; a tab's context menu (right-click, the menu key or Shift+F10) has Open in New Window, Pin Tab / Unpin Tab, Move Left / Move Right and Hide Project Names; + at the end adds a project. Too many tabs scroll sideways (a vertical wheel scrolls too), and a ⌄ button lists every project; the strip never wraps. Show or Hide Project Names (⌥⌘S) now switches between named and compact tabs (dot, initials and badge). The tab menu and the ⌄ list are native menus, since a menu drawn by the one-row page would be cut off. ⌘1…⌘9 and ⌘⇧[ / ⌘⇧] still go to the same projects, in tab order. The strip is opaque in light and dark: it no longer sits on Liquid Glass, vibrancy or Mica (the Sessions window still does). As before, it is an app-local page (desktop/dist/tabs.html, replacing rail.html) with no IPC, no network access and no token, and its actions go through the window's navigation intercept. The embedded dashboard now shows the same sidebar and phone drawer as in a browser (plus Issue view); the top bar's Board / Sessions links and More menu are gone, and the Go menu still navigates through window.__itervoxNavigate. The top bar stays on one row from the md width up: status pills that do not fit fold into one +N pill that names them (in a browser too), and the capacity bar shows from the xl width up. Guide: desktop app.
  • internal/attest shares PrintVerification, LoadKey and AppendFile between itervox attest verify and referee verify, with no change in behaviour.