Repository navigation
Description
Separate fast-iteration verification profile (2026-09-04)
The user requested roughly ten times faster development verification after fixed-background tiny checks took about three minutes each. The committed profile contract keeps fast_iteration_verified distinct from fully_verified; fast checks cannot satisfy the existing exhaustive Phase 1/release gates.
The exhaustive campaign is paused after a completed check: 37 new full proofs plus two retained full proofs remain available, with 343 further full checks required under the unchanged acceptance scope. All 373 active performance samples are retained. Implementation now removes repeated verifier work and adds certificate-bound changed-data checks plus explicit untouched FUSE witnesses. Qualification will use one small negative-check campaign and one representative fast tiny case before broader rollout. The 18–20-second target is not yet measured. No case definitions or historical failures are deleted, and this issue remains open.
Latest Phase 1 scope amendment (2026-09-04)
The user authorized permanent Phase 1 scheduling suppressions under the committed 15-second policy. This supersedes the original full-inventory execution wording below. Keep every case implementation and historical outcome for Phase 2 testing/optimization; suppression is not deletion or a passing result.
The original 130 new timed definitions remain intact. The initial 14 suppressed scenario IDs remove 42 performance samples and their 42 associated verifiers from required Phase 1 scheduling, leaving 116 active new cases / 348 performance samples, plus 25 capped inherited samples. All 29 standalone proof recipes remain required. Any additional single performance sample exceeding 15 seconds of cumulative declared product time permanently suppresses that exact scenario across all seeds/repetitions and future Phase 1 sources. Preparation, standalone proofs and external cleanup are exempt. Still-active correctness, resource, custody and cleanup gates remain unchanged; #21 stays open.
Phase 1 completion amendment (2026-09-04)
The user requires functional failures to be repaired in Phase 1. The committed amendment supersedes earlier baseline-only closure and deferral wording below. Required functional, correctness, integrity, resource, safety-deadline and cleanup gates must pass before PHASE1_TERMINAL_PASS. Optional latency/storage optimization of correct operations remains Phase 2.
Preserve all original baseline failures and producing identities; record corrected candidate evidence separately. Fix shared causes and recollect only genuinely invalidated coverage. Do not shrink fixtures, omit cases, weaken oracles, raise budgets/timeouts or add benchmark-only bypasses. Keep affected family issues and #35 open until corrected execution and independent verification pass; #21 stays open for later phases/release.
Parent: #21
Problem statement
The twelve planned families need common registry, fixture and execution support. Rebuilding the harness or eagerly regenerating inputs for each case would make iteration slow and evidence inconsistent.
Goal
Publish/freeze the current specifications, then adapt the existing infrastructure so each family can be implemented and collect an authentic initial baseline. This is shared infrastructure work; it does not optimize the LayerFS product.
Work
- Commit and publish the twelve family specifications, shared testing rules, and relevant general-rule updates; replace planning-snapshot references with exact source links. Freeze the product baseline, harness identity, correctness/resource caps and finite diagnostic deadlines.
- Reuse the current binary, workload helper,
sdk_edit_common.rsgenerator/size labels, runner helpers andsdk-edit-custody.py. Share helpers when needed; retain one definition and thin adapter per family. - Add the bounded
workspace-shards-v1fixture, deterministic schedules and independent manifests; prepare only the selected case dependencies. - Reuse compatible binaries, images, fixture/oracle data and pristine Stores; per-key atomic publication, corruption/invalidation checks, independent sample copies, and explicit cold/cache-hit reporting remain mandatory.
- Support selected-case development, complete family performance, separate verification and explicit extended qualification. No default invokes all families or endurance.
- Preserve SDK-only routes and separately register authentic POSIX/tool routes. Required passive observability and verifier-only fault seams may be added with qualified provenance; no benchmark-specific product shortcut.
- Implement cardinality/route/timing/byte-bound self-checks and validators. Keep one result stream usable for latency, memory, dedup and preparation analysis; reports consume existing raw data.
- Keep inherited identities intact and specify the five capped-result growth replacements with new IDs/fixture hashes/family manifest before any capped execution.
Acceptance criteria
- Exact committed specification and baseline source links are available to every family child.
- Existing SDK families retain their semantics; the shared adapter can run a small selected smoke case without preparing all families/tiers.
- Cache hit/miss, invalidation, interruption/corruption, concurrent publication and sample-to-master isolation checks pass using existing mechanisms.
- Repeated warm-prepared command wall and first-use preparation are measured separately; budgets are recorded without hiding required work.
- Registry, sample counts, byte envelopes, authenticity, timing separation and cleanup self-checks work before family baseline collection.
- No product performance/storage optimization or cached post-operation state is introduced.
Files to read
docs/roadmap/0.1/0.1.3/testing-rules.md, docs/general/benchmark_rules.md, benchmark/fs-bench-pro/families/sdk_edit_common.rs, benchmark/fs-bench-pro/lib-edit-sdk-runner.sh, benchmark/fs-bench-pro/sdk-edit-custody.py, benchmark/fs-bench-pro/workload.rs, and the twelve family specifications.
Stage 1 boundary
Build the benchmark and retain its initial outcomes. Product algorithm, storage-format and performance optimization are deferred to Stage 2. Improve benchmark preparation/reuse and correct harness defects now; do not silently change the measured product to make results pass. Pin the unoptimized product identity and distinguish harness changes from product changes.
A slow result, product failure or timeout is an initial finding, not permission to lower a gate, drop a case or start tuning. Keep outcome, harness validity, verification, resources, cleanup and coverage completeness separate. Failed/invalid cases cannot support performance claims. Unimplemented cases, missing mandatory observations and unexecuted slots remain incomplete.
Planning specification snapshot — testing-rules.md
Source file: docs/roadmap/0.1/0.1.3/testing-rules.md. Local draft SHA-256: f3f33fec46ca1a0f05ef6f4257ac92796341c87324f0edf51a5f0793593da346. This snapshot is reviewable now; it is not a committed admission contract. The infrastructure issue must publish/freeze the source revision before implementation and collection.
v0.1.3 benchmark testing rules
Status: Current planning checklist; no v0.1.3 release candidate exists.
These rules govern implementation and execution of the twelve family
specifications. They extend the general benchmark rules (docs/general/benchmark_rules.md; planning file awaiting publication).
New workloads, selectors, fixtures, and result schemas are planned, not
implemented commands or measured performance guarantees.
Stage 1: build and collect the initial baseline
Stage 1 implements and qualifies the benchmark, then records initial outcomes
on a pinned product baseline. Product performance/storage optimization belongs
to Stage 2, after the consolidated baseline review. Reusing and improving harness
preparation, selection and reporting is Stage 1 infrastructure work; changing
the measured product algorithm to make a new result faster is not.
Freeze the family specification and issue, input/oracle identities, authentic
route, correctness/resource gates and finite safety deadlines before collection.
Implement the complete family, run its selected diagnostic, then collect all
prescribed initial samples and independent proofs, including required extended
members. Correct benchmark defects before calling the resulting evidence ready.
Do not silently fix or optimize the product during that collection.
A Stage 1 family issue may close when its benchmark is implemented and every
required case/subcase has an executed, reproducible, correctly classified
initial outcome with retained evidence. A product failure, timeout, unsupported
capability, or numerical miss is recorded as such and remains a failing release
gate. An unimplemented case, missing required observation, or unexecuted slot
is incomplete work, not a successful baseline. A supported-error oracle may
pass only for the exact documented capability contract.
Keep baseline collection completeness, harness validity, product correctness,
resources, cleanup and performance as separate statuses. Never turn Stage 1
issue completion into release admission or claim that a failed operation's
latency is eligible performance evidence. Preserve pre-fix failures; any later
product correction receives its own source identity and evidence.
The consolidated baseline report identifies measured bottlenecks, correctness
failures, preparation costs and coverage gaps. It proposes Stage 2 issues by
shared root cause and freezes performance targets before optimization. Do not
pre-create one optimization task per benchmark or tune fixtures/thresholds to
hide initial misses. The central release issue remains open beyond Stage 1.
One implementation path
Use benchmark/fs-bench-pro, its existing binary, and its shared workload
helper. Each family has one Markdown specification, one canonical definition
module when implemented, and one thin runner or existing compatible family
runner. Do not create a second benchmark crate, framework, cache service,
container manager, or independent report pipeline.
Reuse and minimally extend:
| Existing component | Reuse |
|---|---|
families/sdk_edit_common.rs |
Four sizes/labels, bounded deterministic byte generation, existing payload hashes and identities where the fixture matches |
lib-edit-sdk-runner.sh |
Family selection, explicit selected/full modes, performance/verification stages, supervision, cleanup and receipts; isolate SDK-specific route checks |
sdk-edit-custody.py |
Build/source seals, preparation compatibility, cache publication, acquisition, independent clones and manifests |
run-namespace.sh |
Existing namespace preparation/import lifecycle and inherited namespace controls |
workload.rs |
In-container ordinary filesystem workloads and bounded deterministic generators |
| Existing report generators and validators | Raw-data consumption, family completeness, provenance, phase summaries and independent verification |
A reusable part may move to a shared helper when a second family actually
needs it. Do not parameterize or copy the whole SDK editor into a generic
framework. Preserve all existing SDK scenario meanings and route checks.
SDK range-edit claims call the public singular or same-file batch API exactly
as declared. Ordinary filesystem/tool claims run the actual POSIX/FUSE workload
through public Exec. A same-file batch is not a multi-file API. No shell
reconstruction may substitute for an SDK edit; no SDK edit may silently
substitute for a tool's ordinary writes. Import claims perform actual public
LayerStack initialization. Report the observed route and call counts.
Size, units, tiers and seeds
Use binary units consistent with the existing fixture infrastructure:
tiers = [1, 10, 100, 500]
max_workload_file_bytes = 524288000 # 500 MiB, inclusive
max_workload_total_bytes_exclusive = 1073741824 # 1 GiB, strict
seeds = layerfs-v0.1.3-seed-1
layerfs-v0.1.3-seed-2
layerfs-v0.1.3-seed-3
Apply the file and total caps at every initial, intermediate and final workload
state. Count logical lengths, sparse holes, temporary replacements, generated
outputs, Git internals, conservatively each hard-link pathname, and live unlinked
inodes until their last handle closes. Deduplication
or compression cannot reduce this accounting. Use a precomputed transient
bound and verify it at relevant operation boundaries, not just final cleanup.
A 500 MiB file cannot be appended to under this cap without reserving headroom.
The cap covers the workload filesystem. Physical Store, spool, fixture caches,
verifier artifacts, binaries and logs have separate measured disk budgets;
do not call the logical cap a total host-disk bound. For the history family,
also bound the sum of logical retained snapshot sizes; its 1 MiB initial tree
and at most 500 new Commits represent at most 501 MiB.
Each curve names one tier unit: bytes, paths, shards, requests, variants,
episodes, or Commit count. Never form a size × operation-count × history-depth
Cartesian matrix. Count-based schedules are nested prefixes of one deterministic
maximum schedule; fixture generation may construct only the selected prefix.
The fourth tier is 500, not an inferred geometric tier of 1,000.
New timed IDs have three fresh samples, one per seed. Fixed-payload cases reuse
their existing byte identity; seed labels identify schedules/repetitions rather
than silently changing released payloads. Proof-only recipes declare their own
cohorts/subcases and normally run once; do not multiply every fault by four tiers.
Shared identical controls are registered and executed once and referenced by
other curves. No reused evidence gets a second scenario identity. Independently
verify each distinct admitted fixture/schedule variant. Repetitions sharing
that exact variant may reference its source-bound verification receipt; never
use one seed's proof for a different seed's input or reuse a proof after its
product/oracle identity changes.
Shared Workspace fixture
The new workspace-shards-v1 profile reuses the existing bounded byte generator.
For N shards and file ordinal j in 0..199:
| Ordinals | Files per shard | Bytes per file |
|---|---|---|
| 0..127 | 128 | 1,024 |
| 128..191 | 64 | 8,192 |
| 192..199 | 8 | 49,152 |
| Total | 200 | 1,048,576 per shard |
Thus tiers contain 200/2,000/20,000/100,000 files and 1/10/100/500 MiB.
Use zero-based shard index s; paths below are relative to the fixture root:
j < 64: wide/s{s:03}-f{j:03}.dat
64 <= j <199: regular/s{s:03}/f{j:03}.dat
j == 199: spine/d001/d002/.../d128/s{s:03}.dat
Prepare an empty dest/ directory. The spine uses the literal sequence of
128 short components and remains within the released path limits. The largest
wide directory has 32,000 entries, allowing repeated FUSE readdir-page evidence.
These paths replace, rather than add to, the 200-file shard population.
Additional family target files or directories must be explicitly accounted for.
Use file mode 0640, directory mode 0750, and mtime 1700000000.0.
Set directory metadata after children are constructed. For each file, define
frame(x) = len(UTF8(x))_le_u64 || UTF8(x) and
H = SHA256(frame(profile) || frame(seed_label) || s_le_u64 || j_le_u64);
use its first eight bytes as a little-endian state for
sdk_edit_common::fixture_block. Freeze all resulting hashes at fixture
admission; file identity must not depend on requested maximum N.
Stream in one reusable buffer of at most 1 MiB. Do not hash separately for
every output word or clone another shard's content to manufacture sharing.
For a 500-target operation schedule with declared domain D, rank indices
0 through 499 by SHA256(frame(seed_label) || frame(D) || index_le_u64),
break ties by numerical index, and take the first N entries. Operation kinds
and size/depth cycles use scheduled ordinal; file identity retains the selected
master index. A family may declare a different explicit schedule when its
work unit is a shard, variant or Commit, but must preserve nested prefixes.
Small selected runs prepare only the required shards. Count curves needing a
fixed large background reuse that qualified background across compatible runs.
Metadata/content scans and Workspace-locality cases share the same fixture
artifact when their complete identity matches. Hashes of the flat SDK payload
are not hashes of this multi-file tree, even though the generator is shared.
Make preparation reusable and lazy
- Resolve the selected case/seed/arm before building or preparing anything.
A selected tier must not silently build all four tiers or every family. - Reuse the compiled host binary, workload helper, and runtime image when
their exact source/build identity is valid. Rebuild only affected artifacts;
do not rebuild an image for a report-only edit. - Acquire immutable fixture bytes, manifests and independently constructed
oracle data by content/metadata/generator/profile compatibility. Reuse across
families and compatible source arms; family name alone is not a cache key. - Reuse a pristine initialized Store only when initialization is outside the
measured operation. Measured import/creation starts with a fresh output and
still reads, chunks, creates and publishes every required byte/path. - Use the existing per-key coordination and atomic publication. A missing,
interrupted, corrupt or incompatible entry is rebuilt, not partially reused. - Validate the sealed master once per acquisition/run. Give every sample and
writable qualification an independent copy or real COW clone, retaining its
required identity check. Never hard-link a mutable sample to the master. - Close Store connections and quiesce artifacts before sharing them. Cache
eviction is explicit maintenance; ordinary sample cleanup removes its own
resources and leaves shared pristine entries intact. - Cache static expected manifests/chunk transcripts when their full oracle
identity matches. Always verify actual candidate outputs; never cache a
passing result, post-operation Store, live Workspace, reader cache or history. - Generate expected bytes by streaming; do not materialize full expected copies
per sample when a streamed digest/manifest suffices. Prepare dedup files
independently; input caching does not authorize reflink-manufactured sharing. - Keep preparation workers bounded and idle during product timing. Default
performance concurrency is one. Parallel preparation/verification requires
disjoint resources and a declared limit; it must not contaminate measured
CPU, disk, cache, memory or container capacity.
Record acquisition/hit/miss, compatibility key, producing source, validation,
generation, oracle construction, Store initialization, clone/copy method and
wall, build/image reuse, temporary disk high water, and cleanup separately.
Report first-use and cache-hit command wall so preparation improvements remain
visible. Reuse does not make hashed or cloned inputs cold; preserve the declared
cache policy on both source arms.
Fast selected loop and complete qualification
| Lane | What runs | Runtime policy |
|---|---|---|
| Static self-check | IDs/counts, tier algebra, byte bounds, route/timing contracts, schema applicability | Product-free and small; no full fixtures or Docker |
| Selected development | One case, seed and arm; cheap status/count checks plus the focused regression check | Ordinary warm-prepared command aims for 1–5 seconds; diagnostic, never full-family admission |
| Family performance | Complete unique case set and prescribed samples; performance only | Ordinary families aim for tens of seconds; publish actual wall and classify expensive families explicitly |
| Family verification | Exact bytes/metadata, intermediate observations, reopen and resource proofs | Separate mode, receipts and deadlines; can take longer than performance |
| Extended qualification | Large history trajectories, spill/admission-boundary faults, sustained sessions | Explicitly selected; full release qualification must include required extended cases |
These are development objectives, not invented latency guarantees. Before any
measurement, freeze correctness/resource bounds and diagnostic timeouts; after
an untouched baseline, freeze numerical performance targets and final deadlines
before candidate optimization or sampling. Every family must bind selected,
full-performance and verifier deadlines independently. A selected timeout is
not a reason to discard a valid slow result or inflate an algorithmic bound.
Warm-prepared command wall includes acquisition/validation/cloning, required
fresh process/container readiness, workload, minimal receipts and cleanup.
One-time build/preparation is shown separately, not hidden in the user-visible
wall. A 500-Commit case cannot inherit a 1–5-second promise from a tiny edit.
The loop is: self-check → smallest selected failing case → inspect phase and
work counters → fix shared cause → rerun focused check and selected case →
expand only to the siblings needed to resolve remaining risk. Do not repeatedly
run already-passing families, all tiers, or the full verifier after each edit.
Run complete affected families when the candidate is ready, then one final
release qualification. A later relevant source change requires affected evidence
to be recollected; old results remain retained with their original source.
Use the existing explicit selected versus --all and performance versus
verification stages as the implementation starting point. New family command
names must be labeled planned until implemented. No default command may launch
all twelve families or an endurance run. An ordinary-lane pass cannot stand in
for complete admission if extended members remain outstanding.
Pure timing, verification and result reuse
Performance invokes only the declared authentic workload, its acknowledgement,
and named lifecycle operations. Measure inner workload, aggregate SDK calls,
Commit, End and complete product lifecycle separately where applicable.
No added benchmark digest, tree oracle, object census, Store reconnect,
materialization or fault injection runs in the performance phase. Intrinsic
product/tool work, including CAS hashing/authentication and Git object hashing,
remains inside its declared timing boundary; the zero-verifier counters do not
mean disabling those operations. Cheap exit/status/count checks
may reject an incorrect result immediately. Actual verifier failures block
admission even when already-collected performance samples remain valid.
Verification uses a separate run/state and compares all paths against an
independent expected manifest: type, logical size, streamed bytes, mode, exact
controlled timestamps, link equivalence classes and symlink targets. Include
unchanged paths and intermediate observations when final operations cancel.
Reuse a common verifier; use failure-specific cohorts without weakening checks.
For tool-generated platform-dependent metadata, such as Git index inode/stat
cache fields, a family may explicitly combine independent semantic/format
expectations with complete pre-Commit-to-reopen byte/metadata custody. It must
identify those fields, keep source bytes and semantic outputs independently
specified, check every path, and label the custody receipt as persistence
evidence rather than an independent oracle. This exception does not allow
candidate-produced roots or receipts to define their own expected semantics.
Collect latency, work counters, memory, FUSE traffic and incremental receipts
from one workload execution. Let several analyses reference the same sealed
row. Expensive chunk/Store census belongs in separately attributed verification;
do not rerun the identical workload solely to populate another report. Never
count a shared control twice or treat a reused row as an independent sample.
Derive reports solely from sealed raw evidence. Do not rerun a successful
campaign because Markdown or a chart changed; recompute its report. A changed
workload, oracle, relevant product code, environment or timing definition does
require the appropriate new evidence or scenario version.
Inherited evidence and release scope
The released three SDK edit families retain their meanings. Five 500 MiB
length-growing rows exceed the new result-size cap and need versioned bounded
replacements before future capped execution:
insert/append/prepend/zero-extend 4 KiB: input 524283904, result 524288000
replace middle 2 KiB with 4 KiB: input 524285952, result 524288000
Prepare shorter deterministic prefixes outside timing; retain the singular
public call. Version IDs, fixture hashes, plan hashes and family manifest;
never relabel the originals or claim an exact 500 MiB input. Other inherited
rows keep their own repetitions, schemas and disposition. The previous
POSIX/temp-copy edit families remain archival and do not return as SDK evidence.
Single-Branch retained-history storage growth is now v0.1.3 scope. Multi-Branch
sharing, fan-out, Add/promotion, competing heads and broader history-query
scaling remain v0.1.4. Count actual new retained Commits, not UpToDate attempts,
when computing represented-history bytes. Dedup ratios must distinguish
within-operation coalescing, preexisting chunk reuse, borrowed unchanged
references, canonical metadata, and actual SQLite footprint.
The released storage profile
guarantees live-process transaction semantics, not crash/power-loss recovery.
These benchmarks cannot upgrade that guarantee by testing orderly reopen.
Admission checklist
- One canonical file/module/runner per family; shared infrastructure and input
preparation reused; no duplicated framework or cached measured result. - Explicit case/seed selection, complete-family opt-in, and separately selected
expensive qualification; all required members eventually included. - Size/transient bounds, exact fixture/schedule/oracle identities, public route,
CPU/memory/disk caps, and independent phase deadlines fixed before admission. - All prescribed samples/subcases retained; no retries to select favorable time.
- Independent full-state and relevant intermediate verification; source-bound
correctness, resource, cleanup, custody and performance statuses all present. - Reports show preparation and command wall as well as product timings; a fast
inner call is not reported as a fast entire test.
Activity
yifanxuaaa commentedon Sep 4, 2026
The Phase 1 contract is now committed and published at
de27a847489ffec56429673d712503ae8ea7e8ec:Live issue snapshots and current local specifications were reconciled before implementation. Membership remains 130 timed cases / 390 initial slots, the CDC boundary proof and 28 reliability subcases. Product baseline is
1e81e9b8cf871324341c221a51b0a0239c580da9; product optimization stays in Phase 2. Unrelated working-tree content and running containers are preserved.Shared implementation/qualification is now in progress. No initial samples or proofs are claimed yet. This issue remains open until its implementation and evidence criteria are met.
yifanxuaaa commentedon Sep 4, 2026
Progress toward Phase 1 terminal pass on the user-authorized8-CPU Docker VM:
7948df2d. Benchmark containers still have the existing2-CPU/2-GiB caps; no deadline, fixture or correctness gate was relaxed.tiny-stat-1, seed1, check passed:6.916s runtime,13.895s complete sample,15.862s CLI invocation. The retained exhaustive reference was170.565s runtime/177.173s per sample. Observed sample time was12.75× lower; this is a different assurance profile, not a controlled product-performance comparison.fast_iteration_verifiedreceives zero exhaustive verification credit.-37 compatible VM8 full proofs and the separately identified completed600-second proof are retained.344 further full checks remain for the matching cohort, including the small payload proof needing the current environment.
-[v0.1.3][Stage 1][04] Build and baseline git workflow in a populated workspace #26 is closed under the explicit four-case Git runtime-suppression scope. It is not a claim that suppressed Git exhaustive checks passed. [v0.1.3] Benchmark-first Workspace and CAS/CDC roadmap #21 stays open.
Contracts: verification profiles, VM8 admission cohort.
Fast attempt
tiny-stat-1-s1-fast-verify-4173c0ddecb8and its independent validation are preserved locally under the campaign evidence directory; their artifact publication is queued for the next non-measurement checkpoint. This issue remains open until the applicable terminal evidence gates pass.yifanxuaaa commentedon Sep 4, 2026
VM8 performance collection is complete: 373/373 active samples have raw PASS outcomes, with supervisor and mutable-sample cleanup PASS for every sample. The independent admission selection checkpoint passed; final report validation and 344 outstanding full checks remain. No terminal pass is claimed.
Published checkpoint: 3753870bc, including source-bound raw evidence and selection receipt and qualified fast-profile results and limits.
The 8-CPU VM retains 2-CPU/2-GiB per-container caps. Samples totaled 1,751.250 seconds including 1,062.159 seconds of preparation. All14 authorized exact-case suppressions remain explicit, never passing coverage. Both cache-cap preparation failures and selected successful retries are retained.
The final campaign will reuse37 completed VM8 full proofs plus the original source/environment-bound600-second standalone proof. Fast verification has zero full-gate credit. A verifier-only direct authenticated inode traversal retains all full byte, metadata, alias, namespace and typed-census checks; its scoped build and small qualification are next. Product timings remain sourced to7948; no performance recollection is needed for that verifier-only change.
Remaining children stay open until their mandatory checks pass. Central#21 stays open for later phases.
yifanxuaaa commentedon Sep 4, 2026
Shared infrastructure validation: PASS. This closes #22 only for its specified infrastructure deliverables. The live acceptance criteria require committed contracts, an authentic selected adapter, cache correctness, separately measured preparation/command wall, working validators and unchanged product/fixture semantics. They do not require all outstanding family full proofs to finish before this infrastructure issue closes.
Evidence against those criteria:
de27a847and product baseline1e81e9b8. Current infrastructure contract, runtime-suppression and VM8 amendments preserve the original definitions and make scope changes explicit.The metadata aggregate and exact source binding are now passed and published. The sealed binding receipt retains373 independently qualified performance samples and41 completed full proofs with original source/environment identities. No performance rerun or broad repeat qualification was needed.
The broader campaign remains separate: full verification must reach all 382 required slots under the current suppression/VM8 policies. Outstanding family checks continue under their children and #35; neither
fast_iteration_verifiednor this infrastructure closeout fills those slots. Git #26 is already closed under explicit suppression, and #23 has its family-specific evidence. Keep #21 open for Phase 2 and release qualification.yifanxuaaa commentedon Sep 4, 2026
The user has amended Phase 1 acceptance: qualified fast verification is sufficient for routine benchmark verification. The published amendment supersedes earlier comments requiring every routine exhaustive proof before closure. The reference qualification contract preserves independent expected states, affected-content/metadata/alias/absence checks, authenticated references and deterministic witnesses.
The posted performance results remain valid at their original source/environment identities. Completed full proofs remain accepted and are reused. At the scope checkpoint,48 routine slots already had full proofs; the305 unrun routine exhaustive counterparts are now deferred to Phase2 while their qualified fast checks are implemented and collected. Fast evidence keeps its actual assurance and explicit skipped coverage; it will not be labelled
fully_verified.Required targeted reliability checks, the CDC boundary proof, exact expected-error oracles, resource and cleanup gates still apply. Observed failures still require focused repair confirmation. The already-qualified600-second proof is retained rather than repeated. This amendment does not manufacture missing evidence or itself establish terminal pass.
Remaining routine families will close after their accepted fast/full coverage and applicable gates pass. #21 remains open for later phases and release.
yifanxuaaa commentedon Sep 4, 2026
Phase 1 is closed under the user's explicit withdrawal of all remaining verification tests. This is a scope withdrawal, NOT a claim that the original verification terminal criteria passed.
The assistant designed an excessively expensive verification suite and spent too long expanding it after the user requested a much faster finish. That design is withdrawn and must be reassessed in Phase 2. No more verification work is scheduled.
Final performance results:370 independently qualified active observations, with actual source identities and unoptimized timings. All15 suppressed case definitions, original failures and incomplete attempts remain preserved. Completed29 targeted proofs,48 routine full proofs and qualified fast evidence remain historical evidence; unrun verification is withdrawn/deferred, never relabeled passing.
Explicit withdrawal and accountability record. Separate Phase 2 backlog. Central#21 stays open for Phase 2/release. No release tag was created.