Beagle SCM

PUT-010 DONT: sub-crossing multi-path put is O(N²) — prep + wtlog rewrite PER ARG; batch repo-wise

jab put html/todo/*/*.html (733 sub-crossing args, journal root authority) took 10s; the identical files staged as FLAT args in a scratch clone take 0.18s (55x). PUT-007 hoisted the engine prep + made ONE wtlog write per batch — but only for flat args: stageInSub (be/verbs/put/put.js:513) still runs the whole cycle per arg. Fix = the same PUT-007 treatment, repo-wise: group args by their resolved repo (parent or sub), prep ONE engine and commit ONE wtlog write per repo.

Input

Context

Incident 2026-07-17, :put html/todo/*/*.html from the journal tree, 10s wall-clock, 13ms/arg. Per sub-crossing arg, stageInSub does:

• store.open(subRepo.storePath, ...) — fresh reader per arg (maintain memoized per instance only).
• stage.prep(subRepo, wtlog.open(subRepo), subK) — the whole-wt rescan PUT-007 hoisted for flat args, re-done per arg.
• commitOps → appendAndAssign (put.js:216) — ulog.each reads the whole wtlog, ulog.write REWRITES it whole + unlinks the idx sidecar; the log grows 1 row per arg → quadratic bytes.
• putOne already returns flat-arg rows for ONE batch commit; sub-crossing args bypass that return path ("commit to the sub's own wtlog and return no parent ops").

Goals

733 sub-crossing puts cost ~1 flat batch (sub-linear in args): one stage.prep, one store.open, one wtlog append per DISTINCT repo touched by the arg batch.

• Repro first: N sub-crossing puts vs N flat puts, assert bounded ratio (or count engine preps / wtlog writes via hook — must be per-repo, not per-arg).
• Group args by resolved (sub)repo — SUBS-051 nested-mount descent still decides the repo per arg; only the ENGINE and the COMMIT are shared.
• Output order/banner rows byte-parity with today (rows still print in arg order under the shared put: banner).

Constraints

• BE-049 gitlink-bump rows (put <sub>#<tip>, arg names the sub itself) and SUBS-051 nested descent keep exact semantics; bump stays ONE row per sub per batch.
• appendAndAssign's ts policy (nowAfter(tail), +1 per row, restamp to row ts) is unchanged — one call per repo instead of per arg.
• PUTNONE stays a whole-batch decision (JAB-004 tallies on ctx); per-arg skip reporting unchanged.
• Minimal diff in verbs/put/put.js (+ shared/stage.js only if prep sharing needs it); no other verbs touched.

WIP

Design decisions

• Per-repo groups ride ctx._putSubGroups (key subRepo.bePath): ONE store.open + stage.prep per sub; stageArg ops accumulate.
• putRun flushes ONE commitOps per group after the arg loop, before the parent batch commit (per-arg wtlog order kept).
• BE-049 bump stays INLINE, not at flush: the pin==tip guard already dedups per batch; flush would break arg-order output.
• RULING 2026-07-17: ms>999 rons are VALID ts numbers; ts+1n cohort stepping stays (POST-029/GET-049 keep it in ulog.append).
• The ron->TIME conversion maxes ms at 999 (native RONToTime already clamps): ulog.ronMtime helper + ronToMs clamp; wtlog .has() also keys each row's MATERIALIZED (ms-maxed) stamp.
• ctx.T0 = the be.now precursor (RULING 2026-07-17: one per verb invocation): every group flush shares it, none samples its own.

TODOs

• Repro/perf test: sub-crossing batch put counts ONE stage.prep + ONE wtlog write per repo (hook-based, RED on current code).
• Cache per-repo {subRepo, wtlogReader, storeReader, engine, ops[]} across args in putRun; flush commits repo-by-repo after the arg loop.
• Keep BE-049 stageSubBump once per repo (inline pin==tip guard, see Design); verify SUBS-051 nested mounts land in the right group.
• Full suite + end-to-end: repeat the incident shape (hundreds of sub-crossing args) and compare wall-clock + .be rows vs a pre-fix run.

Blockers and bummers

• Pre-existing pin loss on ms>999 cohorts (PUT-007 era): 4/8 pre-fix flat 400-arg runs failed mtimeinv; 0/8 post-clamp.
• Native io.setMtime (RONToTime) already maxes ms at 999 — no C touched; test/put/mtimeinv.js amended per the ruling (flagged).

Outcome