v0.23.0

Changed

• npm run release now accepts a package up to 35 MB (was 20 MB): the Go port made the four native binaries about 15 MB each, so the 0.23.0 package is 28.3 MB; the refusal reads published package must be under 35 MB (B605)
• block close runs in Go for late and cap rows whose file, finding or open id is an object or array (Node's [object Object] and joined text, or Node's arg.replaceAll is not a function error for a file it cannot quote) and for plain-text or Codex transcripts with JavaScript-only whitespace (NBSP, U+2028, BOM); before, these closes handed over to Node (close-gates-format, close-transcript-format). A routine close under a close:routine grant now prints Node's opened before warning once per gate load and joins every routine failure into the close-not-routine reason, byte-equal to Node (B590)
• block close runs in Go when a changed file matches review.exclude or the default lock-file list: the file leaves the review set, gets a gate.review_excluded row and a not reviewed line, and an npm lock gets Node's lock check and lockfile blocker; before, every such close handed over to Node (close-excluded-file). A lock shape Go cannot judge like Node hands over with the new reason close-lockfile-format (B587)
• block close runs in Go for a transcript that is not valid UTF-8 (decoded as Node does, each bad byte run one U+FFFD), a Claude Code log with an escaped surrogate pair, and agent waiver and reopen rows whose fields hold objects or arrays (--json prints them in the ledger line's key order); before, these closes handed over to Node (close-transcript-format, close-gates-format) (B583)
• Go reads the Node version when it runs (node --version once per process, CODE_FORGE_NODE else node on PATH), not the build machine's: error-log rows, the gate reuse stamp and the logs report Node line match the node that runs; logs report no longer hands over when no Node version is known and prints unknown (B585)
• facts with a Codex (openai) step in the levels.L0 ladder (first, as a fallback, or from a top-level provider: openai) now runs in Go byte-equal to Node instead of handing over: the read-only codex exec call in the snapshot, the packet on stdin, the OpenAI-strict schema file, the -o answer, the fallback moves on usage limit, 401, 503, timeout and exit, the answer checks, the sheet and the ledger rows; review.allow_open_book_codex does not change it, as in Node (B582)
• A fix-loop recheck with a block base runs in Go byte-equal to Node's packet builder for every peer case: one peer, several peers (named and imported kept, the rest dropped), a moved-code hint alone, a moved hint plus cross-file evidence, over the budget (the cut line, or no evidence), no peers and no base; worker --run <id> serves such a recheck of a .js file end to end with no hand-over row (B564)
• block ready no longer hands over to Node when the workspace path holds secret-like text such as eyJ, AKIA, AIza or sk- (a random temp folder name did this once on CI); like Node, it masks only the run's signer key, and output that would show that key still runs in Node (B565)
• Go no longer needs a node on PATH for context pack and cloud-coder: with no Node, the pack's ## code-forge line names the install's bin/code-forge launcher instead of refusing (with Node found, the pack bytes are unchanged), and cloud-coder runs review-file and ledger add coder in this Go binary instead of the Node router (B572)
• The Go binary is required: bin/code-forge no longer falls back to Node. With no binary for the platform and arch, a missing file or one without execute permission (and for setup, a binary that crashes), it prints one stderr message with <platform>-<arch>, the expected path and the fix (sh <package>/scripts/install.sh, then npm i -g @codedology/code-forge if that fails) and exits 69, a code no verb uses; CODE_FORGE_NATIVE=0 still runs the Node router. New scripts/install.sh (POSIX sh, shipped) checks the binary for this OS and processor, restores a lost execute bit, runs --version and internal version, compares the version with package.json and prints OK or the problem and one fix: line (exit 0 / 1); no network, no sudo, no postinstall (B569)
• npm run release runs no Node on the laptop: it builds the four native release targets with go build from Go (same targets, flags, temp name, mode and printed lines as scripts/build-native.mjs; the Node version stamp comes from node --version when a node is usable and stays unknown otherwise), and in place of the local gen-config-doc --check, gen-commands-doc --check, npm test and npm run typecheck it requires the latest CI run for HEAD to be completed with success, refusing before any write with one line naming HEAD and the run state; npm pack --dry-run, npm ls --json and claude plugin validate . still run; the --no-checks warning names the new list and the notes usage line names sh scripts/cf-release.sh release notes (B580)
• The Node release scripts are gone: scripts/release.mjs, release-site.mjs, docs-block.mjs and changelog.mjs and their Node tests are deleted, after every case those tests checked was ported to the Go tool's goldens (74 new multi-step cases recorded from Node); the GitHub release workflow sets up Go and writes the notes with sh scripts/cf-release.sh release notes (same bytes), and scripts/gen-site-data.mjs reads CHANGELOG sections itself with the same output; nothing changes in the npm package (B574)
• The maintainer release tools run in Go: npm run release, npm run release:site, npm run docs-block and npm run changelog build and run native/cmd/cf-release through scripts/cf-release.sh, with the same arguments, output, exit codes, file edits and git commands as the Node scripts, checked against goldens recorded from Node; the Node scripts stay because tests, the site data generator and the release workflow still use them, and nothing new ships in the npm package (B570)
• The native daemon's status no longer starts a Node helper: a block id outside printable ASCII is answered in Go when it is the one listed block or sits on a closed or stopped block (also for status and native-status); with two or more such listed blocks the daemon answers status-unreadable, as it did with no Node, and the status command computes the status itself (B576)
• The native rebuild in gates run and block rebase runs go build in Go instead of node scripts/build-native.mjs --host: same env, ldflags, <binary>.<pid>.tmp temp name, mode 755, rename and native-rebuild-failed text; it works with no Node on PATH, and then leaves the binary's Node version at unknown (B575)
• facts checks more glob path claims in Go, like Node's path.matchesGlob: braces ({a,b}, {1..3}), backslashes, [:ascii:] and [:xdigit:], extglob openers with no ) and non-ASCII text with Node's case folding. A Unicode POSIX class, an extglob that can close, a case-insensitive suffix with a sigma, a Codex L0 step (B551 is not on this base) and the gate's non-ISO dates (Node reads them in the local time zone) still hand over before any write (B577)
• block rebase that hands a narrow state to Node no longer prints an autopilot expiry warning twice: a failed grant expiry or an approval not restored yet is reported once, by Node's own check; a key or file read error in such a warning names no path, as Node's (B584)
• block rebase no longer starts a Node child: active and due autopilot approvals, run records with no orphans list, an odd sibling block or an unreadable config snapshot, falsy or invalid rebase_check values and a missing HOME run in Go with Node's output, run record and ledger rows; the few states Go cannot read hand over with a narrow named rebase-* reason before any write (B578)
• The Go worker, the daemon (internal serve) and every Go verb (review, block close, block land, gates, status, proof export and the rest) record each child they start in the run root's pid registry like Node's exec: pids/<pid>.json while it runs, the owner pid, start time and run id in its environment, the lazy root released at exit; stdout and exit codes do not change (B573)
• block open serves its former Node fallbacks in Go, byte-equal to Node: an empty proof.worktree.dir or base, --after statuses that are not text, claim rows whose path is not text, the signer key and ledger checks with no --level, brief loop, name-too-long and read errors, acceptance and pipeline YAML errors, pipeline and outcome read errors, no HOME and block ids such as __proto__; YAML forms Go does not reproduce, AJV schema wording, a torn ledger line, a failed home lookup and an unresolvable brief path hand over before any write under the new reasons open-acceptance-yaml, open-pipeline-form, open-outcome-form, open-level-ledger, open-home-lookup and open-brief-cwd; Go's ELOOP and ENAMETOOLONG texts are libuv's, as Node prints them (B581)
• CI on Linux is green again: the tools and init rows follow a platform seam, so the init wizard test replays its Mac golden (Homebrew hints, Solo.app) on Linux too; the block close fake reviewer writes its result file then renames it, like the worker, so close never reads a half-written result; the Jev triage test waits for its fake server before it reads the requests (the race detector caught the bare read); the 25 ms Go hand-over check reports its number on CI runners instead of failing, because the same binary measured 10 to 63 ms there, and local runs keep the gate (B560).
• A Go worker that hands its run to Node keeps the queue served while Node starts: it leaves a hand-over announcement that review-file --wait reads as live and Node's boot prunes, so a waiting review no longer ends worker_down during the hand-over (B561)
• Go doctor records each child it starts (CLI probes, pings and probe ses...

v0.22.1

Added

• run status, run end and run start --reattach (with or without --worker-pid) run in Go with the same output, exit codes, run record, mirror and signed ledger rows as Node, as do run help, usage errors and unknown flags; a plain run start, run start --add-worker and run reload still hand over to Node with their own reason (B454)
• gates run runs in Go for every form Node completes: a run with no --run and no --block, custom, kind and formatter gates (pint and prettier in argv batches), repeat_new_tests with changed sources, JS Number forms of --timeout-ms (0x, 0o, 0b, exponent), unknown flags, no HOME (the user's home folder), a --timeout-ms over the timer limit (1 ms timer and Node's warning), an empty --run or --block and a missing --cwd, all as Node; a bad gate config stops with one stderr line that names the cause and the fix; only a run record with a mismatched run_id or no workspace still hands over; a command that cannot start is a red spawn-error gate; the block land gates step and the batch land preflight run the same Go path (B450)
• block open, block claim, block stop, block close and block land no longer hand over to Node: help, unknown flags, errors and the error log run in Go, block close checks light limits in Go, and every other case Go does not serve exits 1 with one block <sub>: refused: <cause> (<code>); <fix> line and writes nothing; only the land gates step still hands over (B450) (B451)
• block open, block claim, block stop, block close and block land serve help, unknown flags, errors and the error log in Go; block close checks light limits in Go, reads only the closing block's rows (another block's rows no longer hand the close to Node) and prints Node's detail for a rule_break row whose id is not text; no case is refused, and the cases Go does not serve yet still hand over to Node (B466 ports them) (B451)
• npm run release:site — after npm publish, waits until npm serves the version, builds the site data in an
  isolated worktree of the site repo, runs every site gate, commits only src/data/site-data.json on
  release-site/v<version> and deploys; a red gate deploys nothing; --dry-run stops before commit and deploy (B315)

Fixed

• gates run hands a gate command that is an executable file with no #! line to Node again (Node runs it with /bin/sh on Linux and refuses it on macOS; Go had shown a red spawn-error gate); context pack names node on PATH in the pack header when CODE_FORGE_NODE does not resolve, as before B452, instead of refusing; the Go test for gates run with no HOME no longer writes ~/.code-forge/queue in the real home; the Node parity tests now check the B449–B452 Go forms against Node instead of expecting a hand-over (B469)
• status, review-file, context: fewer Node hand-overs — Go runs every context form, status for array run records, an infinite spend and broken run files, and the review-file enqueue worktree and run-record-unreadable refusals; Node stays only for a non-ASCII block id in status and a few review-file states Go cannot read (B452)
• block rebase runs in Go in every form (--help, closed and awaiting blocks, --head, --accept-changed, --accept-landed), and block ready runs in Go with hooks.on_block_end and with close.require_human under an active autopilot grant; only run state Go does not expect still hands over to Node (B449)
• The config and command references now describe the merge gate as it runs: gates.merge_gate runs the Go test selection for the merge, never the full suite, reuses a green gate on the same tree (gate_reused) and is always on in a batch; block land usage lists --push, --watch-ci, --copy-links and batch land, and gates run usage lists --full, --preflight and --no-preflight (B444)
• npm run release:site deploys the merged site folder docs-site/site/.pages-out (marketing pages plus /docs)
  instead of dist, which has no /docs; --deploy-dir <path> picks another folder inside the site root, and a
  missing folder or index.html after the gates stops before commit and deploy (B446)
• block land output no longer says the merge gate runs the full suite: --no-merge-gate warns merge gate skipped; the merged tree was not checked, a batch refuses it with a batch always runs the merge gate; --no-merge-gate is refused, a red gate stops with tests failed: and a missing test command with test gate unavailable: configure gates.test before merging; help lists every block land flag and batch land (B447)
• code-forge ci watch survives the GitHub API rate limit: a rate-limit reply is never a CI result; it waits until the reset from gh api rate_limit (else backs off 60 s doubling to 15 min), prints ci watch: GitHub API rate limit; retry at HH:MM UTC per wait, and past --timeout exits 4 with rate limit, gave up instead of a failure; polling stays at one call per 30 s, and a second watch for the same repo and commit exits 0 without starting (B448)

npm: https://www.npmjs.com/package/@codedology/code-forge/v/0.22.1
Full changelog: https://github.com/ricardov03/code-forge/blob/v0.22.1/CHANGELOG.md

v0.22.0

Added

• gates.merge_gate_links — repository-relative git-ignored paths (for example local.properties,
  app/google-services.json) are linked from the main checkout into the temporary merge-gate tree before setup; each
  link must stay under the repository root. A retried land merges only the closed block head (B343b)
• block open --allow-api-mismatch — block open (Go) checks the brief's uses/extends lines against the code
  (api-fit). A missing name or parameter exits 2 with an api-fit: line; --allow-api-mismatch opens anyway and prints
  each line as a note (B338)
• code-forge cloud-coder --run <r> --block <id> (Go) — runs a cloud coder from config coder.cloud (submit, then
  fetch until a patch or timeout), applies the patch to the block's owned files only and queues review; a patch fetched
  at the deadline still lands (B342)
• code-forge report has a pace section: per-block and run pace in minutes; text, --json and --export carry the
  same 18 sections (B341, B358)
• heal queue: gates run, block rebase and block land queue a failure that passes by itself (a held lock, a transient git
  error) in ~/.code-forge/heal/.jsonl and print heal: queued ; code-forge heal list|show|run retries each item
  with backoff (15 s, 60 s, 240 s), removes a lock whose owner pid is dead, and marks needs_coder after --max-tries
  (B429)
• Main first: block land --push (or land.push: true) pushes main after the merge; a rejected push queues a heal item
  of kind land (argv block land <ids> --run <r> --merge --push; already landed blocks only push) and exits 1; --watch-ci starts a detached code-forge ci watch, a new Go verb that follows the
  commit's GitHub Actions runs and queues a heal item of kind ci naming the failing jobs, tests and block ids (B430)
• Under an active autopilot grant an agent may run block close --decide without a terminal for transcript rule_break
  hits and warning/nit findings; criticals stay with the owner; each decision is a signed close.decision row shown by
  the new code-forge decisions list (B390)

Changed

• the skill's block land text no longer says the merge gate runs the full suite: it uses the Go test selection
  (B404); new skill/references/code.md §5.1 tells the orchestrator how to use the changed-test selection, preflight,
  close review wait, Go rebase replay, batch land, --push/--watch-ci, the heal queue and the machine test queue,
  with pointer lines in SKILL.md (B443)
• native block close queues a review for each changed owned file that has no review (also after an acceptance
  amendment), waits once for all of them (review.close_wait_s, default 600), then stops with not_approved or
  review_pending; close never approves a file itself (B339)
• A Go verb that holds the run lock writes an owner file (pid, start token, verb) in <run>.lock and removes it on release; a waiting Go verb breaks a lock whose owner process is gone or replaced (or, with no owner file, that is older than 10 minutes) once, logs broke stale run lock (pid N) and takes it, so a crashed holder no longer blocks every verb until a human removes the dir; a lock with a live owner is never broken (B423)
• block land (Go) no longer stops with "land stopped at join: reviews did not finish" when a loaded machine misses the run daemon's fixed 2 s connect/ping deadline: the review join asks the daemon again until land's own --max deadline (then wait_timeout); a dead daemon (connect refused, connection closed, invalid answer) still stops the join at once with the same message (B417)
• block close and block ready (Go) check the code-forge-runs-access transcript rule themselves instead of handing any transcript with .code-forge text to Node: plain-text logs and Claude Code JSONL logs get the same hits as Node after B415 (a Read/Bash/Glob/write-tool path or command word naming the run records, absolute or home-relative, hits; a heredoc body or quoted echo text a command only writes to a file does not; .code-forge.yml does not). Go also decides the git/gh/rm and code-forge launcher rules, sh -c wrappers, interpreter scripts and non-ASCII text, so a coder-forge path or forge/r-… branch name no longer hands over; only Codex logs, .code-forge/reviews and .code-forge/queue text, invalid UTF-8, lone surrogates and JavaScript-only line separators still hand over (B416)
• Go gate children start at nice 10 (or the engine's higher nice) before their own code runs: the engine starts each gate through a short copy of itself that sets its own nice and then execs the gate program with the same argv, environment and spawn errors. Before, the engine lowered the child after start, and on macOS that change could be lost while the child was still starting, leaving a gate (and the nice test) at nice 0 (B420)
• gates run --changed and the block land --merge and batch-land merge gates (Go) run only real test files (*.test.*, *.spec.*, *_test.go, *Test.php, test_*.py, *_test.py, *Tests.swift): a changed helper, fixture or script under test/ is no longer run as a test or picked as a stem-paired test, and selects the tests that import it or name it by path instead. The owned-file test fallback, the no-JS changed scope and repeat_new_tests skip such files the same way (B394)
• gates run --changed and the land gates select the CLI tests for a change to any verb module: Go's import graph counts bin/code-forge.mjs as importing every src/cli/*.mjs its router loads by readdir, and bin/code-forge as importing the entry (a change to src/cli/version.mjs selected 0 tests before) (B373c)
• gates run (Go, every mode: --changed, full, block land and batch merge gates) runs lint, types and format before the test gate. When one of them is red the test command never starts: its entry stays in the result (same order) with skipped: true, ok: false, reason: pre_gate_failed and pre_gates_failed naming the red gates, gate.done records the same reason, and the exit code stays 1, so two type errors no longer cost a 12-minute suite first (B418)
• block land <id> --merge skips the merge-gate run when the merged tree equals the clean tree the block's last green gate ran on and that gate covered the merge selection: merge gate: reused green gate on tree <id> (gate_reused), merge_gate_reason: gate_reused in land.timing and the --json landed event; a block on an older base still runs it. gate.done rows from a block worktree record the tree they ran on (B393)
• Batch block land <id> <id>... (Go) runs git merge-tree --write-tree for every block against the running result before any rebase, gate or suite. A block that would conflict is parked with reason block_rebase_conflict and its conflicting files (--json event: parked, land.batch parked); the other blocks still gate and land. When every block conflicts, nothing lands and land exits 1 naming each block (B397)
• Go tests that build a fixture repo (gates run, gates go-only scope, review-file --wait/--wait-block, review wait-block, status direct) run fixture git in the fixture repo without inherited GIT_* variables and start their code-forge children without them, so a GIT_DIR, GIT_INDEX_FILE or GIT_WORK_TREE from a hook or worktree no longer breaks them; a guard test reruns them with those variables set (B410)
• Go tests in native/gates, native/blockops, native/blockopen and native/gatecheck run fixture git with the fixture repo as the directory and gitx.ChildEnv() (no inherited GIT_*), with a guard test that reruns them under GIT_DIR/GIT_INDEX_FILE/GIT_WORK_TREE pointing nowhere; cloud-coder takes its deadline from a replaceable cloudDeadline, so the fetch-timeout test expires after two polls instead of 2 s of wall time and no longer fails on a loaded machine (B411)
• gates run --run R --block B --changed (Go) selects its tests in Go and never runs or hands over to the full Node suite: the block's tests, owned and changed tests and the stem-paired tests of changed sources (any language), every test that imports a changed file (static and dynamic imports, require, new URL, path mentions anywhere in the closure, imports of deleted files), for a native change test/compat/go.test.mjs, the compat tests named after the Go files and every test that builds or runs the native binary (B330), and the config golden test for a fixture, schema or src/config/ change (B409). A changed test the runner cannot take is dropped, never widened; an empty selection skips the test gate. The reason is go_only or import_graph. The block land --merge merge gate and the batch-land merge gate use the same selection (merge gate: scoped tests passed (...) for --merge) instead of the full suite; a test command without {test_files} gets the selection appended and never runs unscoped; go.test.mjs runs only for a native change. gates run --run R --block B --full is the only local full suite (scope: full, reason: explicit) (B404)
• In a code-forge worktree, block rebase rebuilds the worktree's native binary (node scripts/build-native.mjs --host) when the rebase brings a change to native/** or scripts/build-native.mjs, and gates run --run --block rebuilds it before any gate when it is missing or older than native/go.mod or a non-test native/**/*.go file (the gate JSON shows native_rebuilt: true). A failed build exits 1 naming native-rebuild-failed; the gate then runs nothing. Compat tests no longer run a binary built on the old base (B408)
• The close transcript check no longer counts a ~/.code-forge/runs path that a coder only writes as text: the body of a cat > file <<'EOF' or tee file heredoc (not piped on, no shell substitution) and quoted echo/printf arguments written into plans/ give no code-forge-runs-access hit. Real access still does: cat/ls/cd/< on the path, a...

v0.21.0

Added

• npm run docs-block writes the docs brief for a release and stamps docs/release-docs.json when the docs block ends. npm run release refuses when the docs stamp is not current (B312)
• node scripts/gen-site-data.mjs --tag vX.Y.Z exports release notes and commands from the tag for a local website update. It exports only run, completed-block and spend totals from the local ledger. The same tag and ledger inputs give the same JSON (B313)

Changed

• block land does not run the full test suite again in the merge gate when the merged tree is the same as a tree that already had a green full run. It prints the reused tree id and records it on the land.timing row (B317)

Fixed

• A review that asked for a file the policy refuses now goes on to round 2 with the refusal line, instead of stopping as unavailable. The worker's review ledger row keeps only the needs_file diagnostics, never finding text (B311, #33)
• parity-gates-custom no longer fails at random under load: the test writes its fixture files completely before the Go engine reads them (B309)

npm: https://www.npmjs.com/package/@codedology/code-forge/v/0.21.0
Full changelog: https://github.com/ricardov03/code-forge/blob/v0.21.0/CHANGELOG.md

v0.20.0

Added

• The Go engine records each hand-over to Node in ~/.code-forge/native/handovers.jsonl: the command, the known subcommand and a reason code. Unknown words are stored as unknown, never as typed. Set CODE_FORGE_HANDOVER_LOG=0 to turn it off (B282)

Changed

• More commands run fully in Go, with the same output and exit codes as Node. docs/native-engine.md lists the few cases that still hand over. These cases no longer hand over to Node:
  • block close with --auto-claim, --remove-worktree and --no-require-reviews (B283), and with external review (B284)
  • hooks.on_block_end on block claim, stop and close (B284)
  • active autopilot grants on block claim, stop, open and close (B285)
  • block open with --after, --after-outcome and no --level (B286)
  • block ready, block waive and block reopen (B287)
  • review-file with --fresh, --answers, --of, --rebase-check and a cached result that needs a fresh ticket (B288)
  • gates run with custom gates, repeat_new_tests, light blocks and flaky detection (B289)
  • context pack (B290)
  • block land with plain, --merge, --no-merge-gate, grant and hook shapes (B291, B307)
  • block close --decide, block human close and block human-pass (B292)

Fixed

• npm run bench:block counts every command it starts, so the process count no longer drops below the number of runs when fast Go commands end between two samples. This made CI fail on Linux (B297)
• A review recheck and the agent waiver judge now see the block's other changed files that a finding names or calls. The context is bounded and recorded. Before, a fix in another file of the block was not seen (B280, B306)
• gates run --changed keeps its scope after a rebase when the base move is safe, so one block no longer runs the full suite twice. It resets the scope when the base move is not safe and records the real fallback reason. A change in Go code now selects the affected parity tests (B294, B305)
• gates run --changed no longer passes Go _test.go files to the Node test runner. Before, every Go-only block failed to land (B301)
• A reviewer that times out twice on the same file now falls back once to another configured model, chosen by measured speed and accuracy. run reload now applies review-only keys when frozen keys differ, keeps the frozen keys and prints their names (B296)
• block rebase --accept-landed no longer deadlocks on the run lock, shows the Go error, leaves no lock after a refusal and no longer replays the commits of an earlier block (B299)
• A stopping worker no longer creates a removed HOME again (B303)
• The merge gate of block land now runs in the right folder when the workspace path goes through a symlink, in Node and in Go (B307)
• Tests no longer fail on a busy machine because of wall-clock limits (B300, B302)

npm: https://www.npmjs.com/package/@codedology/code-forge/v/0.20.0
Full changelog: https://github.com/ricardov03/code-forge/blob/v0.20.0/CHANGELOG.md

v0.19.1

Fixed

• code-forge init asks for a level again when the answer is unreadable, is empty, or repeats the provider, model and effort of an earlier level, the L3 judge included. Before, init went to the end and stopped with "the resulting config is invalid, nothing written" (#31, B281)
• The forbidden-command scan reads Codex coder logs again when they start with the plain "Reading additional input from stdin..." banner. The coder's stderr now goes to session.err.log. Before, the banner switched the scan to plain text: brief text in command output gave false hits, and a real git stash inside an escaped shell command was missed (#32, B293)

npm: https://www.npmjs.com/package/@codedology/code-forge/v/0.19.1
Full changelog: https://github.com/ricardov03/code-forge/blob/v0.19.1/CHANGELOG.md

v0.19.0

Added

• Go write kit: file locks, signed ledger rows and atomic state writes with the same bytes and lock rules as Node. No public verb (B272)
• Go runs every status form (status, --json, --run <id>) directly from disk, with no daemon and no lock; unreadable or unknown state hands over to Node (B273)
• Go runs review-file <file> --block <id> (plain enqueue); --fresh, --answers, --of, --rebase-check and fresh-ticket cases hand over to Node (B274)
• Go runs block claim and block stop; autopilot grants, pending approvals and hooks.on_block_end hand over to Node (B275)
• Go runs block open with an explicit --level, including worktree creation; no --level, --after/--after-outcome and autopilot cases hand over to Node (B276)
• Go runs the plain agent block close; --decide, --no-require-reviews, --auto-claim, --remove-worktree, ready, human-close, external reviewer, hooks and autopilot cases hand over to Node (B277)
• Go runs gates run for built-in gates, with the same rows on cancel (SIGINT/SIGTERM); custom gates, repeat_new_tests, light blocks, flaky detection and other gates subcommands hand over to Node (B278)
• Go runs block land (join, gates, close, merge) when every step can run in Go; it checks this before any write, so one land never mixes Go and Node steps (B279)

Fixed

• block claim in Go resolves symbolic links in the workspace path before it checks overlap (B279)

npm: https://www.npmjs.com/package/@codedology/code-forge/v/0.19.0
Full changelog: https://github.com/ricardov03/code-forge/blob/v0.19.0/CHANGELOG.md

v0.18.0

Added

• Go runs logs path, logs [--last] [--json] and logs summary; logs clear and logs report hand over to Node (B247)
• Go runs ledger tail; other ledger commands hand over to Node (B248)
• Go runs review-file --wait <ticket> (B266), and review-file --wait-block through the daemon; stopped files and unusual answers hand over to Node, which writes all signed rows (B267)
• Go runs status --json --run <id> through the daemon client native/daemonclient, with Node fallback (B268)
• npm run bench:verbs compares Node and Go per verb (time, memory, output parity, leftover processes); bench:block adds the Go-first entry lane (B265)

Changed

• Land gates run only the tests the block changed or affects; the full suite runs once per wave (B269)
• block close finds the final approved review tickets in the ledger, so a report needs no hand ticket lines (B270)

Fixed

• The CI timing check "Go handover budget rejects a 40 ms delay" no longer fails on a busy machine (B271)

npm: https://www.npmjs.com/package/@codedology/code-forge/v/0.18.0
Full changelog: https://github.com/ricardov03/code-forge/blob/v0.18.0/CHANGELOG.md

v0.17.0

Added

• Go config loader (native/config, yaml.v3 pinned and vendored): reads .code-forge.yml with the same defaults, schema checks and error lines as the Node loader, checked byte for byte against goldens made by Node (B243)
• Per-verb parity harness: runs each ported verb in Node and in Go on isolated copies of the same state, and compares output and state files field by field (B244)
• code-forge <verb> --help for every verb, and a generated command reference docs/reference/commands.md (checked by scripts/gen-commands-doc.mjs --check); a test fails when a doc names a verb that does not exist (B251)
• The test gate reruns only the failing test files once, one at a time; a pass on rerun makes the gate green and marks those files flaky in status and report. Set gates.rerun_failed: 0 to turn it off (B255)
• docs/step-by-step.md: the whole project workflow, step by step, from install to release (B252)

Changed

• npm code-forge starts the Go binary; unported verbs go to Node; native internal verbs are under internal (B242)
• On macOS, npm test runs the suite in a sandbox that blocks writes to the real ~/.code-forge and $TMPDIR/code-forge, so a leak fails at once and other runs on the machine cannot cause false leaks; it prints leak guard: sandbox or leak guard: snapshot (<reason>) (B254)
• The docs explain the Go entry and the Node fallback: docs/getting-started.md, docs/how-it-works.md, docs/native-engine.md (B253)

Fixed

• A review of a Go file now lists the other Go files of the same package and shows the bodies of the functions its changed lines call, so a reviewer no longer reports a function in a sibling file as missing (B245)
• The test leak check ignores short-lived lock files and live-run control writes made by other code-forge runs on the same machine, fails closed when a process probe errors, and tracks children started with spawnSync/execFileSync, so gates no longer fail on false leaks (B246)
• The leak check ignores atomic temp files of other processes and temp files that vanish during the scan (B250)
• The leak check now sees that a lock file belongs to another live code-forge run on days 1-9 of a month (ps pads the date with two spaces), and retries a busy process check before it reports a leak (B258)
• The Go config goldens no longer hold the package version, so a version bump in npm run release no longer fails its own test step (B262)
• The Go entry speed test compares the Go start with a matched Node start in pairs, so a busy machine no longer fails it; the 25 ms budget is unchanged (B257)
• npm run release now also bumps the version pins in docs/step-by-step.md, and when npm test fails it lists the failing test names and saves the full log to .code-forge-tmp/release-npm-test-*.log (B263)
• A file rerun after a failed gate now finds test names whose duration has a space before the unit, such as (12.5 ms) (B259)
• The coder command check no longer flags spawn words that are only data inside a Python json.loads(...) literal; a dynamic lookup such as getattr or __import__ keeps the check on (B256)

npm: https://www.npmjs.com/package/@codedology/code-forge/v/0.17.0
Full changelog: https://github.com/ricardov03/code-forge/blob/v0.17.0/CHANGELOG.md

v0.16.3

Added

• review.silence_timeout_s (default 60): a reviewer or judge session that prints nothing for this long is killed and counts as a timeout (B206, landed as B240)

Changed

• A review answer with passed: null and findings is read as a failing review with its findings kept; with no findings it is unavailable (schema) and the fallback model reviews the file (B206, landed as B240)

• After a timeout, a silence kill or an at-capacity answer, the next fallback model runs at once instead of a second try of the same model; without a fallback list the old single retry stays (B206, landed as B240)

• CI also runs on a push to a ci-check-* branch and by hand (workflow_dispatch), so the pre-release check really runs before main moves (B239)

• The queue and parallel review tests check order and state with an injected clock, not short wall-clock deadlines, so they pass on a busy machine (B216, landed as B241)

npm: https://www.npmjs.com/package/@codedology/code-forge/v/0.16.3
Full changelog: https://github.com/ricardov03/code-forge/blob/v0.16.3/CHANGELOG.md