Beagle SCM

GET-050: get must stamp carried/woven files by PATCH's band rules — stale put stamps false-clean them

RULING (gritzko, chat 2026-07-19): GET uses the SAME stamping rules PATCH uses for merged files (the DIS-057 band) — the follow-up GET-049's constraint explicitly anticipated ("route merge outputs to the DIS-057-style band"). Today a bare get that carries an uncommitted edit leaves the file wearing its OLD put row's restamp; that ts stays in the wtlog stamp-set, so the STATUS-011 has(mtime) fast path validates the file clean against a base that moved — dirt that status and bare diff HIDE, and a post would silently not commit.

Input

Context

Incident 2026-07-19, work/STATUS-016: wtlog put shared/wtlog.js (row 26719BQw09, BE-011 restamp → mtime 11:26:59.009), then a user bare get ///be/#27d03a26 (row 26719BkGEg) carried the edit per GET-048 §4.

• Post-get jab status | cat and bare jab diff | cat read the tree CLEAN; targeted jab diff shared/wtlog.js prints the full delta vs base — the discrepancy.
• Mechanism: the carry didn't rewrite the file (mtime still the put restamp); the put row fell below the new get floor (de-staged, out of classify scope) but its ts remains in the stamp-set, so the fast path answers "clean" — a stamp only means "bytes unchanged since row X", never "clean vs the CURRENT base".
• Control: files get DID write carry the get row ts (views/work/work.js mtime 11:47:16.939 == get ts) — GET-049's clean-overwrite leaf works.
• PATCH's band rules (shared/classify.js:179-192 patchStamps, DIS-057): row ts = band CEILING, merged files stamped ceil-2ms (pat clean apply), ceil-1ms (mrg weave), ceil (cnf); the outcome rides the stamp offset, zero content reads.

Goals

After ANY get, no file can read clean while differing from the new base: carried/woven outputs are stamped into a DIS-057-style band under the get row's ceiling and classify buckets them by offset.

• Repro RED first: put an edit, bare-get a diverged/advanced target that carries it → today status+bare diff read clean; must read the carried file dirty (wt column v per Status; conflict carries !).
• Stamp legs: carried-unchanged-by-get (the incident: restamp to the band even without a rewrite), woven output, conflict output; clean-overwrite keeps the GET-049 row-ts stamp.
• Reuse PATCH's stamping helper and generalize the classify band reader (patchStamps) to get rows — one band vocabulary, no parallel implementation.

Constraints

• No log read-back: the band derives from be.now / the assigned row ts returned by ulog.append (GET-049/POST-029 discipline); row appended BEFORE stamps (ULOG refuses ts<=tail).
• Stamping side is shared with the patch verb — extend, don't fork; status stays read-only (band reconstruction at read time, as patchStamps does).
• Whether the get should ALSO preserve the staging (the put row got out-scoped) is a separate question — this ticket only guarantees the dirt is visible; don't change put/post semantics.
• GET-048 reset semantics and STATUS-016 patch-floor scope are in force; expect a weave with work/STATUS-016's staged wtlog.js.

WIP

Design decisions

• Root cause is the merkle-PRUNED carried file: a put-staged file identical in old+new base is skipped by the reconcile, keeping its put restamp — still in the whole-log stamp-set (has() is not floor-scoped), so STATUS-011 reads it clean vs the advanced base. Woven/conflict legs DID rewrite (visible), so the incident is specifically the un-rewritten leg.
• Get band = the SAME DIS-057 band, laid UNDER the get row's ceiling (=stampTs, the GET-049 clean-overwrite stamp, stays ok via has()): ceil-1ms mrg (wt v), ceil-2ms con (wt !). The ceiling is NOT registered — clean overwrites keep it. In practice stampTs >> the prior tail (separate procs), so the below-ceiling band never collides with a real row ts; the same 1-2ms collision edge GET-049 already noted (cosmetic).
• Stamping side (get.js): a bandStamp(g,full,outcome) twin of trySetMtime; the leaf weave leg stamps mrg (or the ceiling when the weave reproduced the target), the three conflict legs stamp con. The pruned leg is caught by a terminal carrySweep: collect every pre-get put path (all de-scoped by the just-appended get row), and for each NOT visited by a leaf, restamp to the band iff still dirty vs the new base. No log read-back — the band derives from g.stampTs (the ts ulog.append returned); row appended before stamps.
• Classify side: patchStamps EXTENDED (not forked) — after the patch rows it registers the recentmost get row's {ceil-1:mod, ceil-2:con}; scoped by boundaries().pd so a consuming post ends it. Read-time only; status read-only.

TODOs

• red repro: put → carrying bare get → status/bare-diff hide the dirt (test/get/carry-stamp)
• band stamping in get's carry/weave/conflict legs (bandStamp; carrySweep for the pruned leg)
• classify: generalize the band reader to get rows; quad reads ...v / ...!
• green: incident shape shows the carried file; GET-049 stamp legs + suites stay

Blockers and bummers

• The de-scoped put row itself is left below the get floor (out of scope per the ruling — put/post semantics untouched); only the DIRT is made visible.
• Pre-existing unrelated red: test/work/getctx (pty frame goldens) fails IDENTICALLY on the pristine baseline — verified, not touched.

Outcome

LANDED 64525364 (2026-07-19 12:42, "GET-050: get must follow same rules for merged files as patch"); work/GET-050 clean at tip. The DECISION-side hole (stamp false-clean at get's pending check on a base-moved file → clean-overwrite discard) is split out as GET-052.

Original staging note (historical):

Changed (staged):

• shared/classify.js — patchStamps also opens the recentmost get row's band {ceil-1:mod, ceil-2:con} (pd-scoped); the ceiling stays the GET-049 ok stamp.
• verbs/get/get.js — bandStamp helper; leaf weave/conflict legs restamp to the band; collectStaged+carrySweep (finalizeGet) restamp de-scoped, still-dirty PRUNED carried files; g.seen skips leaf-handled paths.
• test/get/carry-stamp/run.sh — NEW case (test submodule): put f.txt, advance a diverged mover g.txt, bare-get → f.txt (pruned) reads ...v + bare diff lists it; clean g.txt stays unlit. Glob-registered (no CMakeLists edit).

Evidence: manual repro RED (post-get status/bare diff EMPTY for f.txt, only targeted diff f.txt showed it) → GREEN (...v f.txt, bare diff lists it). Suites green: test/get/* (35 pass / 6 env-skip, GET-049 stamp + weave/conflict incl.), test/status/* (12), test/patch/* (26, stampband incl.), test/work/view, statusfast.js, patchband.js. Pre-existing unrelated red: test/work/getctx (pty frame goldens — identical FAIL on pristine baseline).

Suggested commit message: