# Guion status

**Stage:** active development. The Guion-identity release matrix has passed on macOS ARM64 and Debian 12 GNU/Linux on ARM64 and x86_64, all with glibc. That cohort predates artifact format 44. Named current-format managed packages now pass on macOS ARM64 and Debian 12 ARM64 and x86_64. Feed Digest passes on macOS ARM64 and both Debian architectures: ARM64 natively and x86_64 under Rosetta. Broader package coverage remains open.

## What is established

- The default core CLI embeds a self-hosted compiler and runs on the Rust runtime. It can create, check, format, lint, test, run, build, package, verify, install, inspect, and document Guion programs.
- The current language includes typed functions and records, modules, collections, `Option`/`Result`, JSON, bounded file and HTTP operations, SQLite/TOML services, Unicode helpers, and bounded parallel work. The [language contract](../language/spec.md) is authoritative about what syntax works and what remains unsupported.
- New source, artifact, manifest, lock, and local-state names are `.gu`, `.gub`, `guion.toml`, `guion.lock`, and `.guion/`. A limited set of old Veritas project names remains readable during migration; see [compatibility](compatibility-and-migrations.md).
- The Guion-identity release matrix passed on macOS ARM64 and Debian 12 GNU/Linux on ARM64 and x86_64, all with glibc. This does not establish support for other operating systems, CPU architectures, or libc variants.

## Current evidence and its limits

