Skip to content

Releases

0.9.1

Choose a tag to compare

@github-actions github-actions released this 08 Nov 02:59

[0.9.1] — 2026-11-08

Changed

  • The README is a landing page again. The long design document moved to
    docs/DESIGN.md; the README now leads with the one-command install, the
    measured A/B, the two routes and the full command list. It still names no
    concrete model: the model is a fact about your account, not a recommendation
    that can be shipped.
  • The README carries the A/B numbers directly, including the result where
    the kit loses: on a task that fits in one read it uses more tokens and takes
    longer for the same answers.
  • A recorded demo and a social preview ship under docs/assets/. The demo
    shows a real init against a free model, the ten lanes, and the install
    verifier agreeing with the profile.

0.9.0

Choose a tag to compare

@github-actions github-actions released this 05 Nov 03:22

[0.9.0] — 2026-11-05

Changed

  • No model profiles ship. The kit is the harness, not a list of models:
    profiles/index.json is empty and default is null. The old profiles
    moved to test/fixtures/profiles/ and are test data, not choices.
  • No model retention entries ship either. retention.yml now carries only
    the unknown default and documentation; a person's verdicts live in
    ~/.config/opencode/retention.json and are written by
    use <provider>/<model> --retention <level>. Fixture verdicts moved to
    test/fixtures/profiles/retention.json so the suite still exercises them.
  • The README documents two routes, free and paid/upgraded, and names no
    concrete model. A model id in the README would be a recommendation that goes
    stale the day the route is withdrawn; the test suite now fails if one is
    added.
  • oc-harness use <provider>/<model> --retention <level> creates a
    profile.
    It reads the model from the live catalogue, writes
    ~/.config/opencode/profiles/<id>.json, and records the retention verdict
    in ~/.config/opencode/retention.json. --id overrides the generated name.
  • oc-harness init --model <provider>/<model> creates the profile and then
    installs and verifies it. Without a terminal or --model, init prints the
    command instead of guessing a model.
  • Profiles are discovered in the config directory first, then in the
    package directory, so a user profile and a fixture profile cannot shadow
    each other silently.
  • list, auto, upgrade, verify and lanes say when there is no profile
    yet and print the use command that creates one, instead of failing on an
    empty selection.
  • No runtime path names a model. The invariant is enforced against the
    fixture ids and models, so a future edit that puts a concrete choice in
    bin/, src/, the prompts, templates, skills, schema or README fails the
    suite. Historical measurement docs may keep their names; nothing executable
    may recommend one.
  • doctor with no profiles asks for a model instead of printing "all
    profiles match" over an empty list, and <command> --help prints the help
    rather than starting the command and failing for want of a terminal.
  • CI and the V2 gate use the test fixtures explicitly instead of relying on
    profiles that no longer ship, and selfcheck copies the fixture profiles
    into a temporary directory before installing, so it never writes test data.
  • Project metadata: SECURITY.md now lists the supported versions for the
    0.8.x and 0.7.x lines, the Contributor Covenant 2.1 applies to every
    community space, and .mailmap folds the historical author spellings into
    one maintainer identity.

0.8.0

Choose a tag to compare

@github-actions github-actions released this 04 Nov 09:41

