---
status: historical
created: 2026-08-18
archived: 2026-08-18
reason: "Stage-C evidence: the design pass's client INTENT-WATCH lens (e) — the schema-less whole-sidecar cell.sink (four CFC probes per run, two O(E²)), the demand leak, the redesign (a) a non-reactive storage-notification listener keyed on the outstanding intent set, interim (b) the schema-narrowed sink, the seven-point build contract, pins 1–11, rulings 1–5, refutation; read against fb2292a24; input to the reconciled design (docs/plans/server-execution-v2/stage-c-design.md)."
---

I have what I need. Here is the panel report.

# Lens (e): the client speculation overlay's intent watch is O(history) — findings

## 0. The convener's five reads — verified/refuted

1. **VERIFIED.** `trackIntent` (`packages/runner/src/speculation/overlay-destination.ts:586–642`) builds `getCellFromLink({space, id: sidecarId, scope:"space", path: []})` with NO schema (606–611) and installs one `cell.sink` per `${space}\0${sidecarId}` (603–604, 612–618, stored 633). `#scanIntentNotices` (730–781) iterates every `value.entries` element and acts only on tracked ids (735–741); arm order is `status==="dropped"` (742) then `consequenced===true` (758). `#untrackIntent` (783–806) cancels the sink when the set empties (792–803). The value-plane rationale comment is at 575–585.
2. **VERIFIED, with two refinements.** `sink` (`cell.ts:2746–2773`) → `subscribeToReferencedDocs` (3503–3559): `extraTx = runtime.edit()` (3522), `wrappedTx = createChildCellTransaction(tx, extraTx)` (3523), `needsTraversal = schema===undefined || isTrueSchema(schema)` (3525–3526), `validateAndTransform(..., {synced:true})` (3530), `deepTraverse(newValue)` (3533–3534), then `prepareTxForCommit(extraTx); extraTx.commit()` (3549–3550). `sinkHelper` (3566–3610) runs the action once immediately on `tx = runtime.edit()` (3585–3586), `prepareTxForCommit(tx); tx.commit()` (3592–3593), `resubscribe(..., {isEffect:true})` (3597–3603). Refinement A: the deepTraverse reads land on the SINK's `tx`, not `extraTx` — `TransactionWrapper` forwards every read to `wrapped` (`extended-storage-transaction.ts:2624–2649`) and `childCellTx` is consulted only when minting child Cells (`getTransactionForChildCells`, 2306–2308; callers `schema.ts:729,1018,1578`); the schema-less path returns a query proxy (`schema.ts:1213–1221`) whose `readTx()` is `runtime.readTx(wrappedTx)` = the wrapper itself while the tx is ready (`query-result-proxy.ts:235–238`, `runtime.ts:2329–2334`). So per scheduler re-run there are FOUR probes (extraTx prepare+commit, cheap; scheduler tx prepare+commit via `run.ts:110–122` `startReactiveActionCommit`, expensive), and the profile's two expensive ones are on the scheduler tx. Refinement B: `readOnly` is a declared mode set by `runtime.readTx()` (`runtime.ts:2338`) AND by `scheduler.populateDependencies()` (`scheduler/events.ts:672`), not only readTx (`v2-transaction.ts:958–968`); commit-side probe guard is `!readOnly` (`extended-storage-transaction.ts:2017–2036`); `prepareTxForCommit` probes unconditionally when `!relevant && flowLabelsMode!=="off"` (`runtime.ts:2302–2308`).
3. **VERIFIED.** `flowLabelWorkExists` (`cfc/prepare.ts:1985–2067`) → `forEachFlowObservation` (1556–1690): for EVERY read activity (1619) it calls `probeBelongsToDereference` (1649, defined 1593–1618) which does `sources.some(source => isPrefix(source, logicalPath))` (1616–1617) over all trace sources recorded for that doc; the per-doc source map is built once per call from `dereferenceTraces` (1599–1614). Traces are recorded per followed link hop (`link-resolution.ts:69–78`, called at 375). So cost = O(reads_doc × sources_doc); the sidecar contributes O(E) reads and O(E) sources ⇒ O(E²). Note `docEntries` (2022–2042) is memoized per doc and the sidecar has no labelMap, so the probe spends its whole budget computing `false`.
4. **VERIFIED.** `StreamEventEntry` (`packages/memory/v2.ts:383–432`), `StreamEventsDocValue` (437–440); marks are SpaceServer-written by INDEX path `["entries", String(index), "consequenced"]` (`executor/space-server.ts:1171–1180`; error/status/reason at 2063–2072). Compaction allowed at-or-below `eventWatermark` (events.md §4 :224–230), unbuilt (verification-coverage.md OW24 :1376–1388). One correction: `stream: StreamLinkRef` is a plain `{id, path, scope}` object (v2.ts:341–345), not a sigil link, so traces come ONLY from links inside `payload` (`payload: event` where `event = convertCellsToLinks(newValue)`, `cell.ts:1535–1537`) — the profile's isPrefix dominance therefore itself implies this workload's payloads carry links.
5. **VERIFIED.** `cell.ts:1580–1644`: `overlay?.trackIntent(space, sidecarId, firedEventId)` (1611) precedes `replica.enqueueEventAppend(...)` (1613), inside the flag-ON, non-serving, unstamped-tx branch (1581–1586). Note the immediate sink run therefore executes on the click's SYNCHRONOUS path.