- **Speed gate on server CPUs (2026-11-03).** On GitHub's x86_64 (AMD EPYC 7763) and ARM64 (Neoverse N2) Linux runners, Guion took less time than the uv standalone CPython 3.14.7 on every lane of the text, JSONL and CSV gate, at 20,000 and 200,000 rows, from source and from artifacts (15 shuffled, output-checked trials per lane). The worst 95% upper bound of the Guion/Python ratio was **0.976** on x86_64 and **0.859** on ARM64; at 200,000 rows the median ratios were text 0.957–0.960 / 0.810–0.816, JSONL 0.860–0.897 / 0.844–0.855 and CSV 0.862–0.875 / 0.789–0.799 (x86_64 / ARM64). The x86_64 text margin is 3–4%, each host was measured once, and an Intel Xeon runner, which measured worse on an earlier build, has not been rerun. This closes the JSONL and CSV gaps recorded below for these workloads and hosts. See the [server speed-gate report](../evaluation/completion/results/real-task-sprint/2026-11-03-server-speed-gate.md) and the [task-class evidence](../evaluation/development/core_cost_closure/task-class-evidence.md).
- **Helper cost (2026-11-04).** Passing a list, map or text through a helper and storing the result back into the same variable used to copy the whole value on every call, so loops over such helpers cost the square of their size. A map helper over 10,000 keys took 10.941 s and now takes 0.043 s; 40,000 list appends took 9.212 s and now take 0.012 s; 160,000 text appends took 1.166 s and now take 0.032 s (one Apple Silicon Mac; see `evaluation/completion/results/2026-11-04-helper-cost-report.md`). A result stored in a different variable still copies, and functions that hand a list or map through a call run in the interpreter, not machine code.
- **Mac re-measurement (2026-11-05).** On main at commit `484cefd` (artifact format 61, macOS ARM64, CPython 3.14.7), Guion and Python each passed **127/127** frozen application cases, and seven-pair timing comparisons favored Guion in all nine selected everyday tasks (ratios **0.149–0.826**). The five 21-pair short-source gates ran at ratios **0.184–0.234**. Richards uncached source measured **28.03 ms vs. 64.70 ms** for CPython (ratio **0.433**, 95% interval **0.426–0.440**), passing the 0.60 target; the 16,384-package lockfile audit measured **77.71 ms vs. 162.23 ms** (ratio **0.477**). See the [re-measurement report](../evaluation/completion/results/2026-11-05-mac-remeasurement/2026-11-05-mac-remeasurement.md). The earlier [current-main checkpoint](../evaluation/completion/results/real-task-sprint/2026-10-27-current-main-outcome-checkpoint.md) (commit `6b5e5aba`, artifact format 44) is kept as the historical record.
- The 2026-10-28 core sprint adds `http_response_text(HttpResponse) -> Result[Text, HttpError]` and `std:http.http_response_json(HttpResponse) -> Result[Json, StdError]` in artifact format 45. Existing byte-preserving HTTP requests and format-44 artifacts remain supported. The Debian ARM64 JSONL profile found parse-plus-line-iteration took 1.2202s median versus 0.3601s for file reading on the 200,000-row workload (ratio 3.3587, 95% interval 3.3265–3.4124). Two candidate optimizations were rejected. The final seven-workload run passed output checks but missed the preset JSONL speed gate: 20,000 rows measured 0.566s vs. 0.121s for CPython (4.63×, 95% interval 4.48–4.76), and 200,000 rows measured 5.879s vs. 0.810s (7.11×, 95% interval 6.68–7.38). Tiny-source timing was consistent with parity against a same-toolchain base rebuild; the typed HTTP path measured 13.409ms vs. 12.659ms (1.064×, 95% interval 1.006–1.210). The [sprint completion report](../evaluation/completion/results/real-task-sprint/2026-10-28-guion-core-sprint-completion.md), [typed HTTP report](../evaluation/completion/results/real-task-sprint/2026-10-28-typed-http-response.md), [optimization outcome](../evaluation/completion/results/real-task-sprint/2026-10-28-core-optimization-outcomes.md), and [capability audit](../evaluation/completion/results/real-task-sprint/2026-10-28-guion-core-capability-audit.md) record the evidence and limits. These Debian results do not supersede the format-44 macOS checkpoint.
- The format-44 concurrency cohort has evidence beyond CPU-only workers. The frozen app cases exercised calendar fan-out across five feeds and health checks with mixed service responses, each capped at two simultaneous requests. A runtime regression also confirms that a failing HTTP worker interrupts an in-flight sibling request and closes its socket. This closes the named current-host failure/cancellation scenarios; it does not establish a general async runtime or cross-target format-44 behavior. See the [concurrent HTTP cancellation report](../evaluation/completion/results/real-task-sprint/2026-10-27-parallel-http-cancellation.md).
- The 2026-10-27 format-44, macOS ARM64 bridge follow-up used one typed Python call to process 100,000 JSON rows through NumPy 2.5.1 and orjson 3.11.9. A same-host 15-pair comparison did not establish a speed change after borrowed request serialization and sidecar frame-copy reductions: the candidate/pre-change ratio was **1.012** (95% interval **0.985–1.025**). Guion remains **1.129×** slower than the same package function in Python and **1.406×** slower than the standard-library reference. All reports matched byte-for-byte. This code reduces intermediate copies but has not shown a speedup or measured peak-memory reduction. See the [serialization follow-up](../evaluation/completion/results/real-task-sprint/2026-10-27-python-bridge-serialization.md) and [raw samples](../evaluation/completion/results/real-task-sprint/2026-10-27-python-bridge-serialization.json); the earlier separate cohort remains in the [initial bridge report](../evaluation/completion/results/real-task-sprint/2026-10-27-python-bridge-package-analysis.md).
- The next current-format bridge pass added private protocol-v2 raw-byte request attachments and compared the same 100,000-row task in 15 randomized output-checked pairs. Guion `Bytes` reduced the Guion median by **13.7%** versus Guion `Text` (140.59 vs. 161.60 ms; paired ratio **0.863**, 95% interval **0.859–0.879**). It came close to the same NumPy/orjson Python function at **137.93 ms**, but Guion remained **2.5% slower** (ratio **1.025**, 95% interval **1.001–1.027**), and **22% slower** than the standard-library Python reference. Outputs matched exactly. This is a targeted improvement on one payload-heavy task, not a general language-speed result; host CPU stacks and peak memory remain unmeasured. See the [plain-English report](../evaluation/completion/results/real-task-sprint/2026-10-27-python-bridge-bytes.md) and [raw evidence](../evaluation/completion/results/real-task-sprint/2026-10-27-python-bridge-bytes.json).
- The 2026-10-28 bridge follow-up removed one full-size temporary allocation while keeping Python arguments as immutable `bytes`. The parser allocation regression fell from a 10,202,573-byte peak to below its 7,651,300-byte bound for a 5,100,867-byte attachment. On the full workload, Guion `Bytes` measured 138.49 ms versus 136.05 ms for the same package-backed Python function; the paired ratio was **1.020** (95% interval **0.988–1.031**), so this run does not establish a winner. Guion remained **19.9% slower** than the standard-library reference (ratio **1.199**, 95% interval **1.177–1.225**). Every output matched exactly. See the [copy-reduction report](../evaluation/completion/results/real-task-sprint/2026-10-28-python-bridge-single-copy.md) and [raw evidence](../evaluation/completion/results/real-task-sprint/2026-10-28-python-bridge-single-copy.json).
- A four-lane no-op control keeps package imports and the `Bytes` call constant while comparing empty and 5,100,867-byte inputs. With no payload, Guion and Python were at parity (ratio **0.993**, 95% interval **0.979–1.019**); with 5.1 MB, Guion was **4.3% slower** (ratio **1.043**, **1.004–1.050**). The relative payload penalty was **1.045** (**1.001–1.088**), locating the remaining difference in work that scales with transferred bytes. Every output matched. This does not attribute CPU time among file reading, pipe transfer, and frame handling. See the [control report](../evaluation/completion/results/real-task-sprint/2026-10-28-python-bridge-startup-sizes.md) and [raw evidence](../evaluation/completion/results/real-task-sprint/2026-10-28-python-bridge-startup-sizes.json); the earlier [5.1 MB no-op cohort](../evaluation/completion/results/real-task-sprint/2026-10-28-python-bridge-startup-5mb.md) is retained separately.
- The sidecar frame reader now uses `readinto` to cut isolated temporary allocation for a 5.1 MB frame from **10.20 MB** to **5.10 MB**. The full application remained at parity with package-backed Python (ratio **1.019**, 95% interval **0.995–1.046**); a paired comparison across independent cohorts found no measurable speed change. All outputs matched. See the [frame-reader report](../evaluation/completion/results/real-task-sprint/2026-10-28-python-bridge-readinto.md) and its [application](../evaluation/completion/results/real-task-sprint/2026-10-28-python-bridge-readinto-application.json) and [no-op](../evaluation/completion/results/real-task-sprint/2026-10-28-python-bridge-readinto-startup.json) evidence.
- A direct-read fast path was tested and reverted after candidate/readinto bootstrap comparisons showed no measurable speed change (application **1.018**, 95% interval **0.967–1.043**; no-op payload penalty **1.003**, **0.975–1.072**) and only a 520-byte peak-allocation difference. A streaming-reader prototype also failed the one-copy allocation bound for a fragmented 5.1 MB attachment. The next measurement targets repeated bridge calls after startup; see the [direct-read report](../evaluation/completion/results/real-task-sprint/2026-10-28-python-bridge-direct-read.md).
- A 15-pair repeated-call comparison found the 1-call bridge run at parity (ratio **1.046**, 95% interval **0.984–1.068**), with an increasing gap at 10 calls (**1.066**), 100 (**1.339**), and 1,000 (**4.131**, **4.046–4.305**). The estimated excess was **0.241 ms per added call** (95% interval **0.236–0.254 ms**), positive in all pairs. All outputs matched. The next target is phase-level timing of the per-call request/response path. See the [report](../evaluation/completion/results/real-task-sprint/2026-10-28-python-bridge-repeated-calls.md) and [raw samples](../evaluation/completion/results/real-task-sprint/2026-10-28-python-bridge-repeated-calls-1-1000.json).
- Current-format managed packaging passes on macOS ARM64 for the mixed-dependency fixture and the 100,000-row NumPy/orjson analysis, and on Debian 12 ARM64 and x86_64 for the analysis. The three analysis bundles are source-free, relocate to a path with spaces and Unicode, and launch twice without external Python/uv settings while matching the independent report exactly. Their uncompressed directory sizes are 157,585,367 bytes on macOS, 244,199,858 bytes on Debian ARM64, and 274,853,607 bytes on Debian x86_64. `GUION_PYTHON_CACHE_DIR` lets package assembly seed its offline cache from a preloaded uv cache. This closes the named package outcomes on these targets, not broad Python package compatibility. See the [mixed-dependency report](../evaluation/completion/results/real-task-sprint/2026-10-27-current-format-managed-python-package.md), [macOS analysis report](../evaluation/completion/results/real-task-sprint/2026-10-27-current-format-managed-package-analysis.md), [Debian ARM64 analysis report](../evaluation/completion/results/real-task-sprint/2026-10-27-current-format-managed-package-analysis-debian-aarch64.md), and [Debian x86_64 analysis report](../evaluation/completion/results/real-task-sprint/2026-10-27-current-format-managed-package-analysis-debian-x86_64.md). The first QEMU attempt and Rosetta retry are both documented.
- A separate current-format Feed Digest package adds managed pure-Python package coverage with feedparser 6.0.14 and feedparser-sgmllib 2.1.0. Six source cases and six relocated-package cases matched the independent Python implementation byte-for-byte on macOS ARM64, Debian 12 ARM64, and Debian 12 x86_64. The packages retain the exact loopback host grant, complete license records, and no native extensions from these Python dependencies; their uncompressed directories are 172,422,430 bytes on macOS, 128,874,649 bytes on Debian ARM64, and 158,943,069 bytes on Debian x86_64. The Debian ARM64 run used the native path in the existing Colima VM without Rosetta; x86_64 used Rosetta, not QEMU. This broadens the evidence by one library and application; general package compatibility remains open. See the [macOS report](../evaluation/completion/results/real-task-sprint/2026-10-27-feed-digest-managed-package.md), [Debian ARM64 report](../evaluation/completion/results/real-task-sprint/2026-10-28-feed-digest-managed-package-debian-aarch64.md) and [raw evidence](../evaluation/completion/results/real-task-sprint/2026-10-28-feed-digest-managed-package-debian-aarch64.json), plus the [Debian x86_64 report](../evaluation/completion/results/real-task-sprint/2026-10-28-feed-digest-managed-package-debian-x86_64.md).
- The lockfile auditor now passes 17/17 frozen cases in both languages and emits exact output through 16,384 packages / 32,768 diagnostics. On this Mac, Guion measured 171.82 ms versus Python's 179.87 ms at that size, with peak RSS of 40.92 versus 47.13 MiB. This closes the scale, speed, and RAM gap for this workload; it is not a general-purpose speed or memory result. See the [lockfile report](../evaluation/completion/results/real-task-sprint/2026-10-27-lockfile-scale-ram-package-limit.md).
- The earlier target cohort has 18 passing application reports for each of nine retained regression applications across initial and follow-up variants on each of the three targets: 54 of 54 reports passed. The preserved inputs and original Veritas reports were not rewritten.
- The Guion installed-performance report is [`performance-guion.json`](../evaluation/completion/results/guion-final/performance-guion.json), with command, correctness, and comparison records in [`performance.json`](../evaluation/completion/results/guion-final/performance.json). It measures the Guion ARM64 installed artifact against pinned, GIL-enabled CPython 3.14.7 on macOS. The report retains raw paired samples and percentile intervals. The newer Debian x86_64 validation was functional and release-focused; it adds no performance comparison.
- The earlier Guion package-performance report measured the installed CLI. The newer runtime-efficiency cohort separately measured fresh uncached source and prebuilt `.gub` program artifacts through the release CLI; both were faster than pinned CPython 3.14.7 on each named workload. On 200,000-row JSONL, uncached source took a 4.025-second median versus 17.670 seconds for the Python data reference; the prebuilt program artifact median was 4.030 seconds. A focused runtime change reduced the uncached-source median from the merged baseline's 4.160 seconds by 3.2%; the candidate/baseline median-ratio bootstrap interval was [0.941, 0.983]. Peak RSS was effectively unchanged. The five 21-pair short-source gates passed again. See the [runtime-efficiency summary](../evaluation/completion/results/runtime-efficiency/2026-10-26-summary.md) and its linked raw reports. These results cover named programs and conditions only; they do not show that Guion generally outperforms or replaces Python. Free-threaded Python remains unmeasured because it was unavailable.
- The frozen independent recommendation campaign selected Python in all 18 choices for its older candidate. A later three-pair builder study recommended either language for two work classes and Veritas for one. These are separate historical studies with different questions; neither is a general adoption estimate.