[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. ...

Read more

0.7.3

Choose a tag to compare

@pham-canh pham-canh released this 04 Nov 09:52

[0.7.3] — 2026-10-26

Documentation only. No code, config or behaviour changed.

The 0.7.2 tarball was built from 8bf0283, before the README sentence that
describes npm run selfcheck was corrected on main. It said the release
check ran last; it runs right after the build, against the tarball that build
produced. 0.7.2 users have the old sentence in node_modules; this release
republishes the corrected README.

0.7.2

Choose a tag to compare

@pham-canh pham-canh released this 04 Nov 09:52

[0.7.2] — 2026-10-26

A patch about the release process itself: the checks that decide whether a
release is coherent now live in one command and run in CI.

Added

  • npm run release:check. It compares package.json with both versions
    in package-lock.json, the first release heading in this file, an optional
    tag, and the files npm pack --dry-run would publish. --release requires
    the CHANGELOG heading; --tag v<version> requires the tag. It is part of
    npm run selfcheck, runs in the test job without --release, and runs in
    the publish job with the pushed tag.

Fixed

  • CONTRIBUTING.md asked for two commits and two tags. npm version
    already makes both by default, and the steps after it made a second one. The
    release steps now use npm version --no-git-tag-version, verify the tree
    before committing, and tag once.
  • models.yml claimed a check it did not run. The scheduled job reads
    catalogue lifecycle; it cannot see a route that answers 200 with no text.
    The comment now says so and names eval/models.mjs --free --check.
  • README named doctor as the pre-release check. It is the online check.
    npm run selfcheck is the release gate, and the README now says which is
    which.

Documentation

  • MIGRATION.md covers 0.4.x → 0.7.x. The config file format survives, but
    the compiler now owns more keys: run is build + verify, --review exits 5
    on a rejected review, the build cap is 120, doc and verify no longer
    open bash with "*": "allow", denied tool calls are not retried, the
    reviewer moved off the retired nemotron-3-ultra-free, and doctor --check-models checks lifecycle rather than presence.

0.7.1

Choose a tag to compare

@pham-canh pham-canh released this 04 Nov 09:52

[0.7.1] — 2026-10-26

A release about checks that were green while the thing they check was not:
a withdrawn model reported healthy, a lane on a model that cannot do the
lane's job, a config from the previous kit reported as matching the current
profile, and a free route that answered nothing still recommended as a
candidate.

Fixed

  • doctor --check-models read presence, not lifecycle. models.dev keeps
    a withdrawn model and marks it deprecated; the check only asked whether a
    record existed, so a pulled base or fallback rung was reported healthy.
    It now asks isWithdrawn, and the message says withdrawn-or-removed.
  • A lane's route was never checked for the job it does. A live model that
    cannot call tools, a vision lane on a text-only model, a missing context
    or output ceiling, and an effort level the model cannot express all passed
    doctor. Each is now reported by lane, against the first live rung of the
    chain install would use. A level that snaps down is still allowed, because
    that is the documented behaviour; a level that resolves to null is not.
  • verify compared a hand-written key list. harness.kit had been added
    to the compiler and not to the list, so the live install - compiled by
    0.6.4, still carrying 25 ECC subagents - passed as matching the profile.
    The check now recompiles the profile over the installed file and compares
    every key the compiler owns. A config from an older kit is a note;
    verify --strict makes it a failure.
  • The probe could not tell an answer from a spent route. eval/models.mjs
    now classifies ok, empty, timeout and error, treats a finished step
    with no text as empty, and exits non-zero under --check.
  • A free route that answered nothing was still recommended. Two live
    probes of nemotron-3-ultra-free produced no step and no text. The route
    is recorded in eval/unusable-models.json; --free and research skip it
    until it is re-probed, and the standalone profile and its reviewer rung are
    retired. The reviewer lane now runs on GLM 5.3 Flash.

Added

  • eval/models.mjs --free --list selects live free routes without spending a
    request and names the ones a probe rejected.
  • eval/graph.mjs checks the import graph and prints the routing graph:
    --check fails on an unresolved import, a module cycle, or a source file no
    entry or test reaches; --routing prints profile -> lane -> model with the
    catalogue's verdict on each rung. --json and --dot are for a machine.
  • npm run graph, npm run test:coverage (85% lines, 70% branches, 80%
    functions), and npm run selfcheck, which runs build, typecheck, the suite,
    the graph, premises, and a fresh install in a temporary config directory
    ending in verify --strict.
  • test/effort.test.js covers the config mutation directly: the router's
    session model, a lane's preserved model and prompt, a null variant
    deleting a stale one, harness keys surviving, and health entries keyed by
    provider. test/trust.test.js covers a replacement that fails after the
    revoke and has to say the package now has no publisher.
  • CI runs graph, test:coverage and premises beside the suite, and the
    install smoke test uses verify --strict. A daily models.yml job asks the
    live catalogue whether every shipped model is still live.

Changed

  • fleet-safe and fleet-all are refreshed against the live catalogue:
    fleet-safe publishes three effort levels (low, high, max) and
    fleet-all no longer claims image attachments on a model that does not
    read them.
  • README and docs/ROUTING.md quote the current fleet: reviewer on GLM 5.3
    Flash, build and longform on Flint, and the seven lanes that move under the
    zero-retention ceiling.

0.7.0

Choose a tag to compare

@pham-canh pham-canh released this 04 Nov 09:51

[0.7.0] — 2026-10-25

oc-harness run now stops for the reasons it already claimed to stop for,
the read-only lanes no longer have a write-capable shell, and the token budget
counts the context a request reads instead of only its uncached part.

Fixed

  • A denied tool call was fed back as another turn, and the retry spent the
    window.
    experimental.continue_loop_on_deny was true, so opencode
    handed the guard's refusal back to the model and continued the loop. The
    measured session made 138 requests and 7,559,016 context tokens in 29
    minutes on six shared token window denials, each retry re-sending the
    whole prompt. The generated config now sets it to false, and the guard
    blocks a single request that re-sends more than OC_HARNESS_TURN_STOP
    (default 300k) with "do not retry".
  • The in-event shared-window stop did not refuse anything. When the
    step-finish sum crossed OC_HARNESS_BUDGET_WINDOW_STOP, the guard set
    windowSpent but never set windowWhy, so sharedWindowSpent() returned
    an empty reason and every tool call was allowed. The reason is set where
    the sum crosses, and the stop is written to the ledger with
    recordStop() so a new session cannot outlive the provider's window.
  • A corrupt ledger locked the machine for six hours, or vanished. It is
    now moved to budget.json.corrupt and the window starts empty; the broken
    bytes are kept as evidence. recordSpend() and recordStop() repair
    before writing instead of reading the corruption as an empty window.
  • The bundled ECC subagents were loaded on every request. Their
    descriptions came from prompts/agents/*.txt, were not lanes, and so were
    not covered by the stale-lane rule. They are removed from the generated
    agent map when that is the prompt, and named in the config header; a
    hand-written agent that reuses that prompt path is removed like the
    bundle's own, while any other prompt is left alone.
  • The token budget undercounted a cached session five to forty times, so it
    never fired.
    A step-finish part reports input, cache.read,
    cache.write, output and reasoning. The guard summed input alone -
    the part of the prompt that was not cached - while the cached prefix, which
    is what a long conversation actually re-reads, was ignored. One measured
    stream reported 844 uncached tokens against 36,480 cached ones on the same
    step, then 391 against 9,088. The 2M warn and 5M stop were therefore five
    to forty times the real spend, and the provider's window ran out before
    either fired. requestTokens() in src/budget.js now counts input + cache.read + cache.write for both the session total and the shared-window ledger; the
    toasts and refusals say "context tokens" because that is what they count.
  • The A/B's --budget had the same undercount. The suite cap summed
    inputTokens, so 120 runs reported about 1.3M of spend while their streams
    carried 7.1M. parseStream now also returns contextTokens, the cap and the
    report use it, and --rescore re-reads the old streams to put the corrected
    number on them. inputTokens is still recorded so a table can be compared
    with the ones written before this.
  • The test suite wrote to the real window ledger. guard-hook.test.js
    exercised the guard with the default OC_HARNESS_BUDGET_FILE, so every test
    run added its 1,500 and 600 tokens to
    ~/.local/state/opencode-harness-kit/budget.json - the live ledger showed
    twelve test entries and nothing else. The tests now point the ledger at
    their own temporary directory.
  • --rescore graded a timeout as a wrong answer. A run that hit the
    ceiling has a stream that stops mid-sentence, which reads exactly like an
    answer that cited nothing; only the sidecar knows which it was. Four runs
    that timed out at 12 steps were re-scored as four wrong answers, and the
    table then showed 18/23 where the honest count is 18/19.
  • A resume crashed the report on a sidecar from an older version. The
    re-score reads escaped, tools and text from every result; a sidecar
    written before those fields existed threw a TypeError after every run had
    already been paid for. Missing fields are read as empty, and the corrected
    token count is written back so a second resume does not depend on the stream
    still being there.
  • The A/B's preflight said "ok" to a run that had failed. It checked only
    the timeout and the quota, so a run that reported an error event and exited
    in three seconds passed. The first suite with that preflight spent eighteen
    runs learning that every kit-off arm had failed with
    ProviderModelNotFoundError, scored as "no output, not scored". It now
    reads the stream, and any error event stops the suite with exit 2 and the
    provider's own message. An exit 0 with zero steps and no text is the same
    shape - a spent route - and is refused the same way.
  • The kit-off arm could not resolve the model it was told to use. opencode
    keeps its model catalogue in ~/.cache/opencode/models.json, and the arm's
    temporary HOME had no cache, so a bare model: string was a model the
    installation had never heard of. The cache is opencode's, not the kit's, so
    it is symlinked into the temporary home the same way ~/.local/share/opencode
    already was.
  • An error in a measured run was counted as a wrong answer. A run that
    produced no tool call and no text, but did report an error, now stops the
    suite at once with that error instead of waiting for --fail-fast and then
    scoring the refusal.
  • The lane counter's "no telemetry" test failed on a machine that had one
    two directories up.
    The lookup walks up to the project root by design, so
    /tmp/.space/telemetry.jsonl - written by any opencode run started in
    /tmp - made it find a file and fail for a reason that was not the code's.
    The test now runs twelve levels down, past the walk-up's ceiling, so nothing
    above its own tree is looked at; the walk-up itself is unchanged.
  • The A/B was governed by the kit's own budget. The kit-on arm runs on the
    real config, so the guard's session and window thresholds applied to it: 120
    runs spend more than the window's stop, and from the run that crossed it the
    guard refused tool calls - every later run would be scored as a wrong answer
    for a reason the suite is not measuring. The suite now sets all four
    thresholds to 0 for its runs and points OC_HARNESS_BUDGET_FILE at the run
    directory, so a benchmark neither trips the guard nor charges the account's
    real window. The suite's own cap is --budget.
  • An empty plan reported success. A plan with no tasks printed
    "every task is done (0/0)" and exited 0. Nothing was done, so it now stops
    with exit 2 and says the plan has no tasks.
  • A blocked task did not stop the tasks after it. The loop marked the
    blocker and carried on, then reported it at the end. It now runs in file
    order and stops at the first blocked task, so pending work before the
    blocker still lands and work after it no longer builds on a failure.
  • The task file was written back from the copy read at the start. A
    human edit or an agent deletion made mid-run was overwritten, and a deleted
    task file was recreated. Write-back re-reads the file, refuses to write a
    stale copy, and goes through rename so a reader never sees half a plan.
  • A task was matched by title and position only. With two same-titled
    tasks, removing or renaming the first made the loop mark the second one
    done. Matching now uses title + change + files, and an ambiguous match
    stops the run instead of guessing.
  • verify: true and verify: echo ok were treated as checks. Both exit
    0 whatever the agent did. A verify line made only of no-ops now blocks the
    task before the agent runs; a no-op before a real command
    (true && npm test) is still accepted.
  • doc and verify opened their bash maps with "*": "allow". The
    read-only lanes could write through sed -i, awk or python3 -c
    regardless of their edit: "deny". doc now defaults to deny and verify
    defaults to ask, each with the commands its job actually needs.
  • A run that hit the lane's step cap reported only "verify failed". At the
    cap OpenCode exits 0 with a text-only answer, so the loop saw a failed
    check and blamed the change, while the log held the real reason. run now
    counts step_finish events in the transcript and, when the count reaches
    the role's configured cap, says so in the stop message and in the task's
    recorded output, with the setting to raise.
  • An agent that answered nothing was reported as a failed change. A spent
    model route shows up in one of two shapes. Some providers exit 0 with an
    empty stdout and the reason on stderr: the loop then ran the verify against
    an untouched tree and blocked the task for work the model never attempted.
    Others hang until the ceiling kills them, which at the default budget is two
    hours spent on one task with nothing to show for it.
    run now stops with exit 3 when stdout is empty without running the verify,
    and a timeout names the route and the limit instead of saying the agent
    "failed". The task is marked blocked either way, with the stderr and the
    advice in its output.
  • The A/B ground through a quota error as if it were an answer. The free
    tier can print {"type":"error"} with "Free usage limit reached" on stdout
    and exit 0; the suite read that as an empty stream and needed --fail-fast
    runs before stopping. It now stops on the first one with exit 2 and the
    provider's own words, because the refusal measures the provider and not the
    kit.
  • The kit-off arm made paid title calls. makeNokitHome pinned model
    but not small_model, so the title agent used opencode's default paid
    model. A real run made 1,073 title calls to gpt-5.4-nano; every one was
    refused for insufficient...
Read more

0.6.4

Choose a tag to compare

@pham-canh pham-canh released this 04 Nov 09:51

[0.6.4] — 2026-10-23

Fixed, each one found by re-reading what 0.6.3 published, not by running
anything new:

  • The install command in the README named a package that does not exist.
    The Install section said npx oc-harness init "from the registry", and
    oc-harness is this kit's binary name, not a package anyone can fetch: the
    command every new reader was pointed at returns npm error 404 'oc-harness' is not in this registry. Every install path in the README now reads
    npx -y opencode-harness-kit@latest <cmd>, bare oc-harness is defined
    once as shorthand for one of the two real forms, and a test pins every
    npx reference in the README to this package. Released because the npm
    page is a snapshot: the README on npmjs.com renders from the published
    tarball, so fixing it in git changes nothing for the next visitor.
  • profiles/index.json listed flint-40b-free twice, and the README's
    shipped-profiles table repeated it with a second, differently-worded
    note. oc-harness list printed twelve rows, oc-harness init offered
    twelve choices, flint twice in both, and the README counted twelve
    shipped profiles. Eleven profiles ship; one entry remains, carrying the
    honest note of both. Tests now diff the index, the table and the loader,
    with no Set to collapse the difference.
  • retention.yml repeated opencode/flint-40b-free, and the last key
    won.
    The hand-rolled parser overwrites models[id] on every repeat, so
    the vague 2026-10-22 stub silently replaced the 2026-10-23 record that
    quotes the provider's terms verbatim - same retention class, wrong date,
    lost detail. A test now scans the file for repeated keys.
  • install from npx symlinked into the npx cache. The installer always
    symlinked the plugin, prompts, skills and GLOBAL.md back to the package
    root - right from a git checkout ("edit here, live everywhere"), visible
    breakage from an npx cache that npm cache clean --force deletes. From a
    checkout nothing changes; from npx or any npm install, where .git is
    absent, install now copies, so the harness on disk does not dangle the
    day the cache is cleaned. verify and uninstall learn that a
    byte-identical copy of the kit's file is the kit's, and a test installs
    from a copy of the package with no .git into a temp HOME, asserts real
    files where links used to go, and runs verify green.

No runtime change: dist/, the plugin and every model-facing artifact are
byte-for-byte what 0.6.3 shipped.

0.6.3

Choose a tag to compare

@pham-canh pham-canh released this 04 Nov 09:50

[0.6.3] — 2026-10-23

Nothing here changes the runtime. The plugin, the CLI and dist/ are
byte-for-byte what 0.6.2 shipped; this release is the front page and the
packaging metadata catching up with decisions already made.

Removed

  • The demo media is gone from the repository. docs/demo/pitch.mp4
    (12.5 MB) and docs/demo-loop.gif are deleted, and the README no longer
    embeds them. The recording lives on in the private
    pham-canh/video repo. Two reasons
    it had to leave this one: the .mp4 was never shipped by npm (files
    covers docs/*.md only), so the README rendered on npmjs.com carried a
    <video> tag whose source could not exist — a 404 embed on the public
    page; and a repo whose pitch is "the metadata is the truth" was weighting
    its own checkout with twelve megabytes nobody could watch.

Fixed

  • The lockfile answered for a version two releases behind.
    package-lock.json still said 0.5.8 while package.json said 0.6.2,
    and carried a peerDependencies block the manifest no longer has. Both are
    synced now, by hand rather than a regenerating npm install, so the locked
    dependency versions are untouched.

0.6.2

Choose a tag to compare

@pham-canh pham-canh released this 04 Nov 09:50

[0.6.2] — 2026-10-23

Published. Tag v0.6.2.

Fixed

  • Transient catalogue errors stopped benching live routes. When
    oc-harness doctor or the router asked models.dev and the request failed
    for a reason other than "this model is withdrawn" — a timeout, a rate
    limit, a network blip — the failure was percolating into the route health
    as if the model itself were dead, and a live route got benched on evidence
    that was about the network, not the model. The distinction now matters:
    transient errors are retried and reported as transient; only a confirmed
    status: "deprecated" out of the catalogue marks a route unhealthy.