Repository navigation
Description
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
Depends on: #22 (shared infrastructure and committed specification).
Problem statement
LayerFS needs an authentic initial baseline for git workflow in a populated workspace before deciding product improvements.
Goal and family scope
Run the complete offline Git workflow over a 32 MiB background, including real editor-save replacement and exact Git/LayerFS verification.
Inventory: 4 new timed cases, 12 prescribed initial performance sample slots, and 0 standalone proof recipes. The canonical planning file is docs/roadmap/0.1/0.1.3/git-tool-workflow.md. The snapshot below makes the current proposal reviewable until its committed revision is published.
Stage 1 work
- Freeze this family and its exact fixture/schedule/oracle identities under the shared contract; implement its complete membership in the existing harness with one canonical definition and thin adapter.
- Qualify route, call counts, size/resource bounds, independent oracles and selected-case self-checks. Resolve harness defects before collecting baseline evidence.
- Run one selected case/seed to establish a valid execution path, then collect every prescribed initial sample and separate proof variant on the pinned unoptimized product. Required extended cases are explicit but remain required.
- Retain raw failures/timeouts as classified product findings. Keep setup, performance, verification, cleanup and external command wall distinct.
- Produce a source-bound family report with all outcomes and measured questions for later optimization; do not tune product algorithms within this issue.
Acceptance criteria
- Complete family implementation, unique IDs, exact counts, deterministic fixtures/schedules and independent oracle checks.
- Committed specification and product/harness/build/runtime/input identities linked in the evidence manifest.
- Every required case/subcase executed with a retained initial outcome; no missing mandatory counter, unimplemented member or silent skipped slot.
- All prescribed valid sample repetitions retained, with separate independent verification of distinct input/schedule variants. Failed/invalid outcomes remain explicit and ineligible for performance claims.
- Preparation reuse, per-sample isolation, byte limits and cleanup checked; actual first-use/cache-hit command wall reported.
- Family baseline summary delivered to the consolidated report issue; known product failures remain failing release gates and are recorded for Stage 2.
Files to read
docs/roadmap/0.1/0.1.3/git-tool-workflow.md, docs/roadmap/0.1/0.1.3/testing-rules.md, docs/general/benchmark_rules.md, and the existing source/test references in the specification below.
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.
Shared execution rules
- Reuse
fs-bench-pro, existing generators, runner helpers, custody, qualified pristine inputs, independent writable samples and reports. Add only needed family adapters. - Use 1/10/100/500 of the declared unit; no Cartesian size/count matrix. Each workload file is at most 500 MiB and aggregate logical content is strictly below 1 GiB at every intermediate state, including temporary files and Git internals. Physical Store/spool/cache budgets are separately reported.
- Resolve the selected case/seed before preparation. Reuse compatible artifacts; prepare only required inputs. Measured creation/import/history must still execute all work.
- Iterate one selected case and seed; ordinary warm-prepared 1–5 second command wall is a target to qualify, not a blanket guarantee. Required extended cases are explicitly selected and cannot be omitted from complete baseline coverage.
- Separate performance and verification. Added benchmark hashes, full manifests, reopen and fault injection stay outside performance timing; intrinsic CAS/Git hashing remains measured.
- Collect several metrics from one execution and regenerate reports from raw evidence without rerunning successful workloads. Retain all valid results and failures, with exact source, fixture, oracle, runtime and cache identities.
Planning specification snapshot — git-tool-workflow.md
Source file: docs/roadmap/0.1/0.1.3/git-tool-workflow.md. Local draft SHA-256: 88f68d628508c8f27400879fe6b88ec413ccf17d0b33d0b78e3f210b15d2a1c1. 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.
Git workflow in a populated workspace
Status: Current v0.1.3 planning specification; no release candidate or
measured result is implied.
Family ID: git_tool_workflow. This v0.1.3 implementation contract contains
4 new timed cases and no standalone proofs. The family adapter is not
implemented yet.
Purpose and lifecycle
Exercise an agent's ordinary local Git workflow inside a populated repository:
edit files, inspect changes, stage them, create a Git commit, publish a LayerFS
Commit, and reopen the repository. Git uses ordinary POSIX/FUSE operations;
these results make no claims about singular SDK range-edit latency.
Follow the shared testing rules (docs/roadmap/0.1/0.1.3/testing-rules.md; planning file awaiting publication) for seed identities,
preparation reuse, source and Git-binary custody, samples, timing, byte caps,
and independent verification. Each sample starts from a sealed existing Git
repository imported into one genesis Layer and Branch. Public Workspace
Create/managed execution/Commit/End operations surround one offline Git workflow
through real FUSE. There is one new Git commit and one final LayerFS Commit,
followed by a separate fresh-Store and fresh-mount verifier.
Cases and bounded fixture
Expand N over exactly 1, 10, 100, 500 to obtain four scenario IDs:
| Scenario IDs | Changed paths | Expected result |
|---|---|---|
git-tool-{N} |
First N changes from the same seed-bound schedule | One new Git commit and Created LayerFS Commit |
Every tier has the same substantial 32 MiB tracked background, distributed
across 32 shared-profile shards with 6,400 files. Reuse the bounded shared
generator, path manifests, wide-directory layout, and deep-path witness. The
background remains unchanged and must participate in full Git/LayerFS state
verification. A separate 500-slot change schedule uses domain git-tool-workflow.
Smaller tiers are exact prefixes of its ordered changes.
Each ten-slot block uses:
modify, add, delete, modify, add, delete, add, modify, delete, modify
Modify/delete targets are present in the initial commit; add targets are absent.
All targets contain unique deterministic 2,500-byte files. Every modification
changes ten deterministic bytes at a sealed interior offset without changing
the final length. Number only modify slots with zero-based ordinal m:
- Even
muses an editor save: read the original 2,500 bytes, apply the planned
ten-byte change, create a deterministic exclusive temporary sibling, write
all 2,500 result bytes, set the required mode,sync_all, close, and rename
the temporary file over the original path. - Odd
muses an ordinary in-place ten-byte write to the existing file.
Temporary names are .{original_basename}.save-{m:03}.tmp. Saves run serially,
so at most one extra 2,500-byte temporary file exists. Both routes execute
through POSIX/FUSE inside the measured apply phase and yield the same independent
logical ten-byte edit oracle; neither route calls the SDK range-edit API.
Use separate tracked/modify-*, tracked/delete-*, and added/add-* paths.
The 500 tier modifies 200, adds 150, and deletes 150 paths; the initial tracked
change-target payload is 350 × 2,500 = 875,000 bytes. Its modifications contain
100 editor saves and 100 in-place writes. The one-change tier exercises an
editor save, and all routes preserve the shared nested schedule.
The ordinary working tree stays below 34 MiB, including the additional 2,500
bytes while an editor-save temporary file coexists with its original. Budget
the complete repository at no more than 256 MiB at any intermediate point,
including .git objects,
index, refs, logs, temporary and lock files, and deleted-but-open files. No
individual workload file may exceed 500 MiB, and the shared strictly-under-1-GiB
limit still applies. Freeze a conservative object/index/temporary allocation
bound with the pinned Git version and verify the repository census; never
assume Git compression or CAS sharing makes a larger fixture admissible.
Preparation and verifier copies stay outside the workload namespace and have
separate resource accounting. No pack/repack or automatic maintenance is run.
Exact measured workflow
Apply the scheduled ordinary filesystem changes, then run:
git status --porcelain=v1 -z
git diff --no-ext-diff --binary --
git add -A --
git diff --cached --check
git commit --no-gpg-sign --no-verify -m "layerfs v0.1.3 tool workflow"
git status --porcelain=v1 -z
Pin the Git binary, author/committer identity and timestamps. Disable system
and global configuration, hooks, signing, optional locks, automatic line-ending
conversion, credential helpers, network access, and background maintenance.
Retain the effective configuration. Required index/ref locks remain part of
Git's ordinary writes. The process must complete before LayerFS Commit.
First status includes the exact modified/added/deleted target set; expand
untracked-directory entries or configure status.showUntrackedFiles=all so
porcelain does not collapse added files. Before staging, ordinary git diff
contains only the tracked modify/delete changes: it must not be incorrectly
required to include untracked added files. The independent staged-tree oracle
and final Git commit must include all scheduled changes.
Timing and verification
Record separate apply, first status, diff, add, cached-check, Git commit, final
status, LayerFS Commit, visibility, End, and complete lifecycle walls. Account
for subprocess startup and output handling inside the workload. Fixture Git
initialization, fixture import, source sealing, and exhaustive verification
remain outside operation timers and have separately reported walls.
Report editor-save and in-place counts and apply-phase costs separately.
Git's own object hashing remains authentic tool work; extra reporting digests
and full repository/transcript verification run outside performance timing.
Record changed/unchanged path counts, bytes, output digests, FUSE operations,
Git processes, CPU, memory, swap/OOM, logical/physical I/O, Store/object growth,
repository byte peaks, and cleanup under the shared schema. Do not claim that
N changed paths equals N total filesystem calls: Git also reads metadata and
writes its own repository state.
The separate verifier uses an independent expected source-tree manifest and
reference Git tree/commit prepared outside product timing. Verify exact first
status, tracked diff paths/content, staged tree, cached check, empty final
status, and one new commit with the expected parent/tree/message/identity/time.
In verification mode, observe each editor save after temporary sync and after
rename: require the exact replacement bytes, bounded coexistence, and removal
of the temporary pathname. Verify the in-place routes against the same logical
edit oracle, and require no leftover save file in any final repository state.
In the verification execution, seal a complete repository receipt before
LayerFS Commit and compare it after fresh Store reconnect and real-FUSE remount,
before running any Git command that might refresh the index. Then run
git fsck --strict and repeat clean-status/tree checks. The source-tree manifest,
Git tree, commit, and required object identities have independent expected
values. The receipt additionally proves persistence of every repository file,
its bytes, mode, and timestamp; it is custody evidence, not an independent
content oracle. A native reference's index bytes are not an equality oracle
because inode/stat-cache fields legitimately differ. Authenticate the LayerFS
canonical root and Branch head, unchanged background, size envelope, and
cleanup. No semantic expectation is inferred solely from the product receipt.
Execution and completion
Three fresh performance samples per new case produce 12 timed executions;
every case has separate independent verification. Cache the sealed initial
repository and prepared input Store, then use existing sample-clone isolation.
Every measured sample still performs its own edits, Git workflow, and LayerFS
Commit. Reuse the benchmark binary, workload helper, runner, custody, and
report machinery; no new benchmark framework is needed.
Prospective selection is git-tool-1 with one seed and its focused verifier;
this selector is not implemented yet. A 1–5-second selected-run target is
provisional and depends on the baseline. Larger tiers, full families, and
complete fsck/manifest verification use the longer lane with baseline-derived
budgets. Completion requires all four case identities and samples, exact Git
and LayerFS proofs, bounded resources, and clean teardown.
The historical git init + commit 100 files shell control keeps its original
identity, meaning, timing, and evidence separately; it is not a fifth case.
Activity
yifanxuaaa commentedon Sep 4, 2026
Phase 1 implementation is complete under the user-authorized runtime-suppression amendment. All four Git cases remain implemented with their frozen fixtures, real Git/POSIX/FUSE route, metadata work and independent verifier. All four are permanently excluded from Phase 1 scheduling and retained for Phase 2 testing/optimization.
This closes the benchmark-construction issue under the amended scope. It does not label the suppressed Git family or its unexecuted exhaustive verification as passing. The 12 clean-source historical performance outcomes and earlier failures remain source-bound evidence.
Published implementation
Authoritative suppression scope
Separate Phase 2 backlog
git-tool-1: retained seed-1 evidence.git-tool-10: retained seed-1 evidence.git-tool-100: retained seed-1 evidence.git-tool-500: retained seed-1 evidence.Central #21 remains open. Consolidated active-family collection and mandatory verification continue under #35.
yifanxuaaa commentedon Sep 4, 2026
Performance-results checkpoint for #26: 0 independently validated active VM8 performance samples. The report validates 0 retained full proof(s) for this family at this checkpoint; further full checks are running. This comment does not claim global Phase1 terminal pass.
Published report, exact rows, source identities and verification status, phase/counter evidence.
VM8 performance source:
7948df2de269e5ffd47a232ffd8091ff83f8869f; fixed 8-CPU Docker VM, unchanged 2-CPU/2-GiB benchmark-container caps. No VM4/VM8 timing pooling. Every listed performance row passed the independent authenticity, custody, observation, resource and cleanup validation; workload admission still requires its separate full proof.All four Git cases are permanently disabled for Phase1 under the explicitly approved cumulative-time policy, so there is no active VM8 performance cohort to claim. Their benchmark implementations and original definitions remain intact for Phase2. #26 stays closed under that suppression disposition, not a claim of passing full Git verification.
Retained original VM4 observations remain in the report’s historical source inventory; no fresh execution or favorable reroll was performed.
Explicit Phase1 suppressions (not passing coverage):
git-tool-1,git-tool-10,git-tool-100,git-tool-500. Definitions, historical failures and incomplete attempts remain retained for Phase2.All prior actual failures, source incompatibilities, invalidations and preparation interruptions remain in the linked report and raw evidence. The fast development verifier contributes zero full-verification credit. Completed family tickets will close only after their remaining mandatory full checks pass; #21 remains open for later phases.
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.