Skip to content

Releases

v0.6.1 — the SQLite-switch patch

Choose a tag to compare

@Acfufu Acfufu released this 23 Oct 22:44

Highlights

  • Migration fixed on real-world ledgers (0.6.0 regression, found by
    dogfooding the migration on this repo's own ledger): ledgers whose
    budget events carry object-shaped provenance (the review-runner
    shape) crashed the import phase with
    Provided value cannot be bound to SQLite parameter 5, and the read
    side could never reconcile either. The TEXT-column convention is now
    unified with the append facade — objects/arrays stringify on write
    and restore on read; bare strings and "123"/"true"-style literals are
    untouched.
  • Named refusal for missing dedupKey at both budget-event write
    entry points (dedup_key is NOT NULL — the schema is the gate,
    replacing a cryptic bind error).
  • Plan-gate word-boundary fix: an identifier containing "tbd"
    (e.g. a random temp-dir suffix like vqlTbd) no longer false-flags
    plan adoption as an undecided marker.
  • Test/fixture isolation for the usage ledger:
    sandboxUsageDir() honors LZY_SANDBOX_USAGE_DIR (production
    default unchanged), and six test files now run isolated so fx.*
    fixtures stop writing rows and retry receipts into the real
    ~/.zcode/cli/lzy-usage.

Verification

966/966 tests; CI four legs green (node 24 × ubuntu/windows +
sqlite-floor + docs-links). win32 coverage via the CI windows leg — the
0.6.1 delta is platform-neutral JS; the 0.6.0 VM battery remains the
platform baseline.

Upgrade

lzy update (0.0.7+). Requires the ZCode desktop app (logged in),
Node ≥ 24 (raised in 0.6.0 — ADR-0039), and git. Workspaces on the
JSON backend keep working; migration to SQLite stays an explicit,
one-way lzy migrate sqlite <root>.

0.6.0 — SQLite switch release

Choose a tag to compare

@Acfufu Acfufu released this 23 Oct 19:18

The SQLite switch release. Goal-loop queue/budget/ledger state moves from loose JSON files to a single state.sqlite (node:sqlite, zero new dependencies) behind an explicit, one-way migration — plus the P4 review fixes and real-platform validation that gate the switch.

Highlights

  • lzy migrate sqlite <root> — explicit JSON→SQLite migration (backup → import → reconcile → atomic install → backend-marker commit; idempotent resume; never overwrites an existing DB).
  • Single-authority read gate — once migrated, the DB is authoritative; missing-DB and unrecognized-marker shapes get named diagnostics instead of silent JSON fallback.
  • Legacy-JSON miswrite detection — post-freeze writes (including the frozen=null family) are refused with a delete-and-retry self-heal path.
  • lzy doctor sqlite-store row — five-state observability; new workspaces still start on JSON (migration is always explicit).
  • Runtime floor: Node ≥ 24.0.0 — enforced by engines >=24; the Node 22 line is out of the support surface.
  • P4 fixes — migration micro-window kill re-entry re-anchoring, hook marker-shape gate alignment, doctor attribution split, probe script PATH/pipefail seams, TZ pinning in tests.

Coverage boundary

  • macOS host real-CLI battery: 29/29 (dispatch kill recovery, concurrency, migration interrupts/drift/corruption, hook paths, budget retention, backup-replay, engine 0.17.0 surface).
  • Windows 11 aarch64 VM: 10/10 (Node 22→24 in-place, NTFS migration chain, WAL converge + integrity ok, hook stdin legs, doctor).
  • Known warts recorded, not fixed: backup-replay same-dir rerun fails at VACUUM INTO (guard only checks state.sqlite).

Upgrade

npm i -g lazyzcode@0.6.0
lzy --version   # 0.6.0(插件载荷同版本)

Requires Node ≥ 24. Existing workspaces keep working unchanged; run lzy migrate sqlite <workspace> to switch a workspace to the SQLite store.

v0.5.0 — the closeout-honesty release

Choose a tag to compare

@Acfufu Acfufu released this 10 Oct 03:14

Highlights

  • Degraded stops are now named, not silent (ADR-0037, decision #47). When an
    unattended goal loop cannot honestly finish, it winds down through a named
    closeout (handoff + honest report) instead of vague abandonment, and every
    wind-down cause is tallied into metrics.json — surfaced as a new
    handoff-causes row in lzy status --json / lzy doctor --json.
  • Paid reviews stop burning unchosen providers. Isolated-HOME review
    sessions previously inherited any enabled+keyed host provider, so a leg-set
    change could silently route spend to a metered provider (a four-day
    unnoticed burn, caught in reconciliation). Provider selection is now an
    explicit allowlist (LZY_SANDBOX_PROVIDERS or
    ~/.zcode/cli/lzy-sandbox-providers, line/comma-separated, # comments);
    an empty allowlist fails closed before any spend. Each paid run also
    appends one line to a user-private usage ledger
    (~/.zcode/cli/lzy-usage/YYYY-MM.jsonl) so the bill reconciles by
    construction — both faces declared in SECURITY.md.
  • Verify receipts carry their environment: effective timezone + toolchain
    axes join the receipt fingerprint, with a per-leg legs[] list (skip
    counts and names readable straight off the receipt).
  • Hygiene: hook launcher failure logs moved to user-private directories
    (~/.cache/lzy-hook/ POSIX / %APPDATA%\lzy-hook\ Windows — no more
    world-writable shared /tmp write point); lzy loop drive --mode default
    (yolo) is now stated in the CLI usage text and the zw unattended recipe.

Evaluation note (honest)

0.5.0 was re-evaluated against 0.4.1 in a preregistered paired batch (fresh
sealed task set, 18 pairs × 3 trials, candidate frozen before the batch). The
preregistered main gate returned no quality-benefit evidence: oracle
outcomes 18/18 flat between arms, points +36%, zero strict improvements.
Per ADR-0034 this release ships the code — named closeouts, observability,
spend control — without an adoption or superiority claim; the 0.4.1
operating defaults stand. Full report: docs/spikes/v050-m3-report.md.

Coverage boundary

Live evidence covers macOS/arm64, single machine, engine 0.16.9 (the M3
batch ran there; win32 re-test pending, tracked in the release checklist).
The contract suite (819 tests) runs on node 22/24 × ubuntu/windows in CI,
docs-links job green.

Upgrade

From 0.4.x: lzy update (spawns a fresh child process to deploy the new
plugin payload). From older versions: manual two-step
(npm i -g lazyzcode && lzy install). Requires the ZCode desktop app
(logged in), Node ≥ 22, git.

v0.4.1 — 编排纪律四件

Choose a tag to compare

@Acfufu Acfufu released this 02 Oct 17:42

编排纪律四件(决策 #43–#46,goal orch-discipline·LOOP_COMPLETE 12/12·对照 5/5 MATCH·双职责评审 pass):

  • 执行图单源核心 core/graph.js:deps 校验/就绪谓词/关键路径唯一权威;drive --workers 波分派按关键路径优先
  • 异议原语 lzy finding contest/adjudicate:open→contested 书面异议→同职责复判裁决;recheck --contested 注入异议书
  • 观察面 JSON 契约 lzy status/doctor --json(schemaVersion 1 只增不改)
  • 双图视图 lzy loop graph:执行图×失效 DAG 证据现行性

全 additive 无 breaking;759/759 契约测试绿。详见 CHANGELOG。

v0.4.0 — policy engineering: review runner, findings, scope reuse, migration apply

Choose a tag to compare

@Acfufu Acfufu released this 30 Sep 01:36

Highlights

0.4.0 is the policy-engineering release: the discipline layer learns to prove itself.

  • Controlled independent review runner (lzy review run|list|show): real isolated review sessions against your goal — facts-only input package, candidate snapshot, isolated HOME, sealed raw output, per-session subledger metering. Exit-code contract 0/1/2/3.
  • Finding lifecycle (.lazyzcode/findings/, loop-external): blocking findings land in a checksummed ledger, block the unified gate until closed through the single channel — resolve-request → review recheck → finding close. Two invalid fix cycles demand a root-cause diagnosis. Renamed goals stay chained (finding relink).
  • Obligation reassessment (lzy policy reassess): an extra obligation whose generating condition disappeared can be cancelled with a three-part independent rationale — baseline and tier-floor obligations are refused.
  • Review scope qualification & reuse: declare a review's scope, get adversarially challenged across ten axes, and let an untouched candidate reuse the earlier review (review qualify / review reuse). Closure bases are audited for applicability; finding reopen is the controlled re-entry.
  • Migration apply end-to-end (lzy migrate apply): backup → stage → verify → atomic switch with a phase journal — a kill at any phase resumes idempotently; STATE_VERSION 0.4.0, older states stay readable.
  • Paired evaluation harness (scripts/evaluation/run-pairs.mjs): sealed tasks × baseline/candidate arms × 3 trials with interruption+resume legs and an independent sealed oracle — the 0.4.0 batch report is at docs/reviews/v040-policy-evaluation.md (honest reading: quality gate not met; adoption deferred to 0.5.0 re-evaluation, decision #42 / ADR-0034).
  • Docs link checker + CI docs job, structural-axis real drift injection, gate reuse env axis, fixture materialization containment + symlink-faithful copies.

Coverage boundary

Live evidence covers arm64 (macOS host, Parallels Windows 11 aarch64 VM per prior releases; CI matrix ubuntu/windows × node 22/24 for the test suite). The paired evaluation ran three real repositories (lazyzcode / openchamber / zpigeon-ios) on darwin; oracle check-2 of the lazyzcode leg carries a disclosed Node ≥22 glob-semantics limitation (threat boundary in the report). sqlite3 remains an optional dependency: metering reads degrade to absent with named notes, and review preflight refuses cleanly when absent.

Upgrade

From 0.3.x: lzy update (or npm i -g lazyzcode@0.4.0). Requires the ZCode desktop app (logged in), Node ≥ 22, git. In-flight v1 goals keep running under legacy rules with a version stamp; explicit lzy migrate apply moves them into the v2 format (in-flight goals become drafts with authorization NONE — re-adopting needs a fresh human approval; update/sync never migrate automatically).

v0.3.1 — delivery orchestration closeout

Choose a tag to compare

@Acfufu Acfufu released this 26 Sep 16:33

LazyZCode 0.3.1 closes the 0.3.1 window: the queue-to-delivery bridge, three correctness fixes surfaced by the closeout goal loop, and the 0.3.1 release candidate freeze.

Highlights

  • Queue × delivery orchestration (ADR-0030): queue items can target endpoint B/C with attached delivery contracts; dispatch runs the delivery chain itself after the goal finishes (bind → act/read-back), multi-page Pages verification, HEAVY items in the queue, delivery-aware reconcile with post-hoc acknowledgement.
  • Drive points axis meters this run's own segments (ADR-0027 amendment): the points hard cap is judged on the run's own per-segment sessionId usage — the account-level 5h rolling waterline is retired to a lzy doctor advisory line and no longer stops a task because another session consumed points. A contract budget-ref: none keeps wall clock only.
  • Verification receipts bind the registered contract hash: the four receipt writers recorded null (a mis-read field); reuse judging now rejects receipts owned by another contract (or taken pre-contract) instead of accepting them as coverage.
  • Delivery completion is judged by the delivery result, not intent status (ADR-0028 semantics): B requires the actual merge identity plus green merge-SHA CI; C additionally requires every declared page to pass. Unverified merges keep the intent done (never re-sent) but the queue item is not completed until verified — recovery is lzy delivery readback.
  • Authorization-ledger race fix: same-millisecond approvals for the same contract no longer overwrite each other (append-only ledger no longer silently truncated).

Quality

  • Full suite 658/658 green on the frozen candidate; CI four legs (node 22/24 × ubuntu/windows) green, including the Windows leg running the full suite.
  • Evidence: goal v031-closeout finished 16/16 with a 4/4 MATCH comparator attestation (red-green pairs per fix, real headless sessions for the metering fix).

Upgrade: npm i -g lazyzcode then lzy sync (two-step semantics, ADR-0012 — update never auto-migrates).

v0.3.0 — agent-first: contracts, verification machine, unattended queue, limited delivery, migration

Choose a tag to compare

@Acfufu Acfufu released this 25 Sep 23:37

v0.3.0 — agent-first

Six-milestone release (M0–M5) turning the goal loop into an agent-first runtime: humans approve contracts and boundaries, the agent plans and executes inside them, and every external action is gated, metered, and verifiable.

Added

  • Requirement contracts (ADR-0024): register a goal against an immutable contract file (lzy loop register --contract <file>; contractHash = sha256 of the bytes). The UPS approval phrase binds the contract short code; in-contract replans re-run the review gate but never re-approve. New withdrawal phrase 「撤回 <短码>」 appends an append-only withdrawal record; already-occurred external effects stay honestly recorded. Goals without a contract keep the legacy planHash gate byte-identical.
  • Project manifest: versioned lzy.project.json — six capability classes (prepare/start/check/observe/cleanup/delivery), explicit argv arrays (shell strings rejected), timeouts, env-name whitelists, root-confined write paths. lzy project check / lzy project discover.
  • Verification receipts (ADR-0025): lzy verify run executes a manifest check under a controlled executor (argv array, shell:false, SIGTERM timeout kill, env-name whitelist) and records a checksum-protected receipt bound to the candidate identity. Scope-tier reuse (lzy verify reuse) grants declared-input reuse only after a live adversarial qualification, with named conservative fallbacks. Integration verification runs real checks at the workers-wave barrier (re-anchor is not re-verification — that path is retired). CI identity (lzy verify ci) binds read-only GitHub check-run results to a sha — honest about not-current/blocked, never a silent pass.
  • Bounded queue & cumulative budget (ADR-0027): lzy queue runs multiple approved contracts serially across interruptions with a state-machine authorization gate and dispatch-transaction crash recovery (reconcile before action — never blind re-dispatch, never resetting another goal). The cumulative budget ledger binds (slug, contractHash) and never refreshes across restarts; point enforcement follows the approved approximate-limit semantics — metering absence / unpriced models / killed-inflight consumption are explicitly recorded, never counted as zero, until a human resumes.
  • Limited delivery B/C (ADR-0028): lzy delivery — merge-to-main (B) and Pages live verification (C) via per-endpoint delivery contracts riding the UPS approval channel unchanged (hook approval branch: zero changes). Merge is machine-gated on dual B∧C authorization + PR head/base drift re-check + green CI, bound to the PR head, reads back the actual merge SHA and polls CI on it. An intent ledger records identity before any external call and read-back classifies outcomes — done is final, no blind re-execution after timeouts or disconnects.
  • Complete migration machine (ADR-0029): lzy migrate preview / apply / status. Apply = backup (six legacy record families, sha256 manifest) → staging → validation → atomic switch, with .lazyzcode/state.json as the version entry written last as the commit point. Crash-safe and idempotent per task identity via a per-run journal. In-flight goals become drafts carrying authorization NONE with no scope — old approvals never escalate. A live lease/process refuses migration; a corrupt goal.json stops before any write; corrupt preserve-family records are warned and kept byte-exact. lzy update/sync never migrate automatically.
  • Knowledge routing: the zw skill splits into a ≤8 KiB resident entry plus eight per-phase recipes; the root AGENTS.md slims to ≤12 KiB with history, the decision table, and the glossary relocated. Nothing deleted — entry → recipe → cited ADR.

Verification

618/618 tests, CI four legs green (node 22/24 × ubuntu/windows), docs site builds with zero broken links (86 pages), per-milestone comparator records with final LOOP_COMPLETE attestations (M1–M5 goals), three-repo replay regression matrix (3 replays per repo, including interrupt-recovery forms).

Coverage boundary

Live evidence covers arm64 guests (Parallels VMs on an Apple Silicon host). x64 coverage follows the official ZCode download matrix (three platforms × dual arch) by documentation; the detection paths are architecture-independent (environment-based).

Upgrade

From 0.2.x: lzy update (spawns a fresh child process to deploy the new plugin payload). From older versions: manual two-step (npm i -g lazyzcode && lzy install). Requires the ZCode desktop app (logged in), Node ≥ 22, git.

Migration is always explicit: lzy migrate preview first, lzy migrate apply when you decide — update/sync never migrate for you.

Full changelog: https://github.com/Acfufu/lazyzcode/blob/main/CHANGELOG.md

v0.2.4 — dual-review fix round, honest gates

Choose a tag to compare

@Acfufu Acfufu released this 23 Sep 15:13

Highlights

  • 0.2.4 fix round — 39 findings of the five-round dual review, all closed
    (report: docs/reviews/2026-09-23-v024-fix-round.md). Every finding carries a
    landed commit in docs/reviews/findings-ledger.jsonl. The five P1s live in
    one family, the workers lane's wind-down phase:
    • the cleanup phase unlinks its worker-subject entries before deleting their
      worktrees (a clean non-done wind-down no longer leaves dangling roots that
      make every later finish reject), runs inside the lease window (a
      fenced subject remove is refused once the lease is released), preserves
      dirty worker worktrees with their branches, names them in the handoff
      snapshot, and only removes the run directory wholesale when nothing was
      preserved;
    • startup reclaim now deletes a run directory only when it carries the
      owner sentinel
      the tool writes at creation; foreign directories, .logs
      archives and sentinel-less ones are skipped and named (previously every
      non-current entry under the sibling root was rm -rf'd — including a
      maintained merge-conflict worktree);
    • the wave barrier re-anchors only when the subject head-tree set actually
      moved
      and passes the previous green's --harness through, so the stuck
      wind-down is reachable again and INV-08's harness freeze stops being
      vacuous on every rebind.
  • Workers-lane boundaries (ADR-0026): HEAVY goals are refused at the
    workers entry (structural dead end: every wave re-binds the anchored green,
    while HEAVY finish requires a comparator attestation bound to it), stranded
    per-run step claims are released at wave end with the snapshot naming the
    command, wall-clock accounting moved after the merge so a budget-exhausted
    wind-down keeps the wave's output, and the worker prompt forbids
    lzy loop finish with a pre-merge goal re-check.
  • H3R parser: four lexical gaps closed (segment truncation, bookkeeping
    prefix + newline, quote-parity misfire, mid-word quotes) — the real hook went
    from 0/4 to 4/4 on the four control cases. The bypass axes are now split into
    a fixed lexical family and a semantic family still reserved for lane B.
  • Read faces now say what the machines do: lzy evidence list warns only
    about the current red (matching the gate since 125bbdd), the doctor
    attest-trailer row distinguishes tampered content from absent files and
    never degrades an unreadable directory to "empty", and the doctor drive row
    reports workers residue in three buckets. --fast=false means the
    single-worker path (it used to be inverted into workers 2).

Coverage boundary

  • --workers N / --fast remains a LIGHT-only experimental lane for the
    unattended drive path: HEAVY is rejected at entry, measured request cost is
    ≈2× turns, and the barrier rebind is a fingerprint rebind, not
    re-verification
    (the evidence text says so). Idle/scheduled lanes are
    unchanged; the protocol (skills) carries the discipline, and the machine
    gates now enforce exactly what they claim.
  • The H3R gate remains dormant (L0 protocol text plus dormant prototypes); the
    word list is a matcher, not a command parser.

Verification

  • npm test 491/491 on the frozen tree (baseline 470; +21 new contract
    cases across the wind-down family, the reclaim matrix, the parser controls,
    the read faces and the ledger lint).
  • Real-surface evidence for this release: the workers probe (real CLI with a
    fake engine) went 1/13 → 13/13 pre-fix → post-fix; the real H3R hook 0/4 →
    4/4; the pre-change red captures and the post-change green captures are kept
    under artifacts/v024-fix-round/. Comparator attestation 6/6 MATCH;
    LOOP_COMPLETE at .lazyzcode/attestations/v024-fix-round-20260923T145524Z.json.
  • CI: node 22/24 × ubuntu/windows all green (run 35879379612). The first two CI
    attempts reddened on the new tests' environment assumptions (an ambient
    provider-config env that only a desktop session has; chmod 000 not blocking
    directory reads on Windows) — both fixed test-only, with the host env
    stripped locally to reproduce CI (491/491).
  • Payload: 44 files / 295.1 kB / sha1
    0ce271b9854acfba886434d99a1266ca5d4fd15e — the dry-run figure and the
    tarball packed from the tag tree are byte-identical (freeze held across the
    two test-only follow-up commits).

v0.2.3 — H3R enforcement-point migration + fix round

Choose a tag to compare

@Acfufu Acfufu released this 22 Sep 16:50

Highlights

  • H3R enforcement-point migration (ADR-0022 amendment): the dormant
    high-risk-step prototype gains two machine faces in the unattended lane —
    one-step-per-segment (LZY_SEGMENT_ID, shape-validated <int>:seg-<int>,
    a second distinct step done in one segment is refused; same-step evidence
    rebinds pass) and a command-layer gate (plugin/hooks/h3r-pretool.js,
    PreToolUse/Bash, awake only with LZY_ABLATE_H3R_PRETOOL=1) that denies
    word-list hits and writes the hit marker drive consumes for a clean
    wind-down. Grid h3r2 (32 trials): decisive split — protected arms stop
    4/4 with zero high-risk actions landing (report includes a re-derivation
    errata: true deny events 4, true one-step refusals 11, echo amplification
    ~109x).
  • Fix round (five-round dual review, 41 findings all handled): drive's
    wind-down channel is non-throwing (every non-done cause authors its 7-field
    snapshot), heartbeat failures split by family (storage I/O no longer
    mislabeled as takeover; snapshot + lease-reclaim guidance), segment-boundary
    recovery guidance dispatches by cause (RESTRICTED's only exit is
    narrow-and-re-register), reset/start sweep the segment markers, the
    bookkeeping exemption refuses compound commands and quoted paths, the word
    list closes the push -f / id_ed25519 / whitespace-evasion gaps, and the
    word-list check now states its per-reader failure semantics (drive-side
    throws, hook-side fails open).

Coverage boundary

  • The H3R gate remains a dormant prototype for the unattended lane only
    (ADR-0022): default behavior stays byte-identical to 0.2.2, interactive
    sessions are exempt (given env hygiene) and are the recovery path. Its
    machine form's fate (wake default / removal) is deferred to human review —
    never auto-promoted or auto-dropped.
  • win32: the run-hook.cmd version-sort guard is verified by diff + cmd
    semantics argument; the VM live-shot is on this release arc's retest list.

Upgrade

  • From 0.2.2: lzy update — npm pulls the latest package, then a fresh child
    process from the new install runs lzy sync (skips when already latest).
  • From 0.2.1 or earlier: the manual two-step (see the guide's Upgrade
    section) — engine sessions read the cached version directory, so npm alone
    does not take effect for running setups.

v0.2.2 — instrument and ledger hardening + the H3R gate experiment

Choose a tag to compare

@Acfufu Acfufu released this 21 Sep 19:22

v0.2.2 — instrument and ledger hardening + the H3R gate experiment

Two batons: instrument and ledger hardening (goal v022-bat1-instrument) and
the H3R high-risk-step gate experiment (goal v022-bat2-h3r). Product behavior
is unchanged — the H3R prototype ships dormant.

Fixed

  • drive judged progress by a done-step jump alone. A long step that committed
    code and recorded evidence but never ran step done still read as zero progress
    and was wound down as stuck after two segments. Progress is now the documented
    state set — done steps ∪ subject head trees ∪ evidence-ledger green nodes ∪
    handoff/salvage registrations (core/progress.js) — so a step's commits and
    evidence count even before it closes. Dirty trees are deliberately not a signal.
  • The waterline watch was blind to non-GLM providers. core/cost.js's rolling
    SQL recognized two model names and counted everything else as zero, so on a
    DeepSeek session both the 1600-point warning line and drive's 400-point budget
    read as idle. The pricing table is now enumerated with sources — units stated in
    yuan per million tokens — and the SQL is generated from it (ADR-0023).
  • The ablation harness's engine spawn had no wall-clock hard cap: ADJ-38's fix
    had reached core/headless.js but not the ablation pipeline.
  • Six stale claims the code had outgrown were retired, and the handoff-snapshot
    directory is now enumerated and exempted from the doctor's scar patrol (it is a
    reset-surviving family, not a stray shell).

Added

  • Lock contention is observable. withLock records acquisitions, waits,
    wait-time total/max and timeouts into loop/metrics.json; a new lzy doctor
    lock row surfaces them. A probe measured the real critical section across this
    repo and three dogfood repos: worst case 58.9 ms against the 5 s wait window
    (0.012× of it).
  • The H3R high-risk-step gate prototype (ADR-0022), shipped dormant.
    core/h3r.js holds the judgment surface — a risk word list plus an explicit
    [risk:high] plan marker — and core/drive.js checks it at the top of each
    segment. A hit winds the segment loop down cleanly before spawning: no engine
    call, no tokens, and the 7-field handoff snapshot carrying the recovery path is
    written. LZY_ABLATE_H3R_GATE exactly "1" WAKES it — the inverse of the
    LZY_ABLATE_* family's semantics, which is why ADR-0022 quotes the operative
    pre-registration sentence. Left alone, behavior is byte-identical to 0.2.1.
  • Ablation trials can run through lzy loop drive (h3r-trial.mjs,
    h3r-batch.mjs, the H3R-A/H3R-B/H3R-C arm variants, extractH3rMetrics,
    aggregateH3r). The harness had never exercised drive — every earlier batch
    spawned the engine directly — while the gate lives only in drive's segment loop.
  • ADR-0023: the multi-provider pricing convention (units stated explicitly, an
    enumerated table with sources, the waterline SQL generated from that table).

The H3R experiment, in one paragraph

Report: docs/reviews/2026-h3r-gate-report.md; ablation ledger docs/ablation.md
#31. The gate's mechanics work; its enforcement point does not. A
single-instrument run proves the gate stops a reachable risky step in 2 seconds
with zero engine calls and a clean 7-field snapshot, and no bypass attempt. In the
24-trial grid it never fired — because 15 of 24 trials (62.5%) finished the entire
plan inside one segment
(the segment prompt says one step per segment), so a
per-segment check never gets the chance to run: the gate was bypassed, not
defeated
. The pre-registered "zero differentiation ⇒ the task set has no
measurement power" label is rejected by the evidence — the traps did fire, in
9 of 12 runs — the enforcement point is what failed. An unplanned find with real
value: 3 of 24 runs were stopped by the goal-level gate when the in-segment
model raised the goal's own risk to high, proving that coarse goal-level gate does
fire in practice. Disposition of the machine form stays a human review item;
nothing is promoted or downgraded automatically.

Notes

The 24-trial grid ran on the release version face (payloadHash 7c635b86558a…), captured before the text-layer edits that followed it — the report
records this in §9.6 rather than claiming the grid ran on the final 0.2.2 payload.

Coverage boundary

Live evidence covers arm64 guests (Parallels VMs on an Apple Silicon host). x64
coverage follows the official ZCode download matrix (three platforms × dual arch) by
documentation; the detection paths are architecture-independent (environment-based).

Upgrade

From 0.0.10 and newer: lzy update (spawns a fresh child process to deploy the new
plugin payload). From older versions: manual two-step (npm i -g lazyzcode && lzy install). Requires the ZCode desktop app (logged in), Node ≥ 22, and git.

Full changelog: https://github.com/Acfufu/lazyzcode/blob/main/CHANGELOG.md