Skip to content

0.8.0

Choose a tag to compare

@github-actions github-actions released this 04 Nov 09:41
· 9 commits to main since this release

[0.8.0] — 2026-11-04

The loop becomes something you can leave running. run now fixes a failed
verify or review instead of stopping at the first one, work is the one
command that plans, builds, verifies, reviews and finishes, and the run
records enough for a script - or the person after you - to see what happened.

The loop is now observable and resumable rather than only restartable: a run
leaves evidence, an event log and a record a script can read; a worktree run
can be found after the terminal closes; and a route that died is not retried
blind.

Added

  • oc-harness work "<request>". Plan when there is no executable plan,
    then build, verify, review, final verify, final review and summary. Flags:
    --plan-only, --dry-run, --branch, --commit, --worktree,
    --allow-dirty, --max-tokens, --max-task-minutes, --final-verify,
    --final-review. It never pushes, opens a pull request or publishes.

  • oc-harness plan "<request>". The planner's answer is validated before
    it is written: every task needs files:, change: and a verify: that can
    fail. A rejected plan never replaces an existing one. --print shows it
    without writing; --force replaces an existing plan.

  • oc-harness status [--json]. The last run from .space/run.json:
    status, reason, per-task attempts, review rounds and checkpoint commits.

  • Plan preflight. run checks the whole plan before the first agent is
    called: no tasks, a missing verify, a verify that cannot fail, or two tasks
    the parser cannot tell apart all stop the run at exit 2.

  • Fix rounds. A failed verify is handed back to the build agent with its
    real output; a failed review is handed back with its blockers. Default 2
    rounds each (--max-fix-rounds, --review-fix-rounds).

  • Final checks. --final-verify runs one command after the last task;
    --final-review reviews the whole diff from the run's base commit.
    .space/summary.md is written only when both pass.

  • Checkpoints. --branch and --commit commit each finished task and
    only the paths it touched. --worktree runs in .space/worktrees/<id> so
    the project itself is untouched while the run happens.

  • Route failover inside a run. A spent or unreachable route no longer
    marks the task blocked; work retries once per other route in the lane
    chain using OC_HARNESS_MODEL, and never on the route that failed.

  • oc-harness lanes --suggest. Names lanes the telemetry says are not
    earning a slot. It reads; it never edits lanes.json or a profile.

  • A local profile, ollama-qwen3-coder. Qwen3 Coder 30B served by Ollama
    on localhost: zero egress, zero-retention by construction, no per-token
    cost. Pull it with ollama pull qwen3-coder:30b.

  • npm run test:loop, and a named CI step for it: end-to-end scenarios
    through the real CLI with a stand-in opencode, covering a fix round, a
    review fix, an out-of-scope edit, a vacuous verify, a token budget and a
    failed final verify.

  • oc-harness autopilot: from an empty directory, initialise a blank
    track, tick the charter, run research/design/decompose, then call
    work --project. It refuses an existing .space without a track.json
    instead of overwriting a hand-written track. --json keeps stdout to one
    object; --dry-run still runs the model-backed spec steps and only makes the
    final work step a preflight.

  • Milestone gates in the built-in templates. blank, inventory,
    billing and existing now put - gate: {{test_command}} on M1 and M2, so
    spec decompose --milestone M1 works on a freshly initialised project. The
    last milestone may omit its gate because there is no next milestone to gate.

  • oc-harness finish runs the real completion gate. It refuses missing or
    empty plans and unfinished tasks with exit 2, runs the track's acceptance
    command (exit 4 on failure), then the install check (exit 1 on drift), and
    reports the dirty/publish boundary without publishing.

  • resolve: lane models drawn from the catalogue instead of written down.
    A profile may declare "resolve": { "from": "catalogue", "free": true, "chainDepth": 3 } and carry no roleModels at all. At use time the kit
    keeps the models that are free, at or below the profile's retention ceiling,
    and able to serve the lane — vision needs images, schema needs structured
    output — and records the result in <config dir>/lane-resolve.json.
    --offline replays that lock and refuses when there is none or when it
    belongs to a different profile, so an offline install is reproducible rather
    than freshly guessed. A lane with both a hand-written chain and a resolve
    block is refused: one lane, one source of models.

  • big-pickle-auto, the first profile built on resolve. Ten lanes, base
    model big-pickle, may-train, refreshed at install time. Opt-in, and not
    the default.

  • oc-harness lanes now answers the two questions a reader had to open the
    profile index for: whether a lane costs money (free) and who trains on it
    (retention). A footer names where the models came from — the profile file,
    or a lock and how old it is.

  • The spec workflow: a validated plan before the loop starts. oc-harness spec init lays a track down from a template (inventory, billing,
    existing, or blank), spec check proves the charter still has its locked
    sections and a ticked ## Ready, and spec research, spec design and
    spec decompose make exactly one model call each and write what it
    returns into .space/. Each step is budget-checked before the call and
    size-checked after it, is refused rather than retried when the model is
    offline, times out or returns junk, and cannot be re-run without --force;
    --print and --dry-run never reach the model at all, so a template is data
    and the data commands cost nothing. Readiness lives in .space/track.json
    (charter_ready → research_ready → design_ready → plan_ready) and
    setting a key clears every later one, so a plan cannot stay "ready" after the
    design it was built on changed. spec decompose runs the generated
    tasks.md through the same parser work uses, and refuses a plan whose task
    has no verify, whose [REQ-NNN] tag is not in the charter, or whose verify
    command is not runnable. Every refusal is exit 2 with a JSON body on
    stderr and an empty stdout, listed in docs/EXIT-CODES.md.

  • oc-harness work --project: run a planned track and nothing else. It
    takes no positional request — the request is .space/tasks.md — and refuses
    before it looks for opencode when the directory has no track or
    plan_ready is not true. --strict is forced off, because strict mode
    exists to make an under-specified request fail and a planned track is the
    output of the steps that remove that ambiguity. The refusal prints to stdout
    with exit 2, matching plain work --json, and --dry-run runs the same
    preflight without writing a run record.

  • A ceiling on what one session may spend (effort.sessionTokens). The kit
    bounded one request (compaction at 130k) and one task (40 calls for a build),
    and neither bounds a session: the measured one made 769 requests, every one
    of them under the ceiling, and spent 67.93M prompt tokens until the route
    answered "Free usage limit reached". fleet-safe now sets 6,000,000 tokens;
    the telemetry hook charges each finished message (input + cache read + output, counted once per message id), and the guard throws a three-line
    message at 70% and refuses every tool call at 100%. The message is prose, not
    a rule map, because opencode echoes a rule map back as the refusal and the
    measured one was 11,041 characters. 0 turns the ceiling off, which is what
    every install had before this; a value under one 200,000-token window is
    rejected as a profile that would stop a session before its first request.
    test/budget.test.js covers the arithmetic, both thresholds, the
    once-per-session warning, and the guard actually refusing a call - the last
    one is why the test bundles the guard and the counter into one graph.

  • eval/token-burn.mjs (npm run token-burn). The reading that was missing
    when a session on a free route spent 67.93M prompt tokens, peaked at 169,597
    tokens in one request and ended with "Free usage limit reached": requests,
    prompt and output tokens, the worst request and when it happened, how many
    tokens were re-sent in refusals, and what the tool output weighs — per day,
    from the database the session already wrote. It does not report prune
    coverage, because opencode stores a part unpruned and the pruner rewrites the
    outgoing request: a stored prune marker means the session was resumed from a
    pruned transcript, not that pruning ran. The gate is
    the fleet's own compaction threshold plus the size of one tool result, judged
    only on requests made after the running config was installed, so the history
    that motivated the fix does not fail every run forever.

  • test/token-burn.test.js, the token-burn suite. Eleven tests, each
    pinning one factor of requests x context: compaction at 130k rather than
    176k, 40 calls per build rather than 120, no lane narrowing bash with a
    catch-all rule map, no lane prompt carrying a copy of the allowlist, the
    refusal text under its measured size, tool_output wide enough that a read
    is not truncated, a denial ending the turn, and compaction running the pruner.
    The last test runs the audit itself against a database it builds, including
    the case where the gate fails.

  • oc-harness report [--json]. One run as numbers: phases and their
    tokens, verify count and failures, routes used, recorded error codes, and
    the next action.

  • oc-harness resume. Continues the recorded run, keeps its id, tokens,
    attempts and budget, and refuses a finished run or an edited plan. It finds a
    run inside .space/worktrees/ when the project directory has no record, and
    refuses if that worktree is gone.

  • Worktree cleanup. work --cleanup / resume --cleanup remove a finished
    worktree; a run that is still going is refused unless --force-cleanup.

  • oc-harness health [--probe]. Lists spent routes. --probe asks every
    route once, clears one that answers, records a quota or withdrawn failure,
    and ignores an unclassified blip rather than poisoning the route for a day.

  • --sandbox container. Verify commands run in Docker with the project
    mounted at /work, no network unless asked for, and the image configured by
    --sandbox-image or OC_HARNESS_SANDBOX_IMAGE.

  • --adapter exec. Any command-line agent can serve a lane with
    --agent-command (or OC_HARNESS_AGENT_CMD); {prompt}, {role} and
    {cwd} are substituted, and the prompt goes on stdin otherwise.

  • oc-harness mcp. A read-only MCP server over stdio: status, report,
    evidence, events, health and the plan (harness_tasks, including each task's
    accept: line). There is no tool that starts or changes a run.

  • The kit's hooks run on OpenCode 2. A second entrypoint,
    opencode-harness-kit/v2 (dist/v2.js), is a plain { id, setup } object;
    the default V1 export stays a function, because V2 rejects a function even
    with id/setup attached. setup(ctx) builds the same hook map through
    src/harness-hooks.ts and registers it on ctx.tool, ctx.session and
    ctx.event, so the guard, pruner, router and telemetry enforce on both
    APIs. What the bridge cannot carry (config, chat.params, nested Code
    Mode calls) is listed in docs/KNOWN-LIMITS.md.

  • oc-harness use --target v1|v2|auto. Picks the config dialect. V2 moved
    subagent_depth under experimental, removed batch_tool,
    continue_loop_on_deny, kept lsp, and stopped asking before an outside path.
    The default stays v1, so an existing install regenerates unchanged; auto
    reads opencode --version.

  • npm run gate:v2. Compiles a V2 config and reads it back through
    opencode debug config, asserting the moved or removed keys, embedded lane
    prompts, skills array, LSP and permissions. It then starts a real V2 server
    against a fake model and checks that a shell call to npm publish is
    refused and that Code Mode exposes no shell builtin. It skips with exit 0
    when no 2.x binary is installed, so it stays out of npm test.

  • V2 parity. setupV2 now writes .space/active, applies per-lane effort
    and lane failover through ctx.agent.transform, and records the running lane
    in telemetry from the V2 tool event. Lane prompts are embedded in system,
    skills become an array, LSP is kept, and permissions are emitted in the V2
    native form.

  • accept: in .space/tasks.md. An optional acceptance line, shown to the
    builder before the verify command. It is prose, so it never replaces the
    command that defines done.

  • --verify-repeats <n>. Runs each task verify, and the final verify, up to
    n times and stops at the first failure. Every execution is its own evidence
    entry (repeat and repeats), so a flaky second run stays visible. Default 1.

  • OTLP export. With OTEL_EXPORTER_OTLP_ENDPOINT set, each run event is
    also sent as an OTLP/HTTP span. A collector that is down never fails the run.

  • run.schema.json. The written run@2 record, so a script can validate
    what it reads. Its status, phase and terminal enums are checked against
    the state machine's vocabulary, and history, endedAt and interruptedAt
    are part of the schema.

  • oc-harness resume and run stop on SIGINT/SIGTERM. The record ends
    as interrupted with exit 130 and releases the lock, instead of the process
    dying while run.json still says running.

  • Cache tokens are counted, not hidden. run.budget.spentTokens includes
    cache reads and writes, and spentCacheTokens reports that share. The event
    log keeps tokens and cache as per-checkpoint deltas.

  • A task review diffs from the tree the attempt started in. reviewDiff
    takes a git stash create baseline, so pre-existing tracked edits and
    untracked files are not blamed on the agent.

  • A resumed run continues its review rounds. The count is seeded from the
    record's tasks[].reviews (and the verdict files on disk), so a resume no
    longer overwrites 01-*.json. The final review base is stored in
    finalBaseRef and reused after task commits.

  • npm run gate:loop. Five offline loop scenarios: a pass, a repeated
    verify failure, a destructive verify command, a spent task budget, and a
    route failure that stops provisionally and is resumed.

