Skip to content

Changelog

All notable changes to @agenticengineeringagency/ultimate-harness are recorded here. Format follows Keep a Changelog; the project adheres to SemVer.

Issues are tracked in Linear; PRs live in GitHub.

The first release candidate of 0.11.0, published on npm’s next dist-tag; latest stays on 0.9.0 until the final 0.11.0. It holds everything since 0.9.0; nothing after 0.9.0 has been published. 0.10.0 was prepared on dev in June 2026 but never tagged: it is skipped, and its changes (UH-138, UH-139 and the spec-stale fix below) ship in 0.11.0.

  • Artifacts written by 0.11 can carry fields that 0.9.0 does not know, under the same .v0 version: the mission, runtime session and runtime result schemas gained optional fields (usage, cost, post-check results, completion, a worker’s template and guard, and others), and the .v0 schemas are strict, so a 0.9.0 reader rejects such an artifact. Nothing 0.9.0 wrote is rejected by 0.11: the shipped 0.9.0 example packets and 0.9.0-shaped runtime session and result documents are parsed in tests/v09-artifacts.test.ts. Run every uh command on a project with one version, or finish old runs before upgrading. #267.
  • uh mission prune-runs <mission-id> --keep <n> [--json] archives a mission’s oldest runs beyond a cap and removes their run directories (the pruner uh validate --repair already used), so a caller no longer needs its own copy. #267.
  • Capability checks warn by default (UH-138). A mission capabilities: tag the resolved adapter does not declare prints one [WARN] line per tag and the run proceeds; --strict on uh mission dry-run, run and run-all turns each mismatch into an error. --force bypasses the check with a [WARN] line naming the runtime. runtime_requirements stay hard preconditions and are never relaxed.
  • Runnable examples/missions/hello-uh walkthrough and a no-dependency documentation dead-link checker (bun run docs:check-links, run in CI) over docs/ (UH-139).
  • Native ACP (Agent-Client Protocol) v1 adapter: acp runtime supporting headless agent orchestration via standard JSON-RPC 2.0 over stdio with run-id integrity, strict uh.runtime-result.v0 validation, wire-conformance error mapping, bidirectional permission request handling (session/request_permission), timeout and cancellation signal threading, and 17 regression tests.
  • Progressive semantic routing: chooseSemanticRoute in src/harness/auto-route.ts combining Level 0 deterministic eligibility (runtime_requirements, capabilities, fleet, and decision_policy.allowed_runtimes) with Level 1 TypeSafe System One (JEV) classification. Evaluates task cognitive complexity and selects the optimal adapter and model from candidate options with calibrated confidence, writing uh.decision-receipt.v0 receipts.
  • Mission decision_policy schema: DecisionPolicySchema in src/schema/mission.ts allowing missions to specify enabled, min_confidence, allowed_runtimes, allowed_models, require_provider_for_route, require_provider_for_retry, escalation_model, and fallback_model.
  • ACP session template: .harness/templates/acp-worker.yaml and runbook docs/runbooks/acp-setup.md.
  • guard.allow_native_subagents (default false). Native sub-agent tools (task, agent, subagent, spawn_agent, dispatch_agent, delegate) are denied by tool name for every role; a denied worker is told to end with ESCALATE: <what its orchestrator should delegate>.
  • Delegated-agent route attestation. Supervision reads the structured details.progress[] / details.jobs[] metadata of native tool events and stops the run with route_mismatch, naming the route, when a sub-agent runs on a provider or model outside the assignment. Tool arguments and tool text are never read.
  • oh-my-pi runs receive a per-run omp-overlay.yml through --config. It pins every OMP model role to the assigned model, sets task.eager: default, disables the advisor, and sets task.maxRecursionDepth: 0 so the native task tool is not offered (1 when the guard allows native sub-agents).
  • Project fleet policy. fleet.routes in .harness/project.yaml lists the models the project authorizes, per adapter and role. uh mission run, run-all and every run-team worker are refused before spawn when the assigned model is missing or outside the fleet. --force does not bypass it. A project without a fleet block is unchanged.
  • Codex adapter: optional runtime_config.model, passed to codex exec, with route attestation through the shared supervised process runner. Without a configured model behavior is unchanged.
  • containment_escape guard class: launches that leave the supervised process tree are denied (Win32_Process.Create through WMI or CIM, scheduled tasks, services, setsid, systemd-run, disown, at, batch, crontab edits, backgrounded nohup). Read-only forms such as schtasks /query stay allowed.
  • guard_tamper guard class: writes to the guard policy or log, or to harness state outside the worker root, are denied and stop the run with policy.
  • limits.max_thinking_ms: reasoning output counts as liveness for the stall check, bounded by this budget (default four times stall_timeout_ms). Repetitive reasoning is detected from window frequencies and does not count as live. Reasoning text is never persisted.
  • Experience store: a read-only index over settled runs with grouping by runtime, model, workflow profile or stop code, and a success-rate versus cost Pareto frontier. Unknown cost, tokens and durations stay unknown.
  • OpenTelemetry export: uh observatory export <mission> --otlp writes one run as OTLP/JSON following the GenAI semantic conventions (invoke_agent, chat, execute_tool) with deterministic ids. Tool arguments, results, message text and prompts are never exported; tool targets are opt-in.
  • uh observatory runs [--mission] [--group-by] [--json].
  • Terminal contract for uh mission run: --quiet, a final single-line UH_RESULT {json} without absolute paths, and exit codes 0 passed, 1 failed, 2 blocked, 130 cancelled.
  • Native event stream loop-probe: src/harness/loop-probe.ts projects Command Code (toolCallId sequence from tool_queued to tool_completed) and oh-my-pi events accurately, calculating real repeat and alternating signatures without false positives.
  • OTLP Trace Push client: src/harness/otlp-push.ts sends exported GenAI traces to an OTLP HTTP endpoint with bounded retries, capped retry-after backoff, and strict secret protection.
  • Run arm comparison and A/B template evaluation: src/harness/run-comparison.ts compares run sets using Wilson score intervals and cost-per-success without misrepresenting unpriced runs.
  • Team run salvage: src/harness/team-run.ts preserves verified work from workers stopped by limits or deadlines when their declared outputs and checks pass, recording eligible branches in the integration report.
  • Consistent dry-run overrides: uh mission dry-run mirrors uh mission run override precedence for all runtime adapters.
  • Live-run registry and uh ps: every runtime attempt claims a registry entry at the project root, and uh ps reports each run’s mission, team role, runtime and model, verdict (live, orphaned, stale, settled), turns, denials, heartbeat age, last tool and native pids. --json is machine-readable, --all includes runs settled within 24 hours, any orphaned run exits 3, and uh status prints a live-runs summary line.
  • uh kill stops runs from the project root by id or unique prefix, by mission, role or team, --all or --orphans. It cancels through the controller, waits a bounded --wait-ms, terminates only the recorded controller’s process tree when survivors remain, and reports cancelled_gracefully, force_killed, orphan_settled, still_alive or skipped_settled per target. An orphan settles in place through the guardian reconcile path with a controller_lost receipt, and --team stops workers before the team controller and marks team state cancelled so integration never lands.
  • Independent review packets pin the report to the request: the emitted JSON schema enumerates exactly the acceptance and check ids the request allows (an empty list allows nothing), the packet objective names the required ids per source and directs anything else to observations, verified observations are carried into the assessment without changing the recommendation, and the emitted review mission carries a guard policy limiting writes to the report directory with git, package installs and network denied.
  • The acceptance registry ports every capability to the Command Code fleet as 17 <id>-cmdc capability ports plus three G1-cmdc-* guard probes, with the model carried by the registry so no per-run override is needed, and a costless support wrapper strips runtime usage so the unknown-cost admission route is exercised without spend.
  • Session templates bundle how an attempt is executed: adapter, runtime overrides, limits, recovery, guard defaults and a budget tier. Mission values win over the template, write roots are never widened, a strict template refuses missions without narrow explicit write roots, with native sub-agents, or with network clients, and uh mission run and dry-run accept --template, blocking unknown or invalid templates before spawn.
  • Read-only MCP server over the run store: uh mcp serve answers newline-delimited JSON-RPC on stdio for the stateless 2026-07-28 revision and the 2025-11-25 handshake with three tools (uh_status, uh_runs, uh_run). Identifiers are validated before any path is built, every returned path is relative, and no prompt, runtime output or file content is returned.
  • Command Code runtime_config.role: orchestrator arms the guard with controller commands, so harness mission commands pass while agent CLIs, native sub-agent tools, forced runs and chained commands stay denied. Workers are unchanged, and fleet admission applies the role.
  • Team worker runs are indexed: the run index reads each worker’s canonical run through the team parent’s recorded state, attaches the team mission and role, and lets the team-recorded view win over the bare mission scan. uh observatory runs shows token totals and a cost_source column.
  • Run cost provenance with the operator price table: .harness/prices.yaml (uh.prices.v0) holds operator-maintained USD rates per model, matched case-insensitively. A run’s cost resolves to reported or estimated, or stays unknown with the reason naming the gap; Command Code streams report token counts but no price, incomplete token counters are never priced, and a missing or malformed table prices nothing. Team budget admission treats an estimated cost like a reported one.
  • Settlement conflict records: when runtime-result.yaml and the runtime-control receipt disagree on the terminal status, a settlement_conflict record is appended. A confirmed settlement outranks the result (status rewritten, exit codes annotated or forced); an unconfirmed receipt never rewrites a result.
  • Injectable supervision clock: runRuntimeProcess accepts a clock and poll scheduler, so supervision and recovery tests advance stall, startup and timeout budgets deterministically instead of waiting on wall time.
  • Capability inventory: docs/verification/capability-inventory.md maps every CLI capability to its implementation, tests and acceptance id, classifies each row, and lists the rows most dangerous to leave unproven.
  • uh mission check validates a mission packet and its runtime overrides without launching a runtime, verifying write roots against expected outputs and Change-only paths, checking read_first paths, and testing grounding claims against file contents.
  • uh mission put validates and installs mission packets into .harness/missions/<id>/mission.yaml atomically with audit event logging, refusing overwrite without --replace or while a run is live.
  • uh steer <run-id> <message> messages a live run: its owning controller stops the attempt with stop code steered and resumes the same native session with the message as the first instruction, without consuming restart budgets; --report asks for a status report first. Steering an orchestrator orphans the workers it launched (see docs/known-issues.md).
  • uh wait blocks without polling until matched runs settle or are orphaned by watching the live-run registry, accepting a run id, unique prefix, --mission, or --team.
  • uh note records manual interventions on the intervention ledger at .harness/ledger/interventions.ndjson with cause, qualifier, and source attribution.
  • uh ledger inspects and manages the append-only intervention ledger (list, summary, land, confirm, import), tracking corrections and their countermeasures across runs.
  • Intervention ledger (uh.intervention.v0): append-only NDJSON ledger recording corrections triggered by steers, kills, worker replacements, non-passing reviews, and supervisor stops, with automated secret redaction.
  • Live run digest (uh.run-digest.v0): supervision periodically projects active run progress to disk, enabling uh report to report live tool activity, denials, written files, loop signals, and assistant text without invoking a model.
  • Headless pseudoconsole execution on Windows: workers spawn attached to a headless pseudoconsole so inherited descendant processes do not create visible terminal windows.
  • Shadow loop watchdog, opt-in with runtime_config.loop_watchdog: shadow: supervision monitors live native events and computes deterministic loop signals, recording advisory decision receipts when repetition or alternating thresholds are crossed.
  • Acceptance runner invariants: registry entries can declare invariants (such as untouched protected paths, no worker commits, no package installs, and consistent guard logs) judged against recorded run evidence.
  • The hive: .harness/hive holds open items, controller-proven facts and agent claims for the project that owns the worker. uh land, uh queue and uh verify are the only writers of facts, each citing hashed controller evidence; facts, the intervention ledger and the land decision index are hash-chained, uh hive verify reports the first broken line, and land and queue refuse a broken chain. The guard stops any agent write of the hive and denies direct reads in favour of uh hive show, and only verified facts reach worker prompts, as an escaped data block. uh hive import seeds items from a markdown checklist.
  • uh queue run <queue.yaml> launches missions in file order once their after entries have passed, at most --max-orchestrators (default 2) at a time, and holds a launch while free memory cannot cover one more run above the admission reserve. Entries settle from their run records through the uh wait path (an orphaned run fails with reason orphaned), state is written atomically to .harness/queue/<queue-id>/state.json, a restarted queue resumes from it without relaunching, dependants of a failed entry are skipped, and each settle sends one notification. uh queue status <id> prints the state.
  • uh land --worker-branch <b>... --onto <branch> --message-file <f> lands verified worker branches from the target’s worktree. It refuses unless each branch has a passed uh verify result in its retained worktree and a collected review in the main checkout that names the branch’s mission, matches its request digest, captured the branch tip’s file hashes and contradicts no claim (--accept-review <reason> overrides only the review gate and writes a decision under .harness/land/). It cherry-picks without committing, runs the project’s checks, scans the staged diff and message for forbidden attribution patterns, commits with the repository’s configured identity, runs the build and fast-forwards each --fast-forward checkout; any failure after the gates restores the target’s recorded HEAD. A successful land then removes each landed worker’s worktree, and a team’s leader worktree once no worker worktree of that team remains, keeping the branches (--keep-worktrees skips this). Checks, patterns and build are configurable under land in .harness/project.yaml.
  • uh mission run --post-checks <file> runs operator checks the agent never sees after the runtime settles, in the run’s working root with UH_MISSION_ID, UH_RUN_ID, UH_RUN_DIR and UH_ROOT set. The file path and commands never reach the prompt, the runtime’s environment or argv, or any artifact under the project root; runtime-result.yaml records only names and outcomes, and a failed, timed-out or unrunnable check fails the run with exit code 1.
  • Notifications: settled runs, teams and alerts reach configured command or webhook sinks (presets for hermes send, apprise, ntfy and a Windows toast). Nothing is sent until a sink is configured; deliveries are asynchronous, at most once per event, run and sink, logged, and never delay settlement. uh notify detect, list and test.
  • uh acceptance rebind revalidates old evidence without rerunning a model. Registry entries declare the files each probe asserts, evidence records an input digest over those files plus runtime and model, and freshness compares digests instead of commits, naming the inputs that changed.
  • context.project_brief: false keeps the Project facts section out of a mission’s prompt; uh mission dry-run prints Project facts: off. .harness/project-brief.md is otherwise rendered once into every worker prompt, capped at 4,000 characters.
  • A team worker may name a session template, which supplies its limits, recovery, worker_rules and, when the worker omits one, its adapter. An unknown template fails the team before any worker starts.
  • oh-my-pi runtime_config.tools passes an allowlist to omp as --tools=<list>, so a read-only mission can withhold tools such as eval.
  • ACP runtime_config.mcp_servers passes stdio and http MCP servers to session/new, and runtime_config.env drops exact names or PREFIX* patterns and then sets values before spawn. MCP env and header values go only on the wire. Windows npm shims resolve the same way for check and run.
  • uh ps marks a run whose current tool call has produced no output for five minutes with STALLED tool=<name> <minutes>m.
  • uh report and the run digest count turns, tools, written files and tokens for Claude Code and oh-my-pi runs as for Command Code, and report context size at the first, fifth and last request, single-call turns, re-reads, tool output by kind, and model versus tool time.
  • docs/known-issues.md lists every open defect, gap and unproven claim, each marked confirmed or reported; the README gains an operating-runs command table, and the capability inventory gains a section for capabilities added in this development line.
  • Team workers now receive per-worker objectives, runtime budgets, declared outputs, and seeds with canonical contract and settlement records.
  • Deadline grace recovery now preserves an explicitly incomplete deliverable and missing-work handoff before settling the run.
  • Native runtime supervision now reports denial budgets and repeated commands, stops protected-path mutations, and resumes recoverable denials with source stop facts.
  • Acceptance missions now record attested real-runtime evidence, freshness-aware status, and generated capability reports.
  • Acceptance freshness requires evidence from the current harness commit.
  • Acceptance runtime overrides now select the requested adapter explicitly and warn when they differ from registry defaults.
  • Acceptance campaigns inherit caller environment variables and derive hook distribution paths from the known source root.
  • Acceptance evidence records fact sources for merged attempts, with deterministic sorted-run selection and fixture seams.
  • Attempted fixture-only missions now render their actual failure or pass outcome instead of hiding it as fixture-only.
  • Guardian acceptance requires settlement confirmation and a terminal guardian receipt.
  • Acceptance registry entries carry stable capability identifiers independently of probe names.
  • Deadline acceptance exercises an unscripted task rather than treating a turn-limit fixture as deadline proof.
  • Team budget acceptance remains unproven where canonical state does not expose the required budget or reservation fact.
  • Acceptance report generation is checked for drift against the registry and available evidence.
  • Resource-wave admission now maps mapResourceWaves with memory-headroom checks and cost reservations, preventing unsupported workers from entering a wave.
  • Team workers now carry distinct mission contracts through team.workers[].mission_id.
  • Native Claude Code adapter with structured event capture, tool-guard hooks, route checks, and saved-session recovery. End-to-end coordinator delegation is not yet validated.
  • TypeSafe System One integration in verification and independent-review collection, with typed verdict parsing, compact evidence summaries, and persisted decision receipts. Semantic routing, scope-change, retry policy, and confidence thresholds remain unimplemented.
  • Optional live usage in runtime-control receipts and active non-team Observatory projections. This does not enforce token or context budgets.
  • Releases publish to the npm dist-tag their version implies: a prerelease such as 0.11.0-rc.1 goes to next, a release to latest, both in the publish workflow and in bun run publish:dry-run (scripts/npm-dist-tag.mjs). A GitHub release whose pre-release flag disagrees with the package version publishes nothing, neither to npm nor as a Hermes plugin tarball. A test keeps the package, plugin, dashboard manifest, ACP client and OpenTelemetry service versions equal. See docs/runbooks/publishing.md.
  • The capability section of docs/architecture/runtime-adapter-contract.md says --force prints a [WARN] line (a bypass is never silent), and a test pins that --strict is registered on dry-run, run and run-all. #221.
  • Exit-safe telemetry is covered by a test that a command ending in process.exit(1) hands the beacon status: failed with exit code 1, once. #211.
  • The post-checks file and the worker-memory reservation file are defined in src/schema like the other persisted contracts. A reservation file now carries schema_version: uh.reservation.v0 (files written before still parse), and the post-checks file may be the original bare list or a versioned { schema_version: uh.post-checks.v0, checks } document. #259.
  • The steer record and the resume link, the two versioned contracts that were defined in src/harness, now live in src/schema (exported from its index, timestamps checked as datetimes, both known to uh validate), and a test fails when a versioned schema literal is defined outside src/schema. #259.
  • A team worker’s guard is the team mission’s, narrowed by its packet, its session template and its own guard block, and is written into the worker’s packet. Before, a worker’s template guard was dropped and its own guard block never applied; a worker adopting a containment: strict template was not held to strict containment. A layer can only narrow (restrictions on, permissions off, write and read roots inside the parent’s); a widening is refused, naming the worker. U-404.
  • GitNexus is optional for contributors and agents. Layer 07 of the 0.11.0 stack (#246) changed AGENTS.md, which CLAUDE.md imports: the mandatory GitNexus rules and the ## Deviations section were removed, and agents fall back to grep when GitNexus is not available. This is a project-owner policy decision, recorded here as #251 asks; no skill or guide still calls GitNexus mandatory. #264.
  • uh land checks every independent review bound to the branch tip, not only the first clean one: a clean review no longer outvotes another review of the same tip that contradicts it or recommends against landing. A review of an older tip is still set aside. U-409.
  • Hardened input handling in the tool guard, the notification config and the harness’s own git calls. The guard judges each command a shell line runs, allows only read-only git forms, and recognises more write, delete, kill and install forms. A notification sink in the project file that starts a command or reads an environment variable into a header is used only with UH_NOTIFICATIONS_TRUST_PROJECT=1; sinks in the user file are unchanged (see docs/handbook/notifications.md). Commits, merges and cherry-picks the harness makes run without configured git hooks. Hive facts carry a controller mac and only facts with a valid one reach worker prompts, so facts recorded before this release are kept but no longer injected; evidence refs are paths inside the project. #289.
  • Agent-client denial no longer depends on deny_network_clients. A mission that sets runtime_requirements.needs_network previously lost agent-client denial along with network denial. Workers may not spawn agents; an explicit guard.agent_clients: [] is the only opt-out.
  • Default agent_clients adds claude, opencode, qwen, goose and cursor-agent.
  • uh mission run refuses to run in the project root when no sandbox is bound to the mission, unless --no-sandbox is passed. uh mission dry-run prints the routing.
  • Team and sandbox worktrees are created with git worktree add --lock --reason and unlocked before removal. UH no longer runs a global git worktree prune.
  • Provider and model identifiers are compared case-insensitively for route attestation and fleet admission, with an optional provider prefix reconciled. There is no alias table and no partial matching.
  • System One judgments ask one bounded yes/no question per criterion that has no deterministic result plus a fixed battery about the report itself, compose the three-verdict outcome in code with named thresholds, and record the answering model, latency and usage in the receipt. Requests time out and retry 429 and 529 with backoff, and the requested model can be pinned.
  • Verification hands System One only facts the harness established: criteria with a check command carry their deterministic result and are never sent, the others carry their description, tamper comes from the policy stop code, and deterministic failures still dominate.
  • Dispatch prompts render every list section explicitly: an empty Read First, Expected Artifacts, Verification Checks, Constraints or Acceptance Criteria section says none, add nothing instead of being omitted.
  • uh mission run-team worktrees record their base commit in git config and team state, hide harness-owned files from worker git status, accept --base-ref to set the base ref, and refuse relaunching when worktrees remain unless --replace is provided to archive previous branches.
  • Worker prompts reach runtimes via standard input or file instead of argv payloads, allowing prompts exceeding Windows command-line limits to launch under the guardian Job Object and memory caps.
  • Guard arming verifies hook execution before allowing unguarded tool use, arming the guard once matching evidence is recorded and stopping with policy if tools run without hook coverage.
  • uh report renders efficiently from the atomically updated uh.run-digest.v0 projection instead of repeatedly rescanning full event logs, reading only the tail of events.ndjson unless --full is specified.
  • Orchestrator missions can run observation and run-control commands (ps, report, steer, resume, kill, experiment) as controller commands while agent CLIs remain denied.
  • Team missions support an explicit unknown_cost: "admit" | "block" resource policy, allowing completed workers with unpriced runtimes to proceed to later waves without blocking when admit is set.
  • Session templates drive team worker dispatch, adopting worker overrides, limits, recovery rules, and budget tiers across wave executions.
  • Team workers commit with the repository’s configured user.name and user.email, falling back to uh team worker only when none is set.
  • Teams admit another worker only when measured free memory, minus reservations for workers still starting, covers the worker’s need; a reservation ends when the worker reports running or after 60 seconds.
  • Orchestrator-role missions run in the project root without --no-sandbox; their guard confines writes to their declared write roots, and an orchestrator without write roots is still refused.
  • uh mission run-team --replace no longer force-removes worktrees it cannot prove abandoned (#253). It treated only a live run as a blocker and swallowed every read error, so a stale or unknown run, an unreadable registry, or an empty process table (which makes every controller look dead) let it delete worktrees and any uncommitted work in them. It now blocks on live, stale and unknown runs, fails closed when the registry or the process table cannot be read, and refuses to archive a worktree with uncommitted changes outside the harness’s own folders.
  • A Command Code orchestrator is now refused when its guard’s write roots cover the live project root (#254). uh mission run lets an orchestrator run in the project root without a sandbox on the promise that its adapter refuses repository-wide write roots, but only the Claude Code adapter did; Command Code accepted an empty guard (write root .) and ran with the whole repository writable. Both adapters now share one check (src/harness/orchestrator-write-roots.ts): empty, ., absolute and .. roots are refused at planning.
  • uh queue no longer launches every mission with --no-sandbox (#255). The flag skipped sandbox routing and the refusal of a worker mission with no bound sandbox, so queued missions ran in the operator’s live checkout even when a sandbox was bound. The queue now routes like uh mission run; an entry that needs the project root says sandbox: false.
  • Acceptance evidence whose inputs match no tracked file is stale (it could never go stale before), with the unmatched patterns in the reason; uh acceptance status and rebind read the inputs at a commit with one git cat-file --batch process instead of one git show per file. #258.
  • Independent review finds a sandbox worker’s changes from the commit the sandbox forked from, which the sandbox now records, and includes staged, unstaged and new files; before, the fork point was never set and uncommitted work was ignored. #258.
  • Sandbox, team and land teardown no longer unlink symbolic links the project tracks (git mode 120000); a clean worktree stays clean and a non-forced discard works. Links git does not track are still removed first. #258.
  • The loop watchdog reads each runtime event once instead of re-reading the whole list on every line, and queued observations are coalesced, so a long run no longer costs time quadratic in its length. #258.
  • The controller-command exemption (the orchestrator role running uh) no longer applies to a command with an unquoted $, parenthesis or brace: uh mission run m1 $(git push) ran the substitution unexamined, and PowerShell evaluates (...) and {...} outside quotes. Quoted text is unaffected. #260.
  • A team worker’s worktree hides from git status only the files the harness itself rewrites there (the Command Code hook config and ignore file, the harness ignore file, the seeded mission packet). Every other tracked file under a protected root stays visible, so a worker’s edit to one shows up in status and in the acceptance diffs. Before, all tracked protected files were marked skip-worktree. #260.
  • A team worker’s commit holds exactly the paths inside its write roots: the index is cleared before staging, so a path staged outside the roots no longer rides along (#259); changed paths are read with status --porcelain=v1 -z, so non-ASCII, spaced and quoted names are staged and committed as they are (#259); a declared output that is a whole ignored directory commits its regular files only, never links, node_modules, .env files or protected paths (#260).
  • uh mission put runs its refusals (an existing packet without --replace, a live run of the mission) before writing anything, so a refused put leaves every installed worker packet, even its modification time, untouched. #260.
  • Operator post-checks no longer grade a cancelled run (they used to run and rewrite cancelled to failed); Ctrl-C or SIGTERM while a check runs kills that check’s whole process tree instead of leaving it running after the CLI exits; a check’s output is capped at 1 MiB per stream with a marker; and UH warns when the check logs would be written inside the project. #262.
  • ACP mcp_servers headers and env, and env.set, can name a secret with ${NAME} instead of holding it: UH replaces the reference from the environment when the run starts, and a variable that is not set stops the run with a message naming it. The runbook no longer shows an inline Bearer token. #262.
  • A Claude Code run’s turn count is the runtime’s own num_turns once its final record arrives, not the number of distinct assistant message ids seen along the way, which could overshoot it. #266.
  • uh ps no longer reads and parses a run’s whole events.ndjson to count turns for a runtime whose turns cannot be counted from events, and caches the count of one that can by the file’s size and modification time, so a refresh over many runs does not re-read them. #266.
  • A Claude Code sub-agent’s messages no longer count as the run’s turns (U-064, GH #266). Claude Code puts a sub-agent’s messages in the same stream as its own, marked with the parent_tool_use_id of the call that started it. Supervision, uh ps and the run digest counted them as turns, so a run that used sub-agents hit limits.max_turns early (supervision stops it as turn_limit) and showed an inflated turns. All three counters now skip those messages. The limits.max_turns check on the Claude Code branch that GH #266 found missing was added earlier (see the turn-cap entry).
  • Claude Code’s limits.max_turns was never enforced by UH (U-044, U-114): the supervisor counted assistant messages as turns but never compared the count with the cap, so a run past the cap kept going and could finish with a clean result and pass. It now stops with turn_limit like the other turn-counting runtimes. docs/runtime-targets.md now says which runtimes limits.max_turns can be enforced for (Command Code, oh-my-pi, Claude Code) and which it cannot (Codex, Hermes, Pi: no turn events), with how each runtime reports its own cap. Tests cover a cap hit while the runtime still sends its normal finish signal for oh-my-pi, Command Code, Claude Code, Hermes and ACP; oh-my-pi’s cap already worked.
  • uh steer and uh resume look for .harness/adapters only from the run’s scope up to its own project root, so a project without adapters no longer loads the manifests of a directory above it. #259.
  • uh mission check no longer reads outside the project: a grounding claim’s path must be relative and stay inside (refused by the packet schema, and again at read time through links), and a team worker’s mission_id must be a plain id. #259.
  • uh steer re-reads the controller’s record after the request file is gone, so a not_applied verdict written a moment after the controller takes the request is reported as not applied, not as success. #259.
  • uh steer no longer reports success for a steer nothing has taken. It wrote the request, signalled the stop, waited 1.5 s for a verdict, and reported Steered … when the controller neither refused nor answered. That case now reports status: pending (Steer requested for <run>, not yet taken) and still records the intervention; a request the controller took, or a not_applied record, are reported as before. #259.
  • Toast and notification hardening: the Windows toast app id doubles every typographic single quote (U+2018 to U+201B) as well as the ASCII one, so none can end the PowerShell literal; app_id is refused on any preset but windows-toast; uh notify detect runs reg.exe from the Windows folder instead of a bare reg, which Windows looks up in the current directory first; and uh notify detect, list and test with --root now have CLI tests. #267.
  • The Hermes dashboard plugin stays on the public CLI: cancelling a run goes through uh kill <run> --json (the CLI settles the run’s records; the plugin terminates the child itself only when the CLI cannot find or stop it) and run retention goes through uh mission prune-runs. The plugin no longer writes run events or rewrites run history, and its Python copy of the pruner is gone. #267.
  • docs/architecture/progressive-decisions.md no longer says the CLI exposes uh mission decision scope-change: there is no such command, only a receipt schema kind; the section now says it is not implemented as a command, and a test fails if a doc claims that command while the CLI lacks it. #267.
  • Cancelling uh mission run with SIGINT or SIGTERM no longer exits before the run has written its own terminal state: the exit waits, for at most five seconds, for the run to settle runtime-control.json and the live-run registry, which the plugin’s cancel reads. #267.
  • The hive facts, the intervention ledger and the land decision index no longer fork their hash chain when several writers append at once (#257). Each append read the last hash and then wrote with nothing between the two, so parallel queue runs settling or team workers recording could write two entries with the same prev_hash; the integrity check then failed, and uh land and uh queue refuse to run on a broken chain. The read and the append are now one exclusive step behind a <file>.lock (O_EXCL, the same on Windows and POSIX; a lock older than 30 s is taken over). For chains the old bug already forked: uh hive verify --repair re-links them (explicit, never automatic; it keeps the original file, writes a report of every entry it re-linked with old and new hashes, and refuses a chain with any other break), and uh land and uh queue treat only that fork pattern (two entries linking to the same parent) as a warning that names the repair command; every other break is still a hard failure. #257 also asks to “consider downgrading a broken ledger chain to a warning for land and queue”; only the fork is downgraded, by decision, not any broken chain.
  • uh ledger confirm is no longer just advisory. It refuses to run in a guarded worker, the orchestrator included, and in any process without a terminal, and the tool guard denies it to a worker’s shell, so an agent cannot record verified_by: owner. #261.
  • A run that settles normally now announces itself, and announcements are no longer lost on exit (U-060, U-061, GH #261). notifyRunSettled was called only by a reader that found a settlement, by uh kill and by controller-loss reconciliation, so an ordinary uh mission run never sent a notification. Where it was called, delivery was fire-and-forget and the CLI called process.exit right after, so the delivery was dropped: uh ps, uh kill and run-team lost theirs. uh mission run now sends run.settled when the run settles, and mission run, run-team, kill, ps and wait let the deliveries they started finish before exiting, for at most 5 seconds (a hung sink cannot hang the command). See docs/handbook/notifications.md.
  • Arming a Pi or oh-my-pi guard no longer races another worker’s: the extension probe points two process-wide environment variables at its own policy and log, so concurrent team workers could judge one worker’s probe against another’s policy. Extension probes now run one at a time. #261.
  • A team worker’s supervision stop is written to the project’s intervention ledger, not to a ledger inside the worker’s own nested .harness: the ledger root is the outermost .harness that holds a project, falling back to the nearest. #261.
  • A queue entry whose child exits 0 before its run becomes discoverable no longer spins until the wait timeout: the settle loop paused only when the child was still running, so an exited child made it re-poll in a tight loop for as long as the wait lasts. It now pauses every turn and, after a 1.5 s grace, fails the entry as launch-failed. #263.
  • The no_worker_commits acceptance check no longer trusts a commit just because its message is the harness’s: the team state now records the commit the harness itself made for each worker (and for a salvage), and only that commit is allowed. A worker that wrote team(<id>): worker run as its own commit message is flagged. Runs recorded before this keep the old exact-subject rule. #263.
  • Worker-memory reservations of a team are released one per reporting worker, not all at the first heartbeat: a team’s workers share one controller pid, and the first worker to report used to release every reservation of that pid, so memory the other workers still needed was admitted twice. #263.
  • A failed uh land puts back every checkout it had already fast-forwarded, not only the target: before, an earlier checkout kept the commit the landing discarded. A checkout the owner changed in the meantime is left as it is (reset --keep). #263.
  • uh land binds a review to the branch more strictly. The review’s captured files are compared as the bytes git stores (or as git writes them into a checkout, for line-ending and other filters), not as decoded text, so binary and CRLF files bind; a review that captured no output or changed file is refused instead of binding to anything; the review records the commit its source workspace was at (source_head) and the branch must contain it; a worker branch’s mission comes from the controller’s team state, not from files the worker can write; and --accept-review records no review ids when none of the collected reviews is about the branch. #264.
  • The land decision index re-hashes the receipts it lists: uh hive verify (and the land gate) report a receipt that was edited or deleted after it was recorded, instead of passing because only the index’s own chain was checked. #265.
  • A worker that runs from a project stored under a .harness folder, or in a path spelled with another case on a case-sensitive system, is no longer attributed to the wrong owner: the project owning a worker is resolved only from the worker layouts UH creates (.harness/missions/<id>/team/..., .harness/sandboxes/<id>/...), and the folder name is compared without regard to case only on Windows. #265.
  • A long project brief no longer cuts the hive facts block out of a worker’s prompt: the brief and the verified hive facts are budgeted apart, the brief gives way, and the data block keeps its header, its facts and its closing fence. #265.
  • A queue entry’s hive fact cites a snapshot written once for that entry (.harness/queue/<queue>/evidence/<entry>-<run>.json) instead of the queue’s state.json, which the next entry rewrites. Before, every queue fact but the last stopped verifying and was never injected into a worker’s prompt. #265.
  • The loop watchdog is off unless a mission sets runtime_config.loop_watchdog: shadow. It used to default to shadow, so every scoped run with TYPESAFE_API_KEY set could send loop state to the paid TypeSafe API without asking. #252.
  • uh land now requires a collected review’s source_root to resolve to the retained worker’s worktree and its recommendation to be pass. Workers sharing a team mission can no longer reuse one another’s review, even when their changed file bytes match; a review with only supported claims but a non-passing recommendation no longer clears the gate.
  • uh land refuses unless the target worktree has --onto checked out. On another branch or a detached HEAD it used to commit there, report landed onto --onto, and remove the worker worktrees. #256.
  • uh mission review-collect discards the review’s sandbox after a successful collection, keeping the reviewer’s report beside the assessment as review-report.json. Every review used to leave its sandbox worktree behind. --keep-workspace keeps it.
  • Removing a team or sandbox worktree no longer deletes files outside it. On Windows, git worktree remove --force recursed into a directory junction inside the worktree and deleted the junction’s target, so a node_modules junction to the main checkout emptied the main checkout’s node_modules. UH now removes every link and junction in the worktree, without following it, before asking git to remove the worktree, and leaves a team worktree in place if a link cannot be removed.
  • Tool Guard treated every /-prefixed argument as a cmd.exe switch. On Linux and macOS, cp x /etc/y and mv x ~/.bashrc were allowed because the destination was skipped, and rm -rf of an absolute path inside the worker root was denied as an untargeted delete_outside before the hive and tamper checks. /x tokens are now switches only for cmd.exe verbs.
  • spec-stale drift treats specs/ as the cross-cutting spec root (specs moved out of docs/specs/), so implementation changes with a matching specs/ update are no longer flagged.
  • Tool Guard judges agent clients by executable position instead of a whole-command text match. codex.cmd, omp.exe, path-qualified binaries, the PowerShell call operator, env/xargs/pnpm dlx launchers, bash -c bodies and command substitutions are denied; grep -r omp src and cat docs/codex.md are no longer false denials that consumed a worker’s denial budget.
  • Workers can no longer start paid runtimes through UH itself (uh mission run, run-all, run-team, uh acceptance run, or node dist/cli.js ...). Read-only UH commands stay available, and the Claude Code orchestrator role keeps its controller-command allowance.
  • A runtime that resolves helper or sub-agent models from operator-global settings could spend on a route other than the assigned one, because only the top-level session was pinned and attested. Roles are now pinned per run and delegated routes are attested.
  • Tool Guard resolved every relative write target against the worker root, so a command that changed directory first (cd <elsewhere> && Set-Content <relative path>) wrote outside the sandbox. Directory changes are tracked through a command, including nested shell bodies and an explicit cwd on the tool input; an unresolvable directory change denies every later write in that command.
  • A concurrent reader could fail a run: replacing runtime-control.json by rename fails on Windows while any process has the file open, and the failed heartbeat stopped the run with controller_error. Renames retry with bounded backoff, a periodic heartbeat that cannot be persisted no longer stops the run, and terminal writes stay strict.
  • Team worker commits swept in files the harness writes into the worker root (the Command Code hook configuration, the worktree-local ignore file, a tracked audit log). Commits now exclude the protected roots by pathspec, and a worker that touched only harness state produces no commit.
  • The Command Code health probe ran the CLI without --no-auto-update, so an adapter check could start a self-update that replaced the runtime while another run was launching it.
  • The acceptance report no longer links evidence that does not exist, and present evidence links resolve from docs/acceptance/.
  • Mission turn limits reach the native runtime: Command Code and Claude Code receive --max-turns derived from limits.max_turns (Command Code’s silent native default of 100 turns is recorded on the plan), and a native terminal cap maps to a UH stop code: max_turns settles as turn_limit, native time caps as timeout, and any other failing native stop as runtime_error with the native reason copied into stop_reason.
  • Command Code shell results carry no error field, so supervision reads the leading Exit code: <n> line of the result text: a non-zero code is a failure, a later mention of Exit code in stdout is not, and unknown event shapes are not failures. Repeated failing shell commands now reach the repeated-failure stop.
  • uh mission cancel resolves the run through the same discovery uh ps uses, so a team worker can be cancelled from the project root even though its runtime control file lives deeper in the harness tree.
  • Diff capture retries each git command once after a settle delay, so a transient spawn failure cannot fail an otherwise settled run, and a capture failure after settlement is recorded as diff_capture bookkeeping instead of changing status or exit code.
  • Sandboxing works without a tracked sandboxes index and across volumes: a missing index means an empty one created on demand (the audit log and the index are no longer tracked), an invalid index still fails loudly, and the directory backend retries once with --no-hardlinks when git cannot hard-link objects across the volume holding the object store.
  • Guard hooks run from an immutable per-content snapshot in a per-user cache instead of the mutable build directory, so a rebuild during a run cannot replace the guard under a live worker. An existing snapshot is verified before reuse, and a mismatch fails closed.
  • The acceptance runner installs the support shim its registry entries declare: the copied support directory is prepended to the child PATH for that run only, and shim_on_path is recorded in the evidence.
  • Acceptance guard facts are read from the run’s tool-guard log on disk and count denials only, with allow lines recorded separately, so a guard probe’s recorded denial budget matches what actually fired.
  • The acceptance snapshot resolves node_modules by walking up from the harness root (a worktree or leader tree without its own install resolves the parent checkout), refuses loudly with exit 2 when none exists, recreates a dangling junction, and initializes Windows workspaces with core.longpaths true so deep fixture paths can be committed.
  • Every acceptance evidence record stores the mission CLI outcome (exit_code with stdout and stderr tails); a run that produced no observed status keeps that fact visible instead of fabricating failed, and its FAIL line carries the first stderr line.
  • The acceptance costless wrapper resolves a .cmd shim to the Node entry point it wraps and spawns that directly, falling back to the Windows shell only for shims it cannot parse, so the unknown-cost route attests on Windows.
  • The committed acceptance report drift check renders against an empty evidence root, so local campaign records never fail the check; uh acceptance report keeps rendering local evidence for humans.
  • Guard hooks derive applied policies from the complete artifact and schema, preventing extra artifact metadata from breaking hook execution or dropping policy fields.
  • Tool Guard resolves shell environment variable references in write and deletion targets, stopping attempts to mutate UH_TOOL_GUARD_POLICY or UH_TOOL_GUARD_LOG as guard_tamper, and categorizes xd:// virtual device URIs under the virtual_device class.
  • Team worker and salvage commits obey declared write roots and outputs, keeping files outside write roots unstaged and recording them in worker state and integration reports.
  • Team workers stage declared outputs even when located under gitignored directories.
  • Sandboxes index lock release verifies owner pid and nonce, preventing concurrent sandbox creation from clobbering registrations.
  • Steer requests are tracked and handled by the controlling process that owns the run, avoiding dropped steer messages or unrecorded preparation failures.
  • Native tool refusals without hook invocation are tracked as native refusals rather than treating the guard as disarmed.
  • Supervisor matches tool-guard log evidence to runtime events by call id before falling back to call count.
  • Review capture retrieves a worker’s final message from team run records and captures all modified files.
  • Build compilation outputs to a staging directory before atomically swapping into dist/, avoiding inconsistent builds on compilation errors.
  • Command Code 1.62.1 exits with an uncaught write EOF after a single large tool result (upstream CommandCodeAI/command-code#859). Its guard hook now denies a read_file with no limit, or a limit above 600 lines, on any file larger than 40,000 bytes, with a reason telling the model to read in windows; the denial is logged with class read_window.
  • ACP runs routed into a sandbox persisted no records; they now write to the project’s mission directory while the agent works and diffs are captured in the sandbox.
  • An acceptance entry whose mission left no run record passed when nothing mismatched; it now fails with reason no_verdict, a setup or run error records runner_error evidence and the campaign continues, every campaign ends with a SUMMARY, and uh acceptance run exits 1 when any capability failed.
  • System One never returns a verdict over zero judged criteria, computes confidence over criterion answers only, and receives failed or blocked required checks as deterministic failures.
  • review-collect blocks a pass only on required evidence (a contradicted claim, a failed required check or acceptance entry, an error finding) and records an inconsistent pass as needs-attention instead of throwing.
  • uh mission check checks an independent review packet from its bound review sandbox, and names the sandbox command when none exists, instead of failing.
  • Team worktrees run git with core.longpaths=true, refuse with a clear message when the longest tracked path cannot fit under Windows’ 260-character limit, and keep git’s stderr in setup errors.
  • The build resolves tsc from the project instead of npx, restores the previous build when the swap fails, and restores a lone dist.old left by an interrupted build.
  • The experience store groups each model under one canonical key while keeping the reported model and provider on each record.
  • uh land read collected reviews from the checkout git’s common directory belongs to, which is a different checkout when the project is itself a linked worktree, so every land in that layout was refused; it now reads them from the project that owns the worker worktrees.
  • uh ps showed turns=0 for Claude Code and ACP runs. It now takes the larger of the control file’s and the run digest’s count, and when neither has one counts turns from the run’s events: one per distinct assistant message id for Claude Code, one per stretch of agent activity for ACP. Supervision counts Claude Code turns the same way, so limits.max_turns applies to Claude Code runs.
  • Windows toasts were raised under an unregistered app id, which Windows drops without an error. The windows-toast preset now uses Windows PowerShell’s registered AppUserModelID by default and takes app_id for another registered one; uh notify test reports a toast as a handoff rather than a delivery and says what every other success proved (exit status or HTTP status); uh notify detect reports toasts unavailable when they are turned off in Windows settings; every uh notify subcommand takes --root, and the handbook shows the different top-level shapes of the project and user notification files.
  • The no_worker_commits acceptance invariant recognised the harness’s commit only by the placeholder email, so once workers committed under the repository’s identity every correct run would have been flagged. It now accepts one commit per worker with the exact subject the harness writes, plus any placeholder-identity commit.
  • Command Code print-mode runs now select non-interactive permissions through the harness guard (--yolo) and refuse ambiguous launches before spawn.
  • Guarded Command Code runs now fail closed when hook invocation evidence is absent, preventing --yolo workers from running unguarded.
  • Team integration-report paths in canonical team state now use relative forward-slash artifact paths, including cross-volume targets.
  • Independent reviewers write reports to permitted workspace outputs; protected request and assessment artifacts remain controller-owned.
  • Worker output declarations reject protected runtime paths before execution.
  • Runtime callback failures retain diagnostic details instead of reporting only a generic controller error.
  • Interrupted Claude streams retain known usage counters without treating an unfinished message as a complete total.
  • Verification preserves deterministic failures when a semantic evaluator recommends a pass.
  • Command Code planning now refuses print-mode launches without a guard or explicit permission mode for every configured cli_command, including custom executables.
  • Command Code shell_command queue events now stop protected-root shell mutations before execution.
  • Guard supervision now distinguishes a hook that ran but could not log from a hook that did not run.
  • Command Code guard hooks now record every invocation and fail closed when the evidence log cannot be written.
  • Repeated guarded Command Code setup now replaces the managed hook without accumulating duplicate PreToolUse entries.
  • Git mutation detection now keys on the Git subcommand, avoiding false positives from read-only text such as git log --grep=commit.
  • Native OMP progress is persisted before child exit, including UTF-8 and trailing-line handling. Nested assistant content and terminal errors are interpreted without treating arbitrary response IDs as authentication failures.
  • Windows runtime guardians are compiled once into a per-user, source-hash cache, use extended-length paths for deep run directories, and normalize forward-slash variants before prefix detection, with atomic publication and visible per-run fallback when the cache is not writable.
  • Sandboxed OMP execution publishes run facts to the host’s canonical mission artifacts without promoting product changes. Cancellation settles the selected run and matching mission mirrors without overwriting newer run facts. Initial and streaming event-write failures settle writable terminal artifacts; the existing Observatory prefers an active run over a stale terminal result and rejects unsafe route metadata.
  • OMP token, cache, and reported cost totals aggregate completed assistant turns without counting repeated update/end envelopes, while retaining distinct explicit message identities. Incomplete measurements remain unknown rather than appearing as complete totals.
  • Product diff capture includes staged and unstaged text and applicable binary patches, leaves the Git index unchanged, and excludes generated harness bookkeeping while retaining harness configuration changes.
  • Team runs publish parent and isolated worker facts to durable host artifact scopes. The existing Observatory shows active/completed teams and reported worker usage after normal worktree cleanup; the leader’s verification artifact is retained with the parent run.
  • Native OMP CLI interruption handles Ctrl-C (SIGINT) as well as SIGTERM, stops the owned process tree, and persists terminal cancellation facts before exit.
  • Verification timeouts terminate the owned process tree on Windows rather than leaving child commands behind. OMP and verification subprocesses no longer request separate Windows console windows.
  • Native OMP and Command Code process capture has a configurable combined-output byte limit (64 MiB by default). Exceeding it settles the owned tree as a failed run and retains only the admitted transcript prefix.
  • Recovery accounting includes failed source attempts, preserves mixed-route costs, and leaves incomplete totals unknown. Team accounting and live controls use each worker’s canonical artifact root.
  • Anthropic, OpenRouter, and Hermes-proxy persist reported usage in canonical results. Runtime cost estimates carry provenance and are not presented as provider billing receipts.
  • Mission verification now enforces declared output files, JSON syntax, and optional final-line completion markers. Workspace-escaping paths and missing evidence fail through the existing verification result instead of requiring a separate launcher checker.
  • Command Code supports optional explicit USD pricing with cache-overlap semantics. Complete measured counters and an exact observed-model match are required; canonical receipts retain the configured rates and label the amount as an estimate.
  • Mixed native OMP routes no longer inherit the last provider/model as their sole attribution. Invalid counters and numeric-overflow totals remain unknown while independently complete usage and cost measurements are retained.
  • Finalized native lifecycle events now age under the existing Observatory freshness policy instead of remaining fresh indefinitely; confirmed terminal outcomes stay terminal.
  • Native OMP and Command Code runs fail on mismatched or unattested assigned routes, preserve the requested route in control receipts, and refuse saved-run recovery from route-policy stops. OMP honors adapter default model/provider settings; Command Code no longer receives unconditional workspace auto-trust. Unsupported inner worktree_mode settings fail before launch.
  • Windows canonical artifact transactions now release kernel-owned locks on controller death. Concurrent CLI updates remain serialized; legacy filesystem-lock evidence is retained rather than guessed stale or deleted.
  • Hermes CLI execution and OpenSandbox command templates reuse UH’s owned process runner. Windows Node entrypoints are resolved directly, POSIX templates use a native POSIX shell, and timeout settlement completes before worktree cleanup.
  • Artifact publication rejects ancestor symlinks/junctions as well as linked target files, preventing a replaced run directory from redirecting writes outside the mission.
  • CLI integration tests launch through Node/tsx instead of Windows-incompatible extensionless shell shims. Directory-link fixtures work without granting symbolic-link privileges.
  • Independent review is emitted and collected through normal UH missions: full required-input snapshots, native fresh-session/model assignment guards, shared output validation, and hash-bound advisory assessments. Missing evidence or changed contracts cannot pass; human acceptance remains separate.
  • Team runs admit workers in resource-bounded waves and block remaining admission when resources or completed cost accounting cannot support another worker.

Milestone “Memory & adapter matrix” (Linear UH-131 / UH-136 / UH-137; GitHub PRs #204–#206 / #214 / #215 / #216). Bundles everything merged to dev since v0.8.0: a native pay-per-token Anthropic adapter (experimental), harness-side Honcho memory operations with a per-mission opt-out, the team-run dogfood verdict/artifact fixes, and the Phase-0 DX hardening (real uh --version, opt-in telemetry primitive, adoption docs, curated npm allowlist, CI plugin gates).

  • Native Anthropic adapter (UH-136, #214) — status: experimental. The official, ToS-clean pay-per-token path through the Anthropic Messages API, complementing the OAuth-backed hermes-proxy and the OMP stealth surface. API key via ANTHROPIC_API_KEY (env-only, never the manifest); a missing key degrades uh adapter check anthropic gracefully (the CI-skip signal) and makes mission run fail fast via a plan error. Blocked-output classification on auth / rate-limit / model-not-found / network failures. Registered as a first-class routable adapter (anthropic) with an optional opt-in live-smoke CI job.
  • Honcho memory operations (UH-137, #215) — honcho_search / honcho_remember exposed as harness-side memory operations, plus a per-mission runtime_config.honcho_memory opt-out honored by every Honcho-aware adapter (oh-my-pi / codex / pi / hermes). Builds on the v0.6.0 enrichment + recordMissionExchange wiring; memory stays off by default in tests and is a silent no-op when Honcho is unconfigured. Tunable via HONCHO_SEARCH_LIMIT (default 8) and HONCHO_TOOL_PREVIEW_LENGTH (default 500).
  • DX hardening (Phase 0) (UH-131, #204 / #205 / #206) — uh --version now reads the real version from package.json; an opt-in PostHog telemetry primitive (UH_TELEMETRY, unwired pending the UH-135 follow-up); adoption docs (docs/{quickstart,configuration,runtime-targets,telemetry,troubleshooting,plugin-development}.md); a curated npm files: allowlist; and CI plugin gates.
  • UH-129 team integration_report_path default (#216) — now defaults under .harness/missions/<id>/team/ instead of the mission root, keeping team artifacts scoped per mission.
  • Pinned the Hermes plugin test dependencies for deterministic CI (#216).
  • UH-127 verdict reclassification (#216) — team runs that partially succeed are now classified passed_partial instead of a false BLOCKED.
  • UH-128 per-worker artifact bleed (#216) — fixed cross-worker artifact contamination in team missions; each worker’s artifacts stay isolated to its own worktree.
  • UH-130 constraints-advisory warning (#216) — surfaces an advisory warning when mission constraints are present but not enforced.
  • The native Anthropic adapter ships experimental: registered and routable, but not yet graduated to active. Graduation follows a live-smoke promotion record like the other adapters.
  • The telemetry primitive is unwired — no events are emitted yet. It exists as the opt-in seam; instrumentation lands in the UH-135 follow-up. UH still ships no telemetry by default.
  • Deferred to v0.10.0+ (0.10.0 was later skipped; both shipped with 0.11.0): capability-declaration enforcement (manifest/mission capabilities: binding, warn + --strict); the telemetry instrumentation follow-up (UH-135).

Milestone “Sandbox isolation” (GitHub milestone v0.8.0, issues #154 / #155 / #156). Promotes the container sandbox backend from a fail-fast stub to a real OpenSandbox-gated execution-isolation tier and graduates oh-my-pi to active.

  • container sandbox backend — OpenSandbox-gated execution isolation (#155): replaces the #137 stub. ContainerBackend reuses DirectoryBackend for host-side materialization (so porcelain dirty detection + promotion are unchanged) and routes mission/verification commands through the OpenSandbox seam (runOpenSandboxCommand → runOpenSandboxTemplate). Env contract: UH_OPENSANDBOX_ENABLED=1 + UH_OPENSANDBOX_EXEC_COMMAND (must contain {command}; optional {cwd}, {image}, {timeout_ms} placeholders); optional UH_OPENSANDBOX_CREATE_COMMAND, UH_OPENSANDBOX_DELETE_COMMAND, UH_OPENSANDBOX_IMAGE (default python:3.12), UH_OPENSANDBOX_LIFECYCLE_TIMEOUT_MS (positive int ms, default 30000). Mock mode (UH_OPENSANDBOX_MODE=mock) for CI / dirty-roundtrip tests. Local smoke + claim-boundary table: docs/runbooks/container-sandbox.md. ADR: docs/architecture/sandbox-backends.md (includes #154 spike + #157 lifecycle hardening sections).
  • oh-my-pi graduated to status: active (#156): after the ToS posture documented in docs/runbooks/anthropic-via-omp.md and an uh adapter check oh-my-pi PASS against omp/15.2.4. The adapter manifest, scaffold template (uh adapter add oh-my-pi), README adapter table + capability summary, ROADMAP, and the docs-site mirror all reflect active. Mirrors the v0.7.0 vanilla pi graduation — same surface, same posture, same opt-in responsibility model. The runbook gained a dated v0.8.0 graduation subsection; the ToS-clean alternative (native ANTHROPIC_API_KEY adapter) is still planned for v0.9.0.
  • runOpenSandboxTemplate spawns commands in the sandbox-bound cwd (the host worktree) rather than process.cwd() so verify / create / delete templates with relative paths resolve against the sandbox (#157).
  • ContainerBackend.teardown runs UH_OPENSANDBOX_DELETE_COMMAND unconditionally when configured; forced / orphan discards spawn from ctx.root when the worktree has already been removed so external sandbox resources cannot leak (#157).
  • Lifecycle timeouts are configurable via UH_OPENSANDBOX_LIFECYCLE_TIMEOUT_MS (positive int ms, default 30000), with fail-fast validation surfacing the variable name on bad input (#157).
  • No fallback to a lean in-house OCI/docker-CLI backend is authorized by this release — the ADR pivot rule stands. The container path is OpenSandbox-only unless the lead approves a pivot.
  • CI does not exercise live container execution — Depot runners have no container runtime. The OpenSandbox mock mode covers schema + lifecycle plumbing in CI; live evidence is in docs/runbooks/container-sandbox.md.
  • macOS isolation reality — on macOS the boundary is the host’s Linux VM (Docker Desktop / OrbStack / Colima). Firecracker / KVM / gVisor / Kata claims require a Linux host with a configured secure runtime, per the ADR per-OS table.
  • Deferred to v0.9.0+: AgentFS as a filesystem backend (FS-only, not execution); native Anthropic adapter; Honcho MCP tools + opt-out; capability-declaration enforcement (--strict).

Milestone “Adapter expansion & sandbox backends” (GitHub issues #133–#141 under the v0.7.0 milestone; Linear UH-112–UH-121 — backfilled when the Linear workspace was upgraded post-release). Builds on v0.6.0’s cost-aware routing by adding cheaper routing targets and broader sandbox isolation.

  • OpenRouter adapter (#134) — OpenAI-compat HTTP client for openrouter.ai, the cheapest pay-per-token routing target. API key via OPENROUTER_API_KEY (never stored in the manifest); a missing key degrades uh adapter check openrouter gracefully (the CI-skip signal) and makes mission run fail fast via a plan error. Optional HTTP-Referer / X-Title ranking headers. Registered as a first-class routable adapter (auto-route, capabilities, uh adapter add openrouter).
  • Vanilla pi adapter (#135, #150) — the base pi agent CLI that oh-my-pi (omp) extends; CLI-exec (pi --print --mode json --no-session), config.cli_command overridable. Registered active (TEAM_ADAPTER_IDS, capabilities, uh adapter add pi). Flag surface + output parsing verified against live pi v0.73.1 (#150 fixed the parser to read pi’s message_end/content-block shape).
  • Sandbox backend abstraction + directory backend (#136) — a SandboxBackend interface behind uh sandbox create --backend <git-worktree|directory>. The directory backend is a self-contained local clone (hard-linked objects) that does not register with the parent repo’s worktree list or branch namespace.
  • container sandbox backend (#137) — registered as a fail-fast stub with an ADR (docs/architecture/sandbox-backends.md); the implementation is deferred pending a container runtime in CI.
  • Verify-then-promote auto-trigger (#139) — opt-in sandbox.promotion_policy: auto-on-verify; a passed uh verify auto-promotes. The default human-approved still requires a manual uh mission promote; a typo’d policy never auto-promotes.
  • OpenRouter setup runbook plus ROADMAP / README adapter-table updates (#140).
  • Extracted the mission-artifact helper block (path-safety guards + prompt/session/event writers) duplicated across hermes / codex / oh-my-pi / hermes-proxy into a single src/adapters/_artifact-context.ts (#133). Pure, behaviour-neutral refactor.
  • Capability-match enforcement (#138) was found already implemented (enforceRuntimePreflight → assertRuntimeRequirements, with a --force escape hatch) and was closed as evidence-ready; the ROADMAP “advisory-only” note was stale.
  • Deferred: oh-my-pi graduation to active (ToS posture) — tracked on the road-to-1.0. (The vanilla pi adapter shipped in this release; see Added.)

Epic 7 (adapter capability routing + cost) and Epic 8 (SDD hardening) completed, plus a suite-health pass and CI/release hygiene. Several v0.5.0 gaps were corrected: the UH-101 auto-router (claimed shipped but absent) was implemented, and token-usage capture (assumed by the cost features) was added.

  • Honcho memory for codex + hermes (UH-59 follow-up): both adapters now enrich the dispatched prompt with persistent memory and record the exchange after a run (mirroring oh-my-pi); env-gated and a no-op when Honcho is disabled. Adds basePrompt to their run plans.
  • Spec-adherence judge (Epic 8 / UH-110): uh validate --judge --spec <path> grades whether the diff (<base>...HEAD) satisfies a spec’s acceptance criteria via an LLM, returning a structured {adherence, missing_ac, evidence} verdict (exit 1 on fail). Opt-in; dispatches a one-shot through a configured hermes-proxy runtime. New src/harness/spec-judge.ts (pure prompt/verdict, injectable runner).
  • Spec template library (Epic 8 / UH-111): uh spec template [feature|epic] [--out <path>] [--list] emits starter uh.spec.v0 documents. Templates are source-of-truth TS constants (ship in the package) mirrored to docs/specs/templates/, with a drift-guard test. New src/harness/spec-templates.ts.
  • Running-now grid (Epic 6 / UH-97): GET /api/uh/runs/active scans each mission’s latest.json for in-flight runs; the dashboard Overview shows a “Running now (N)” card (auto-hidden when idle) linking into each live run.
  • Per-run cost gauge (Epic 6 / UH-96): the dashboard LiveEventsPane header shows live token totals (↑input ↓output) and estimated USD, aggregated from runtime.usage events. $/Mtok rates are sourced from the harness via GET /api/uh/adapters/capabilities (new cost_classes field) — no duplicated rate constants in the frontend. New apps/hermes-plugin/dashboard/src/cost-gauge.ts.
  • hermes-proxy live capability probe (Epic 7 / UH-103): uh adapter capabilities --probe fetches <endpoint>/capabilities and merges a (partial) capability document over the static manifest, falling back to static on 404/error/malformed. Forward-looking — proxies don’t serve this yet, so it’s a safe no-op today. New src/adapters/capabilities/hermes-proxy-probe.ts.
  • Cost forecast (Epic 7 / UH-104): uh adapter cost-forecast --mission <id> [--adapter auto|<id>] averages a mission’s past-run runtime.usage tokens (heuristic fallback when no history) and prices them by the adapter’s cost class. New uh adapter capabilities --json. Plugin endpoints GET /api/uh/adapters/capabilities + POST /api/uh/missions/{id}/cost-forecast shell the CLI so cost math stays single-sourced. New src/harness/cost-forecast.ts.
  • Token-usage capture: adapters now emit a runtime.usage event per run (prerequisite for cost-forecast + the dashboard cost gauge). hermes-proxy records real tokens from the OpenAI-style usage field; codex / hermes / oh-my-pi emit a deterministic estimate (chars/4) tagged source: "estimated". New src/harness/usage.ts.
  • Adapter auto-routing (Epic 7 / UH-101): uh mission run --auto selects the cheapest installed adapter whose capability manifest satisfies the mission’s runtime_requirements; --auto --explain prints the decision matrix. New src/harness/auto-route.ts (chooseAdapter), reusing evaluateAdapterEligibility (UH-102) and compareCostClass. Closes a gap where v0.5.0 listed UH-101 as shipped but the routing code was never landed.
  • Publish package workflow re-ran on every push to main, failing with 403 cannot publish over the previously published versions; now gated to v* tags / releases / manual dispatch with an idempotency guard that skips when the version already exists (UH-91, #112). npm publish was never actually blocked — 0.3.0/0.4.0/0.5.0 are all live.
  • Test suite is hermetic and deterministic (#113): Honcho memory forced off by default in tests (the suite was hitting the live Honcho API via a developer’s HONCHO_API_KEY), wall-clock assertions gated behind UH_PERF=1, and generous timeouts for real-subprocess tests.

Epics 6–8 integrated on dev from feature branches (live observability, adapter auto-routing, SDD hardening). Execution spec: specs/epics-6-7-8.md.

Epic 6 — Hermes plugin live runs & observability

  • Disk-backed SSE endpoint tailing per-run events.ndjson with keepalive and byte-offset resume (UH-93).
  • LiveEventsPane in mission drilldown reusing run-modal tail patterns (UH-94).
  • Cancel running mission by run_id from drilldown, Run modal, and uh mission cancel CLI (UH-95).
  • Runbook: docs/runbooks/plugin-live-events-smoke.md.

Epic 7 — Adapter capability matrix & runtime auto-routing

  • AdapterCapabilities Zod schema and per-adapter manifests (hermes, hermes-proxy, codex, oh-my-pi) (UH-100).
  • chooseAdapter + uh mission run --auto routing by mission runtime_requirements and installed adapters (UH-101).
  • Preflight validator enforcing runtime_requirements separately from mission capabilities (UH-102).
  • Static cost-class table for routing hints (src/harness/cost-table.ts).

Epic 8 — Spec-Driven Development hardening

  • Spec loader + uh propose --from <spec.md> mission bootstrap (UH-107).
  • uh spec scaffold — acceptance-criteria → Vitest it.todo scaffold generator (UH-108).
  • spec-stale validate-drift kind + --strict-spec CLI flag (UH-109).
  • Hermes plugin bundle ships at 43.4 KB (50 KB cap). Plugin manifest version 0.5.0.
  • UH-91 — npm publish workflow fix landed in v0.6.0 (#112, idempotency guard + v* tag gate); npm latest has been current through v0.6.0 / v0.7.0 / v0.8.0.
  • Linear epics UH-92 (Epic 6) / UH-99 (Epic 7) / UH-106 (Epic 8) and the child issues UH-93–UH-97 / UH-100–UH-104 / UH-107–UH-111 were backfilled to Linear when the workspace was upgraded post-release; previously this block noted they were “not filed via MCP during this cut”.
  • Later/Optional slices UH-98 + UH-105 were canceled (no operator gap surfaced) and recorded in Linear as such; UH-110 / UH-111 shipped in v0.6.0.
  • runtime.cancelled event handler now emits a single-line stderr warning when no latest.json pointer exists (instead of silently skipping). Quiet via UH_QUIET_CANCEL=1 for tests. Closes the operator-visibility gap left open by UH-82.
  • Run history retention policy: plugin manifest max_runs_per_mission cap (default null = unlimited). Oldest per-run dirs are pruned on each new run; runs/index.json entries persist with archived: true so the audit trail is preserved (UH-90).
  • New orphaned-run-dir drift kind for uh validate --repair: detects .harness/missions/<id>/runs/<run_id>/ directories that have no corresponding entry in runs/index.json (idempotent rm -rf repair). Closes a UH-82 follow-up.
  • uh mission run --runtime-config-overrides <json> flag merges JSON-encoded overrides on top of the mission’s runtime_config_overrides block. The Hermes plugin Run modal now passes user-supplied overrides through (UH-81).
  • Per-run artifact directories under .harness/missions/<id>/runs/<run_id>/ with a latest.json pointer and append-only runs/index.json history. Concurrent runs of the same mission no longer interleave; the Hermes plugin’s per-run route now serves the correct run (UH-82).
  • Recent runs pane on the Hermes Dashboard Mission detail tab with sortable columns, status-chip filtering, and run-id prefix search. Click a row to drill into that run’s artifacts (UH-85, UH-86, UH-88).
  • UH_TUI_THEME=dark|light|system palette switch with full src/tui/theme.ts palette module (UH-48).
  • Ctrl+Z / fg suspend-resume lifecycle in the TUI, backed by OpenTUI 0.2.13’s renderer.suspend() / renderer.resume() (UH-50).
  • uh tui screenshot --view <name> --out <path> automated capture pipeline with overview / missions / sandboxes / workflows views (UH-51).
  • e opens the current mission manifest in $EDITOR from the TUI mission detail view, suspending and resuming the renderer cleanly (UH-49).
  • Compare two runs side-by-side: new MissionCompare view with runtime-result field diff, prompt.md line diff (LCS-based, no new dep), and events.ndjson side-by-side stream. Triggered via “Compare” mode on the Recent runs pane (UH-89).
  • Replay a historical run: “Replay” button on Recent runs rows + per-run drilldown opens the Run modal pre-filled with the source run’s runtime_config_overrides; runs/index.json carries the replay_of lineage (UH-87).
  • uh mission run now accepts --run-id <id> for deterministic per-run artifact paths; the Hermes plugin passes the id it generates so dashboard, CLI, and on-disk artifacts all agree. The previous 409 run_already_active guard is gone — per-run directories make concurrent same-mission runs safe.
  • RunHermesResult / RunCodexResult / RunOhMyPiResult / hermes-proxy RunResult now carry the runId of the directory they wrote.
  • runtime-result.yaml is still mirrored to the mission root after each run, so uh status, validate-drift, and the dashboard’s last_run field keep working without learning per-run paths.

Two epics shipped end-to-end plus a deep discipline-layer pass distilled from GSD-2 research. 26+ correctness findings caught and fixed under Codex adversarial review across 13 rounds on the Hermes plugin alone.

  • Epic 3 — Hermes Dashboard plugin (UH-60, #89)
    • Drop-in Hermes plugin at apps/hermes-plugin/ exposing UH from the Hermes web UI: adapter health, mission browser, run trigger with SSE live tail, prompt/final-message/diff/runtime-result drilldown, workflow + verification viewers, theme YAML, sessions cross-link, first-run wizard, install runbook (UH-61..UH-69).
    • FastAPI bridge that shells out to the uh CLI; no daemon, no FFI, no Hermes fork. Watchdog enforces UH_RUN_TIMEOUT_S. Solid bundle ships at 25.5 KB (50 KB cap).
  • Epic 4 — Team mission shape (UH-70, #87 + #88 + #90)
    • New team mission shape with adapter-bound workers, per-worker worktree auto-isolation, leader integrator role, integration-report.md artifact (UH-71/72).
    • New workflow profiles: staged (plan → prd → exec → verify → fix) and adversarial-qa (OMX $ultraqa analog) with gate-6-no-leaked-artifacts fail-closed gate (UH-73/74).
    • Companion design.md artifact alongside mission.yaml (UH-75).
    • Three-state MergeOutcome (clean | conflicted | failed) and writeIntegrationReport verdict propagation.
  • Discipline layer from GSD-2 research (#88)
    • Three-verdict runtime-result status (pass / needs-attention / needs-remediation) plus uh mission verdict manual override (UH-76).
    • uh validate drift detection + idempotent repair registry: orphaned worktree, stale render, stale worker, truncated events.ndjson, missing completion timestamp, ROADMAP↔Linear divergence (UH-77).
    • uh status --json LLM-less query mode feeding the Hermes Dashboard (UH-78).
    • Canonical docs/VISION.md with explicit “what we won’t accept” (UH-79).
    • Pre-inlined dispatch context contract formalized across all four adapters (UH-80).
  • Honcho persistent-memory extension (UH-59, #83) — env-driven enrich/record at the harness layer for oh-my-pi, with fail-fast misconfig and graceful network degradation.
  • mission run now writes events.ndjson, runtime-result.yaml, final-message.md, and (for team missions) integration-report.md under .harness/missions/<id>/; per-run subdirectories are a follow-up (UH-82).
  • All adapters (hermes, hermes-proxy, codex, oh-my-pi) now consume a single pre-inlined dispatch-context contract (UH-80), removing per-adapter prompt drift.
  • Codex adversarial review on PR #89 caught and fixed 26+ correctness issues before merge: SSE drain races, cancel-vs-natural-exit races, watchdog leaks, path traversal, symlink artifact disclosure, _active_runs unbounded growth, started-byte-offset capture order, get_mission blast radius on corrupt YAML, runId sanitization, concurrent-run guard (409), is_run_scoped mislabeling, decodeURIComponent crash on malformed hash, and more. Detail: PR #89 conversation.
  • PR #87 Codex pass caught the team-mission MergeOutcome.failed propagation gap; fixed in #90.
  • UH-81 — Real --runtime-config-overrides CLI support. The Hermes plugin’s Run modal currently 400-rejects non-empty overrides (overrides_not_yet_supported).
  • UH-82 — Per-run artifact directories under .harness/missions/<id>/runs/<run_id>/. The plugin’s per-run route surfaces is_run_scoped: false + banner.
  • UH-83 — Activate .github/workflows/release-plugin.yml (staged at docs/ci/release-plugin.yml.example).
  • Epic 1 — Hermes proxy adapter (UH-32) promoted to status: active after live E2E smoke against hermes proxy start --provider nous (#49..#55).
  • Epic 2 — Interactive TUI (UH-41) on OpenTUI (Solid bindings, Bun preload): dashboard, mission browser, run flow, adapter+sandbox manager, keymap overlay, per-project persistence (#52, #57, #59, #61, #63, #64, #65).
  • Spec-Driven Development discipline (UH-54, #68) — structured acceptance_criteria with per-AC verify.
  • Test-Driven Development discipline (UH-55, #69) — tdd workflow profile + test-first verify gate.
  • Cross-runtime QA harness (UH-56, #70) — uh mission run-all with side-by-side adapter comparison.
  • Runtime intelligence + operator polish (UH-57, #77) — TUI screenshot capture, adapter-check age footer, runtime.cancelled event, mission capability enforcement.
  • Package rename + CI publish (UH-58, #79) — @agenticengineeringagency/ultimate-harness with publishConfig.access=public, dry-run + release-publish workflow.

Initial public release. Adapter framework (hermes, codex, oh-my-pi), mission schema, runtime-result artifact contract, verification + promotion pipeline.