- The 2026-10-25 source-run sprint added a bounded source compilation cache. Its results are historical and remain in the [dated comparison](../evaluation/completion/results/source-loop/final-comparison-20261026.json) and [readiness section](pre-release-readiness.md#source-run-and-launch-speed-sprint-2026-10-25). The later 2026-10-26 cohort above reran uncached source and supersedes that sprint's source-versus-Python comparisons for the named workloads.

The earlier multi-target matrix, package details, and current limitations are in the [validation and readiness report](pre-release-readiness.md).

## CI and release gates

GitHub Actions runs formatting, strict Clippy, workspace tests, schema checks, generated agent-reference validation, and switch-condition evidence validation on Ubuntu x86_64. That job is a source check only; it does not certify Guion's supported release targets. The full release gates run on macOS ARM64 and Debian 12 GNU/Linux on ARM64 and x86_64 with glibc. A target that did not run is reported as incomplete.

## Remaining product outcomes

The current-main checkpoint and named managed-package fixtures are complete on macOS ARM64; the 100,000-row analysis package passes on Debian 12 ARM64 and x86_64, and Feed Digest passes on macOS ARM64 and both Debian architectures. Current-format application packaging now includes both native-wheel data processing and pure-Python feed parsing. The Python bridge's 100,000-row comparison remains slower than both package-backed and standard-library Python in its latest cohort. Profiling repeated calls found an avoidable native-image scan; the event-gated observer reduced the 1,000-call bridge ratio from 4.131 to 1.481 and the excess per-call estimate from 0.241 ms to 0.0381 ms. Direct Python remains faster for this 1,000-call loop, so response transport and reader wakeup are the next performance target. The `readinto` change still halves isolated frame-read allocation; the direct-read fast path showed no measurable benefit and was reverted, and the streaming-reader prototype did not meet the memory bound. Broader package usefulness, bridge efficiency, and language learnability remain open. Historical recommendation exercises remain exploratory evidence, not a measure of broad adoption. See the [validation report](pre-release-readiness.md), the [phase-profile report](../evaluation/completion/results/real-task-sprint/2026-10-28-python-bridge-phase-profile.md), [repeated-call result](../evaluation/completion/results/real-task-sprint/2026-10-28-python-bridge-repeated-calls-after-native-image-gate.json), the [latest application report](../evaluation/completion/results/real-task-sprint/2026-10-28-python-bridge-readinto.md), the [direct-read experiment](../evaluation/completion/results/real-task-sprint/2026-10-28-python-bridge-direct-read.md), the [payload control](../evaluation/completion/results/real-task-sprint/2026-10-28-python-bridge-startup-sizes.md), and the [Feed Digest reports](../evaluation/completion/results/real-task-sprint/2026-10-27-feed-digest-managed-package.md), [Debian ARM64](../evaluation/completion/results/real-task-sprint/2026-10-28-feed-digest-managed-package-debian-aarch64.md), and [Debian x86_64](../evaluation/completion/results/real-task-sprint/2026-10-28-feed-digest-managed-package-debian-x86_64.md).

This status page is a current summary, not the test record.

## 2026-10-25 closeout clarification

The 2026-10-25 closeout recorded 18 passing application reports per target across two targets (36 total). The current three-target cohort supersedes that matrix with 54 of 54 passing reports. Free-threaded Python was not installed for the comparison, so that comparison was not run and has no result. The original Veritas checkout was retired after its unique small working records were retained. The idle Colima VM was stopped gracefully, closing its deleted build-cache handles.

## Earlier speed-gate history

These entries record the JSONL and CSV gaps as they stood on each date. The 2026-11-03 server speed gate above supersedes their speed conclusions.

- The 2026-10-29 runtime follow-up closed the typed HTTP 64 KiB cold-source and artifact non-inferiority gate with a 15-pair run: 0.929× source and 0.886× artifact versus same-build legacy; 1 MiB measured 0.761× and 0.716×. The JSONL 200,000-row execution gap remains about 3.8× pinned Python and is still open. See the [HTTP measurement](../evaluation/development/core_cost_closure/results/http-shared-types-paired-15.json).
- The follow-up JSONL core-performance sprint passed all output checks and the unchanged lockfile-auditor holdout, but produced no statistically clear speed win over the frozen Guion control. In the final 15-pair Debian ARM64 cohort, candidate/Python median ratios were 2.9976 (20k source), 2.9599 (20k artifact), 3.6779 (200k source), and 3.5750 (200k artifact); every 95% interval remains above parity. The gate is open, and candidate/control uncertainty exceeds the proposed 2% regression bound in the 200k lanes. A whole-function register/SSA execution plan for the measured guest path is the next candidate; tested forwarding and stack-pooling approaches were rejected. See the [full outcome and raw data](../evaluation/development/core_cost_closure/results/sprint-20261029-jsonl-core-performance-outcome.md).
- Follow-up on the speed-closure branch (2026-11-01): load-time inlining of host-operation forwarders (relaxing the forwarder call-count, depth and trace-frame guarantees at the architect's direction), native fuel handoff between native callees, and a JSON reserved-key pre-check moved the JSONL paired ratios against PGO CPython 3.14.7 to **1.35 / 1.25×** (frozen / fused, artifact lane) and **1.39 / 1.33×** (source lane) at 200k rows, and the fused artifact lane at 20k rows to **0.995×** (upper 95% bound 1.047). The gate (upper bound below 1.0 at 20k and 200k in both lanes) is still not met. A fully native tier on the arena-handle design remains slower than the VM (1.47 s against 1.00 s), and instruction-pair fusion, shallow return checks and native constant-charge changes were within noise. See the [task-class evidence](../evaluation/development/core_cost_closure/task-class-evidence.md).
- The 2026-10-31 speed-closure sprint (branch `codex/guion-speed-closure`, artifact format 50) did not meet the JSONL speed gate. On the pinned Debian ARM64 container against PGO CPython 3.14.7 (9 interleaved, output-checked trials), the frozen program measured **1.35 / 1.29×** Python at 20k rows (source / artifact) and **1.49 / 1.66×** at 200k; the same logic written with the new fused `json_get_text_safe` / `json_get_int_safe` accessors and `format_utc_date` measured **1.24 / 1.10×** at 20k and **1.36 / 1.36×** at 200k (upper 95% bounds 1.14–1.40). The earlier 3–3.7× figures above predate the pool allocator, fat LTO and these accessors. A second workload, a CSV request ledger, measured **3.6×** Python at 200k rows; the lockfile-auditor holdout still leads Python (**0.33×** at 512 packages, **0.41×** at 2,048). Profiling shows the remaining gap is the interpreter's per-instruction cost (about 10 ns per integer instruction and 20–25 ns per data operation, with dispatch the largest share); the `Option`/`Result` box, CSV parser, limit-check and wrapper-inlining ideas were each worth under 8%, and a native tier owning `Text`/`List`/`Map` values is bounded at about 40% (CSV ledger ratio near 2.2), so it was not built. The claim the evidence supports is per task class: faster than CPython on short-lived, compute-bound and parallel CPU programs and on the lockfile-auditor holdout; slower on long interpreter loops over large row streams. The gate is open. See the [task-class evidence](../evaluation/development/core_cost_closure/task-class-evidence.md) and [raw paired data](../evaluation/development/core_cost_closure/results/jsonl-fused-vs-python-paired-9.json).
- The 2026-11-03 stdlib Wave 1 (branch `feat/stdlib-wave-1`, artifact format 59) adds `std:math`, `std:encoding`, `std:crypto`, `std:fs`, `std:regex`, `std:process`, `std:net`, `std:tls`, `std:http_server` and `std:websocket`, all in Guion source over parameterised runtime ops with default-deny grants. Measured on macOS ARM64 (100,000 iterations unless noted, warm runs): a 2M-iteration math loop 0.10 s vs. 0.43 s for CPython; base64/hex round trip 0.07 s vs. 0.10 s; regex match plus replace 0.08 s vs. 0.18 s. A JIT defect that mishandled Text-holding records returned through calls was fixed, socket handles are shared between parallel workers, and the HTTP server supports keep-alive, pipelining and chunked request bodies. Not yet established: Linux results for Wave 1, `random` on the machine-code path, and several security edges (default cwd grants, symlink-following `remove`/`rename`, TLS client certificates). See the [Wave 1 report](../evaluation/completion/results/2026-11-03-wave-1-report.md).
- The 2026-11-04 package registry (branch `feat/package-registry`, artifact format 60) adds package-name rules, version ranges with a resolver, `guion new --lib`, capability declarations that `guion check` compares with what the code does (and that `guion update` will not widen without `--approve-capabilities`), package identities in built artifacts, and `guion add NAME`, `guion publish` and `guion yank` against a hash-chained registry (a Cloudflare Worker over R2, in `registry/`, protocol in `docs/registry-protocol.md`). The client rejects an install when the index, the log and the downloaded bytes disagree. Published libraries can depend on other registry libraries; ranges are pinned at publish time. The Worker is deployed and is the client's default registry; nothing has been published to it yet. Not done at the time: `guion update` did not look for newer registry versions, `.gub` cache attachments, token revocation and signing, and verifying which network hosts a library contacts (all but `.gub` attachments were closed by the follow-ups below). See the [Track A report](../evaluation/completion/results/2026-11-04-track-a-report.md).
- The 2026-11-04 follow-ups (branch `feat/follow-ups`, artifact format 61) close most open items from Wave 1 and Track A. Chained text appends (`set s = s + a + b`) are now linear instead of hitting the allocation budget at about 60 KB; `std:random` runs on the machine-code path with unchanged sequences; functions returning `Unit` (including `fn main() -> Unit:`) and functions using `assert` now compile natively; `guion update` follows a registry package's recorded range; the registry and client support token rotation and revocation (`guion token rotate|revoke`); `guion check` requires hosts named in a library's URL literals to be declared; `fs_remove`/`fs_rename` act on symlinks themselves; and `std:net` adds mutual TLS. A sandbox escape through a dangling symlink was fixed. Records that hold scalar-only records now have a native layout, and a native-code defect that let a record kept across loop iterations be overwritten was fixed. Command-line programs are limited by memory in use rather than cumulative allocation and have no default instruction limit. The registry signs its log with ed25519 and the client verifies it. `guion check` and `guion inspect` say when a program can write files. Measured on macOS ARM64 with default limits: 1M random draws 5.57 s to 0.06 s (CPython 0.28 s); a 20M-iteration loop in a `Unit` main 0.61 s to 0.08 s (CPython 1.24 s). Not done: `.gub` attachments (deferred until separate compilation), deploying the updated Worker, and Linux results. See the [follow-ups report](../evaluation/completion/results/2026-11-04-follow-ups-report.md).