Changed

  • run no longer marks a task blocked when the model route fails. The
    task stays pending so a retry can reach another model. Behaviour that was
    "exit 4 on a 429" is now "exit 3, retry the next route, stop if every route
    is spent".

  • A review failure is a fix round, not a terminal verdict. It exits 5 only
    after the review fix budget is spent, or when the reviewer's answer is not a
    schema'd verdict.

  • run --json exists, and human progress goes to stderr in that mode. The
    report is one object: ok, code, reason, rounds, tokens, run,
    summary, log.

  • --print-verify and --trust-verify gate every verify command, in
    run as well as work. This is the breaking change: non-interactive runs
    that used to execute a task file's shell commands now exit 2 until they pass
    --trust-verify.

  • .space/ is never committed by a checkpoint and never makes a tree
    dirty
    for --branch; it is the harness's own bookkeeping, not the change
    under review.

  • work is strict by default. It refuses to start without the review,
    final-verify, final-review, worktree and commit parts of the contract. Pass
    --no-strict for a local run on a dirty tree.

  • Per-lane prompt budget. A prompt larger than the lane's narrowest model
    can hold is refused before it is sent, instead of being truncated by the
    provider.

  • Opening a record is a transition. start, resume and the provisional
    route-failed are rows in the table, so runLoop cannot reset a record with
    assignments that disagree with the state it writes. resume clears the old
    terminal and endedAt; route-failed keeps the phase and leaves terminal
    null until work writes route-exhausted.

  • work holds one lock for the whole request, across route retries, and
    releases it on every return path. runLoop takes a lock only when it is
    called directly.

  • A task is committed before it is marked done. A refused commit stops the
    run as checkpoint-failed with the task still pending, so the plan never
    claims work git does not have.

  • status prints the record's own next command. A budget stop reports the
    resume --max-tokens it actually needs instead of a generic resume; a stale
    lock still overrides it with the reconciliation command.