Also verified: the wire frame `SessionSyncUpsert` (`memory/v2.ts:1042–1062`) carries `{branch,id,scope,scopeKey,seq,doc,deleted}` — no `consequenceOf`, and `doc` is the WHOLE EntityDocument. The value plane is the only client-visible consequence carrier today.

## Q1. Why whole-sidecar tracking; what the spec requires; minimal state

**(i) What the spec requires.** speculation.md §4 step 2 (:84–86): retire `intent(e)` entries when e's authoritative consequences — or its dropped notice (events.md §5) — exist. §5 (:192–193): "Overlay memory is bounded by pending-intent count." events.md §5 (:269–271): the client MUST be signaled for a drop; T7 (:285–294): the notice is a FIELD ON THE STREAM DOC'S OWN ENTRY and "the client re-reads the stream on reconnect" — a read of the stream doc, nothing more. No sentence requires a reactive effect, a traversal of every entry, or a scheduler node. Step 4 (:97–99, re-run un-consequenced intents against fresh state) is about the ECHO's rebasing, not the watch.

**(ii) What the value-plane CHOICE requires.** Because the frame carries no metadata (SessionSyncUpsert above; protocol.md §7 :773–790 lists `consequenceOf` as derived-commit metadata, and :840–845 bounds it by wave input), the client must learn "e is consequenced/dropped/errored" by reading the entry for e on the sidecar. That needs: the set of outstanding ids (`#trackedIntents`, 218–221 — already exactly the spec's bound), the sidecar kept WATCHED so marks arrive, a trigger when the doc changes, and a way to locate e's entry. Locating is O(1) if the change notification names the entry index (it does — see Q2a) or O(tail) with a raw backward scan; nothing in the value-plane choice forces O(history).

**(iii) What `cell.sink` + `deepTraverse` + tx + probe ADD beyond that.** A scheduler EFFECT node (`isEffect:true`, 3598) that runs once immediately and on every sidecar change; each run mints two `runtime.edit()` txs; the schema-less read returns a query proxy and `deepTraverse` (3626–3654) touches every property of every entry, following payload links TRANSITIVELY into other docs (get trap → `createViewProxy` → `resolveLink`, `query-result-proxy.ts:643–652, 248`) recording O(E) reads + O(E) traces on the sink tx; then four `flowLabelWorkExists` probes (two O(E²)); a dependency log of O(E + linked-doc paths) re-indexed by the scheduler each run; participation in `runtime.idle()`; and demand edges to linked docs' writers (Q4). None of that is spec-required; all of it is O(history) or worse.

## Q2. Alternatives, feasibility in this codebase, recommendation

**(a) Non-reactive storage-notification listener — FEASIBLE, smallest sound.** Two substrates exist:
- `IStorageManager.subscribe(IStorageNotification)` (`storage/interface.ts:116, 512–562`), the same relay the scheduler consumes (`scheduler/facade.ts:449–452, 1941–1955`; also `runner.ts:1317`). Relay semantics: Set iteration with try/catch, `{done:true}` self-cancels, `unsubscribe` exists (`storage/subscription.ts:26–48`; StorageManager `v2.ts:1561–1566`). Notifications carry `changes: IMergedChanges` = `IMemoryChange{address{id,scope,path}, before, after}` (interface.ts:707–744) where paths are LEAF-granular from the differential (`differential.ts:96–245, 247–280`): a consequenced mark yields a change at `["value","entries","<i>","consequenced"]`, an append yields `["value","entries"]`, and `before/after` are the whole visible doc (`State.is` = EntityDocument, `v2.ts:5691–5708`, `v2-document.ts:4–12`). Fired for commit/integrate/pull/load/revert (`v2.ts:3545, 4091, 4610, 4674, 5028, 5573`); the differential is always computed because the scheduler is always subscribed (`hasNotificationSubscribers`, 5753–5761).
- `SpaceReplica.sinkDocument(uri, cb)` (`v2.ts:2616–2635`), a per-doc raw callback receiving `visibleVersion(...).version.value` (an `EntityDocument`, `notifySinksForIds` 5733–5751), keyed `docKey(uri,"space")` which matches `#docKeyOf` for space scope (`resolveScopeKey("space")==="space"`, `memory/v2.ts:148–150`; `v2.ts:2270, 2503–2540`). It is exposed on the concrete `Provider.sink` (2138–2143) but NOT on `IStorageProvider`/`ISpaceReplica` — using it needs an optional interface member, following the exact precedent of `speculationRetirementView?`/`ackedSeqOf?`/`speculationAckObserver?` (interface.ts:2162–2202); currently it has no live caller.
- Raw read without a tx: `ISpaceReplica.getDocument(id, scope)` (interface.ts:2046–2050) / `get(entry)` (2035); `syncCell` already reads the provider's raw `get` through a structural cast (`v2.ts:1607–1612`). Keeping the doc watched: `storageManager.open(space).sync(sidecarId, {path:[], schema:false}, "space")` — the selector `syncCell` uses for a schema-less cell (`v2.ts:1597–1605`; same shape at `runtime.ts:2256–2259`).
- Index maintenance caveat (refines the convener's "append-only from last known length"): the client's append is a TAIL-RELATIVE `op:"append"` patch (`event-append-queue.ts:537–566`; `engine.ts:1871–1891`), applied locally to the pending layer at the local tail, while the confirmed frame arrives as a whole doc in which concurrent appends may precede it — so an entry's index can move across pending→confirmed. Any `eventId → index` hint must be verified by `entries[i].eventId === id` and fall back to a backward scan from the tail. That fallback is a raw JS array walk (no tx, no proxy, no reads, no traces) — microseconds at E=1000 — so it is not the disease even when it degrades to O(E).
- No tx ⇒ no CFC probe, no scheduler action, no `idle()` participation, no demand edges. Cost per notification: O(changes) map lookups; per check: O(outstanding + hinted indices).

**(b) Schema-narrowed `cell.sink` — FEASIBLE as a one-line interim; linear, not flat.** `getCellFromLink(link, schema)` takes a schema (`runtime.ts:2446–2463`); with a non-true schema `needsTraversal` is false (cell.ts:3525–3526) and `validateAndTransform` takes the `SchemaObjectTraverser` route (`schema.ts:1345`). Verified semantics: with `properties` listed and `additionalProperties` UNSET, unlisted properties (`payload`, `stream`, `firedAt`, …) hit the missing-property marker (`cfc.ts:660–685`; `traverse.ts:298–303, 309–319`) and are handed to `addOptionalProperty` which for `TransformObjectCreator` is a no-op (`schema.ts:1482–1490`) — not descended, no read, no link followed (`traverse.ts:4403–4432`). Do NOT set `additionalProperties:false`: that routes the unlisted property through `descend()` which records a shape read first (4463–4466). Reads recorded per fire: array shape read (4123), per-item shape read (4171), per listed property present a shape read (4464) plus its leaf value read — ≈2–7 reads per entry, ZERO dereference traces ⇒ `probeBelongsToDereference` is O(1) per read ⇒ each probe O(E) not O(E²). Reactivity is preserved: a `consequenced` key-add on entry i is a shape change under the per-item non-recursive read. The whole-doc materializing read is `internalVerifierRead` (`schema.ts:1077–1087`) and skipped by the probe (`prepare.ts:1620`). Recommended schema: `{type:"object", properties:{entries:{type:"array", items:{type:"object", properties:{eventId:{type:"string"}, consequenced:{type:"boolean"}, error:{type:"string"}, status:{type:"string"}, reason:{type:"string"}}}}}}` (types per `memory/v2.ts:384–419`; note a type-mismatched element voids the whole array — `traverse.ts:4143–4152` — so entry well-formedness (admission refuses pre-supplied marks, v2.ts:379–381) is load-bearing).
  What (b) does NOT fix: still O(E) reads + O(E) dependency addresses re-indexed per fire; still four probes O(E) each per fire; still a scheduler effect (idle participation, a graph node); still fires on EVERY sidecar change (other clients' appends/marks, `seq`/`firedAt` stamping, `eventWatermark`) at O(E) each; still O(E) on the click's synchronous path. It DOES close the demand leak (no link following). Verdict: "flat enough" as an interim only while E stays in the hundreds; it turns quadratic-per-session back into linear-per-fire, which is what OFF's UI sinks over a growing note list already pay.

**(c) Per-entry `cell.key("entries").key(i)` sinks — REJECT.** The client does not know its index at fire time (tail-relative append, above), the index can move across pending→confirmed, one effect per outstanding intent each with tx + probes per fire, and a schema-less per-entry sink still deep-traverses that entry's payload links (traces + demand edge). Finding i requires the O(E) scan (a) already avoids.

**(d) `consequenceOf` on the wire frame — spec-literal but NOT smallest.** It changes protocol §3/§7 frame shape (`SessionSync` carries no commit metadata today, `memory/v2.ts:1072–1079`), touches engine, memory server, session sync, and the client, and still does not deliver the dropped notice (T7 rules it value-plane, events.md §5 :285–294) or the error consequence, so a value-plane read remains necessary anyway.

**Recommendation:** (a) with (b) as an interim rider if the build stage lands in two steps.

**Contract for the build stage (a):**
1. State: `#trackedIntents` unchanged; replace `#intentSinks` with `#intentListenerReleases` (space\0sidecar → release) plus optional `#intentIndexHints` (space\0sidecar\0eventId → index).
2. Install in `trackIntent` when no listener exists for (space, sidecar): (i) subscribe ONE `IStorageNotification` per overlay (or per sidecar) via `runtime.storageManager.subscribe(...)` filtering `notification.space === space` and `change.address.id === sidecarId` (alternative: `replica.sinkDocument?` after adding the optional member to `ISpaceReplica`); (ii) keep the doc watched: `storageManager.open(space).sync(sidecarId, {path:[], schema:false}, "space")` (best-effort, logged like today's `intent-sink-failed` arm 635–641); (iii) run an immediate raw check against `replica.getDocument(sidecarId, "space")?.value` (covers T25's duplicate fire whose consequence already landed — today's 619–634 logic).
3. Trigger: any notification touching the sidecar (append, mark, stamp, watermark, load/pull, revert; on `reset` treat as dirty). The listener does NOT act inline: it records dirty (+ hinted indices from `address.path[2]` when `path[1]==="entries"`) and `queueMicrotask`s one coalesced check per (space, sidecar) — precedent `#sealSpeculative`'s deferred sweep (495–499). Rationale: `#notifyIntentOutcome` calls arbitrary UI subscribers (717–728) and must not run inside the replica's integrate/commit dispatch (the `speculationAckObserver` precedent, `v2.ts:5381–5388`, is safe only because `#sweep` merely resolves promises).
4. Check: re-read the raw doc at check time (not the captured `after`); for each tracked id locate its entry by verified hint else backward scan from the tail (stop when all located); not-found stays tracked (append not yet landed; the watermark backstop stands). Apply today's arms unchanged and in today's order: `status==="dropped"` → `#untrackIntent`, `retireIntent`, `#settleIntentConsequence(dropped)`, `#notifyIntentOutcome(dropped)`; else `consequenced===true` → untrack, `retireIntent`, settle (`errored` if `error` else `consequenced`), notify `errored` if `error`. `resolveIntent`, `waitForIntentConsequence`, `subscribeIntentOutcomes` untouched.
5. Release: `#untrackIntent` releases the listener when the set empties (or the listener returns `{done:true}`); `close()` releases all (today's 1085–1092 slot).
6. Backstop unchanged: `#ensureWatermarkSink`/`#sweep` (888–921, 960–1057).
7. Diagnostics for pins: an `intentCheckVisits` counter (entries visited per check) and `intentCheckCount`.

## Q3. The CFC probe on the overlay's own bookkeeping txs

`prepareBoundaryCommit` (`cfc/prepare.ts:5287–6774`) is write-anchored end to end: unprivileged system writes (5310–5312), write-policy-input candidates (5323–5335), value write targets (5347, 5379–5410), flow join derived only to stamp targets (5348–5378), sink ceilings from `sink-request` write-policy inputs (6755), grant claims registered by consuming (write) gates (6766). Trigger reads (307–328) only feed the consumed set for write gates. For a tx with no writes, no attempted writes, no write-policy inputs and no ingest stamp, `flowLabelWorkExists` returning true would mark relevant → `prepareCfc` (`extended-storage-transaction.ts:1493–1547`) → nothing to stamp, no reason, prepared digest → inert; returning false → nothing. So on the intent sink's txs the probe's ONLY effect is its cost, and it computes `false` (no labelMap on the sidecar). Sinks are read-only by design (`cell.ts:3546–3548, 3589–3591`). "Skip `flowLabelWorkExists` when the tx has no writes/attemptedWrites/writePolicyInputs/ingest stamp" therefore looks CFC-sound to me, but it is a generic, OFF-visible change (`runtime.ts:2302–2308`, `extended-storage-transaction.ts:2028–2036`), it shifts `cfcStats.cfcRelevantTx` counts, and the S16 rationale text ("a tx that observed or wrote a labeled doc", 2022–2027) reads broader than the code's actual effect — **needs the CFC owner's ruling; keep it a separate rider.** With (a) the intent watch has no tx, so this narrows to ordinary UI sinks (tuning-class). Adjacent tuning: `setReadOnly` exists and a declared read-only tx skips the commit-side probe (2017–2021; `scheduler/events.ts:672` already uses it for a dependency-seeding tx) — a candidate for the tuning half, not this design.

## Q4. Demand leak and firing granularity

The sink's dependency log = all reads on the sink `tx` (`txToReactivityLog(tx)`, cell.ts:3587) = every sidecar path deepTraverse touched PLUS every path of every payload-linked doc it walked into (transitively), because the proxy's `readTx()` resolves to the wrapper → the sink tx (Q0 refinement A). `extraTx` carries only child-Cell reads, which the schema-less path never mints. So yes: the intent sink's log covers the linked docs, and since it is an effect its dependencies are demand — pull-mode upstream computations run for them (`traverse.ts:4119–4122` states the mechanism), i.e., an old event payload linking a computed's output keeps that computed live on the client. It also fires on EVERY sidecar change — append (`entries` shape), `seq`/`firedAt` stamping (key-add on `entries/i`), `consequenced` mark, `eventWatermark` (value read), including other clients' entries on a shared stream — and on any change to any linked doc. Under (a) none of this exists; under (b) the sidecar-change firing remains but the linked-doc leak is closed.

## Q5. Expected cost after

(a): per notification O(changes) lookups; per check O(outstanding + hints), degrading to a raw O(E) array walk only when a hint misses (microseconds); zero txs, zero probes, zero scheduler runs, zero proxies; `trackIntent` on the click path becomes O(1) + one raw check. Per note the ~4 sidecar changes each cost ≈ nothing. The ON client's `scheduler/run` per note should return to ≈ OFF's ~80 ms plus the speculative echo run and overlay bookkeeping (seal + sweep, O(live entries)) — flat in history. What remains: ordinary UI sinks (linear in notes, OFF too), `handleRequest`/`createViewProxy` (~1.6 s at note 10, OFF too), and three ON-only LINEAR residuals outside scheduler/run that only compaction bounds: the frame carries the whole sidecar doc per change (`SessionSyncUpsert.doc`), the differential deep-compares before/after docs per change (`differential.ts:253–279`, O(E) with pointer short-circuits), and local patch application.

## Q6. Invariants to pin red-first (each with its mutation)

1. Consequenced/dropped/errored mark on a TRACKED id retires the echo (mutation: listener never installed → echo lingers until the watermark backstop; existing pin `event-append-client.test.ts:577–643` stubs `getCellFromLink().sink` — it binds to the old seam and must be re-seamed to the notification path, ideally through the emulated storage manager rather than a hand stub).
2. A mark on an UNTRACKED id is ignored (mutation: drop the `ids.has` guard).
3. Outcome subscribers hear dropped/errored, not consequenced (existing).
4. `waitForIntentConsequence` resolves for each terminal kind, memo consumed (existing/extend).
5. Per-check cost O(outstanding): synthetic sidecar with 1,000 consequenced entries + 1 outstanding → `intentCheckVisits` ≤ small constant (mutation witness: full-scan variant reports 1,000); plus zero txs minted by the overlay during a mark delivery (wrap `runtime.edit`).
6. No scheduler effect for the watch: `runtime.scheduler.getGraphSnapshot().nodes` (`facade.ts:1368`) has no id starting `sink:${space}/of:stream-events:` after a fire — precedent filter at `scheduler-effects.test.ts:228–231` (mutation: keep the cell.sink).
7. Duplicate fire whose consequence already landed resolves at `trackIntent` (T25) without leaking a listener (mutation: skip the immediate raw check).
8. `close()` releases listeners; no callback after close (mutation: forget the release).
9. The check runs in a microtask, never inside notification dispatch (mutation: call inline; witness: a subscriber that commits during the outcome callback).
10. The check has run by the time `storageManager.synced()`/`idle()` resolve after a frame (timing regression guard, since the watch leaves the scheduler).
11. OFF byte-identity: `runtime.speculationOverlay === undefined` and no listener installed OFF.

## Q7. OFF-arm

The overlay exists only when `experimental.serverExecution === true && !servingPosture` (`runtime.ts:1897–1902`), and `trackIntent` is reached only inside cell.ts's flag-ON branch (1581–1586). Design (a)/(b) touch only overlay code (+ an optional interface member for the sinkDocument variant): OFF-invisible. The zero-write probe skip (Q3) IS OFF-visible — keep it a separate CFC-owned rider.

## Q8. Owner rulings — flag, don't fill

1. May the intent watch be a non-reactive storage-notification listener outside the scheduler (no spec sentence requires an effect; consequence: it no longer participates in `runtime.idle()`, moving the check to a microtask)? Speculation §4 step 4's re-run is neither the sink's nor the sweep's job today (`#sweep` retires/un-renders an intent echo but does not rebase it) — clarify whether step 4 is owed at all.
2. Is the schema-narrowed sink an acceptable interim (linear, still an effect)?
3. The zero-write `flowLabelWorkExists` skip (CFC owner; OFF-visible; changes cfcStats).
4. Storage owner: `storageManager.subscribe` (typed, precedent) vs adding `sinkDocument?` to `ISpaceReplica`.
5. Should the effects channel (`speculation/effects-channel.ts:141–149`, same schema-less whole-doc `cell.sink` over the session effects doc) follow the same redesign?

## Q9. What would refute the redesign

If per-note client `scheduler/run` still grows after replacing the sink, remaining O(history) candidates: (i) UI sinks over growing lists (check OFF grows too → not ON-specific); (ii) `#entries` growth — never-served instances kept by the arrival gate (speculation.md §4 :142–143) make `#sweep` (960–1057), `retireIntent` (820) and `#supersedeOlderEntries` (864) O(live) per event with a fixpoint loop; watch `overlay.entryCount(space)` (248–250) — it must stay bounded by pending work; (iii) the effects-channel sink if the session effects doc grows; (iv) the watermark sink is tiny (`{seq}`) — not a candidate; (v) the ON-only linear residuals in Q5 (whole-doc frames, differential, patch apply) — linear, outside scheduler/run, compaction-bounded.

## Tuning-class / in-passing

- `#intentConsequenceMemo` (698–715) memoizes a terminal outcome per fire when no waiter exists; `waitForIntentConsequence` is called only when `send` got an `onCommit` (`cell.ts:1657–1670`), so fires without one leave one small entry per fire until `close()` — unbounded memory, negligible CPU.
- Four probes per sink run today (Q0), two expensive; the double-probe fix is the tuning half; `setReadOnly` on sink txs is a further tuning lever.
- `txToReactivityLog`/`getReactivityLog` inside `flowLabelWorkExists` (1995) is O(reads) per probe call.
- The whole-doc-per-change frame shape makes every consequenced mark cost O(E) bytes to every watching client until compaction — the strongest argument for scheduling OW24's compaction.

## Verified vs. taken on faith

Verified by reading (all file:line cites above). Taken on faith: the profile attribution numbers (0.6→15.5 s, 65%, 13×/99 ms, 5.3/5.4/1.3 s), that this workload's payloads carry links (inferred from isPrefix dominance, not observed), that `IStorageProvider.sync` establishes a standing watch (inferred from marks arriving via today's `cell.sink`→`sync` path), and that `getCellFromLink(link, schema)` applies the schema to the link (widely used, not traced into `createCell`).