Fixed

  • A spent route could be retried because its health key was qualified. The
    router records provider/model, while a lane chain names the bare model;
    availableRoutes compared the two directly, so a route the session had
    already written off stayed a candidate. Both shapes now match.

  • oc-harness report counted earlier runs. The event log and evidence file
    outlive a run, but the report counted every record in them. It now scopes
    both to the current run.id, matching the evidence section of report.md.

  • oc-harness spec --help exited 2. The help flag was treated as a missing
    subcommand because the parser only looked for non-flag words. --help and
    -h now print usage and exit 0, like spec help.

  • .space/health.json was written without redaction. A provider error
    stored as the route's reason could carry a credential to disk. Health writes
    now pass through redactDeep like the other .space/ records.

  • A healthy probe did not clear the router's qualified health key. Probing
    a bare model deleted only model, leaving opencode/model spent. The
    default provider's key is cleared too; another provider's key is untouched.

  • health --models accepted the next flag as a model id. --models --probe and an empty --models= now refuse with exit 2 instead of probing
    a flag or falling back to the configured profile.

  • A profile with no declared limits could not send any prompt. Both the
    context and output fallbacks were MAX_SAFE_INTEGER, so the output reserve
    left zero usable tokens. An undeclared output limit now reserves nothing.

  • --allow-compound-verify accepted commands that hide a failure. A pipe,
    ||, ;, newline, background &, or leading ! can make a failing verify
    exit 0; all are now refused even under the escape hatch. The flag accepts
    && chains such as npm test && npm run lint, where every command must
    succeed. finish uses the same rule for the track's acceptance command.

  • The second readiness setter did not clear later stages. track.setReadiness
    accepted unknown keys and left design_ready/plan_ready set after a new
    research note; it now mirrors setReadinessKey and clears everything after
    the key being set.

  • spec research and spec design spent a model call on flags they ignored.
    --milestone is only meaningful to decompose and --question only to
    research; both are now refused as argument errors before any model call.

  • A failed planner spawn was reported as a timeout. runSpecStep treated
    any null status with an error string as a timeout, so ENOENT and a bad
    command produced the wrong diagnosis. A spawn failure is now a spec-agent
    failure; only a signal or an actual timeout error is a timeout.

  • A planner could persist a credential in .space/tasks.md. The plan was
    validated, then written with a hand-rolled temp-file rename that never passed
    through redact or refused a symlink. It now uses writeTextAtomic, the same
    path as the other .space/ writes.

  • oc-harness report lost when a run finished and invented its minutes. The
    run@2 record stores endedAt and seconds, but the report read the v1
    finishedAt alias and a nonexistent budget.spentMinutes; the JSON now
    exposes finishedAt with the endedAt fallback and seconds, and the text
    derives minutes from seconds.

  • A preflight with several invalid tasks corrupted the plan. Each fix-up
    inserted an output: block into the document, but the next task still used
    the ranges from the original parse, so two invalid tasks wrote their notes
    under the first one. The preflight now reparses before each edit.

  • A review verdict that could not be written was reported as a pass. If
    .space/review was not writable, the task was still marked done and the run
    exited 0 with review: pass and no verdict file. The write is now a
    checkpoint: the task stays unfinished and the run stops with exit 2.

  • A task file that could not be written was ignored. The task could be
    recorded as done in run.json while .space/tasks.md still said pending.
    A failed task-file write now stops the run as checkpoint-failed.

  • The health probe ran opencode outside the project. health --probe
    passed no cwd to spawnSync, so the model was checked against whatever
    directory the command happened to start in. The probe now runs in the same
    project as the health file.

  • Clearing a task's verify output did not clear it. markTask treated an
    explicit empty string as "leave the previous output alone"; "" now removes
    the stale block, while an omitted value still preserves it.

  • autopilot derived the project name by splitting on /. That returns a
    drive letter on Windows; it now uses path.basename.

  • spec decompose erased the milestone it was not asked about. A plain
    decompose wrote milestone: null over the track's recorded milestone; it
    now preserves it. The --milestone path validates the selected gate with
    the same policy as a task verify command, runs earlier gates only after the
    cheap refusals and --dry-run, and no longer executes a gate the policy
    would refuse. Milestones inside fenced examples are ignored, and backticks
    around a gate command are stripped.

  • work advanced the milestone without doing any work. A plan that was
    already complete moved M1 to M2 and skipped M2's tasks. It now advances only
    when this run marked a task done, and it resets plan_ready so the next
    milestone needs its own decompose.

  • .space/report.md and .space/summary.md could carry the raw goal.
    Both were rendered from the live record after run.json had been redacted;
    they now pass through the same redact before the atomic write. Bare
    credentials (GitHub, OpenAI/Anthropic, Slack, AWS, Google token shapes) are
    recognised even when no field name precedes them.

  • autopilot could overwrite a hand-written .space. It now refuses when
    .space exists without track.json, writes the charter atomically with
    redaction, treats a $& in the goal as text rather than a replacement
    pattern, suppresses spec stdout under --json, and maps a killed child to a
    non-zero exit instead of reporting success.

  • work --strict ignored the automatic final gate. A track acceptance
    command (or the project's npm test) did not satisfy the strict contract
    unless --final-verify was repeated. The resolved gate is now the one strict
    validates, and --no-final-gate still opts out.

  • work --show-budget and work --cleanup resumed an interrupted run first.
    Both read-only/cleanup paths now run before auto-resume, so a flag that asks
    a question does not start or continue a run.

  • use --target defaulted to auto while the docs promised V1. The
    default is V1 again; --target auto remains explicit.

  • A lane could be given a model above the profile's retention ceiling. The
    last resort in laneModelId returned chain[0] without asking
    retentionAllowed, so a zero-retention profile whose whole chain was
    may-train installed a may-train router. It now resolves to null, and
    generateConfig refuses the install instead of pinning a model the profile
    promised not to use.

  • oc-harness lanes reported the base model for every lane of a resolved
    profile.
    loadProfile fills a missing lane with the base model, which is
    what the profile declares, not what the install runs; the lock is now
    read first.

  • oc-harness use refused with exit 1. docs/EXIT-CODES.md has said exit 2
    means "the harness said no" since spec shipped, and every other refusal
    already used it. A typo in a profile name looked like a broken install to a
    script reading the code. use now exits 2 for a refusal and 1 only for a
    step that failed.

  • Three latency assumptions in test/eval-failfast.test.js. Under eight
    concurrent runs of the file, 16 of 16 runs failed at least one test; alone it
    passed 17 of 17. Two tests gave a child 1–2 seconds to start, which a loaded
    machine cannot guarantee: the "killed by the ceiling" test then died on ENOENT
    because the pid file was never written, and the "stalls before the ceiling"
    test saw an empty stream and was correctly classified as "produced no tool
    calls and no text" instead. The third failed on the preflight's 5-second
    deadline, which has nothing to do with what it asserts. All three now have
    startup headroom (--timeout 5) or skip the probe (--no-preflight), and 16
    of 16 concurrent runs pass.

  • eval/token-burn.mjs reported prune coverage it could not see. It counted
    stored parts carrying a "pruned from context" marker and warned when the count
    was zero, which is the normal case — opencode prunes the request, not the
    history. It now reports the weight of the tool output (bytes, how many results
    are over 8k characters, the largest one and which tool produced it) and treats
    a marker as evidence of a resumed session. A result past
    tool_output.max_bytes (51,200) is a warning that names the tool: the
    measured install had 57,941 characters from read --limit 1500 and the Linux
    one 72,101 from grep, because max_bytes is not honoured the same way by
    every tool: read truncates by lines, grep by matches, so the call's own
    limit is what sets the size.

  • The state machine is the driver's gate, not documentation. runLoop
    checkpoints phase changes through src/driver/transitions.mjs instead of
    assigning run.phase directly, so run.history is a real audit trail and an
    edge the table does not define throws. task-done is a run phase now, and
    the schema accepts it.

  • .space/tasks.md is written atomically and redacted, like every other
    state file. A crash no longer leaves a torn plan or a secret from a verify
    log in the task file.

  • A crash inside the loop ends as needs-human with exit code 2 and
    releases the lock, instead of escaping as an exception with the record still
    marked running.

  • A checkpoint that cannot be written stops the run. checkpoint throws
    CheckpointError, runLoop reports exit 2 with checkpoint-failed and the
    real error, and the final checkpoint in finish writes the stop
    best-effort rather than recursing or returning 0.

  • A route retry writes the live record. work no longer stores copies made
    with { ...run } that the next checkpoint overwrote, so routes.tried,
    routes.attempts and a task's commit SHA survive the retry.

  • A v1 failed record reads as blocked, and a v2 terminal: null on a
    live route-failed record is no longer mistaken for a finished run.

  • The schema and the state machine share one vocabulary. phase,
    terminal and status come from phases.mjs, so a record the driver writes
    validates against the schema it ships. The unused stopped status is gone,
    and a drift test compares the code, the schema and docs/RUN-STATE.md.

  • An interruption stamps interruptedAt on the signal path as well as on
    stale-lock reconciliation, and a record that cannot be written makes the
    interruption exit 2 with the write error instead of a misleading 130.

  • routes.attempts reaches the disk. upgradeRun rebuilt routes from
    three named fields on every read and write, so the history a failover had just
    recorded was gone on the next checkpoint. Unknown route fields are now kept.

  • Verify output is clipped before it becomes a prompt. The reviewer prompt,
    the fix-round prompt and the task note take at most 8 KB (2 KB of head, the
    rest of the tail) with an omitted-byte marker; a 1 MB failing log no longer
    costs that many tokens on every round or grows .space/tasks.md without
    bound.

  • The review diff is capped in bytes, not UTF-16 units. reviewDiff measured
    Buffer.byteLength but cut with slice, so non-ASCII diffs could be 2-3x the
    budget and end on half a character. src/driver/text.mjs now cuts on the
    encoded bytes and drops a partial sequence instead of emitting U+FFFD.

  • The review verdict is redacted before it is written. writeVerdict was
    the one .space/ writer that skipped redactDeep, so a key quoted in a
    blocker or in the verify command reached .space/review/*.json verbatim.

  • A late signal does not overwrite a finished run. interruptRun now leaves
    a record whose status is not running untouched and only releases the lock;
    a done run stays done instead of being rewritten as interrupted.

  • readEvents no longer lets a torn JSONL line consume one of the requested
    slots.

  • Worktree cleanup ignores the harness's own .space/ when deciding whether a
    worktree is dirty.

Removed

  • The shared token window. The OC_HARNESS_BUDGET_WINDOW_* settings, the
    ledger they were summed from, and the guard branch that refused tool calls
    with shared token window are gone, including the sticky stop. There is no
    flag to turn the mechanism back on: OC_HARNESS_BUDGET_FILE and the other
    window variables are no longer read, and the ledger file is neither read nor
    written.
  • The session token budget. The guard no longer counts session tokens,
    refuses tool calls at OC_HARNESS_BUDGET_STOP, or blocks a session at
    OC_HARNESS_TURN_STOP. The variables, the step-finish listener and the
    toasts are gone; src/budget.js and its tests were removed. There is no
    replacement flag.

Release engineering

  • The release gate verifies the tag, not just its spelling. npm run release:check -- --tag vX.Y.Z used to pass when vX.Y.Z did not exist;
    it now refuses a missing tag and a tag that does not point at HEAD.
  • The publish workflow is back on main. A tag push runs the full matrix
    (Linux and macOS, OpenCode 1.19.4 and 2.1.4), publishes through trusted
    publishing, creates the GitHub release from the CHANGELOG section, and
    attaches the npm tarball and its SHA-256.
  • Local profiles are not catalogue profiles. ollama-qwen3-coder is
    marked "local": true; doctor, refresh and research name it and skip
    the models.dev comparison instead of reporting qwen3-coder:30b as
    withdrawn.