Paste the following into your coding agent to investigate and fix these issues.

Fix the following code review issues found in pull request #7817.

Before making changes, review each issue and present a brief summary table:
- For each finding, state whether you agree, disagree, or need clarification
- If you disagree (e.g., the fix would require disproportionate changes
  for minimal ROI, or the finding is factually incorrect), explain why
- If you need to clarify something before deciding, ask those questions
- Then share your plan for which issues to tackle and in what order

## SUGGESTION (2)

### [AGENTS.md] The `weak-refs.h` row lists `WeakOwner<T>`, but its notes still only describe `tryAddStrongRef()`/`runIfAlive`. Mention the `addWeak()` → `tryGet()`/`get()` pattern.
- **File:** src/workerd/util/AGENTS.md:15

### [Code Quality] `ActorCache` flush still attaches `kj::defer([&self]{ --self.flushesEnqueued; })`, a bare self-reference that runs when the promise is destroyed. The behaviour is unchanged from `[this]`, but it is not converted like the rest of the function. Consider a weak handle or a comment explaining why it is safe.
- **File:** src/workerd/io/actor-cache.c++

[SUGGESTION] src/workerd/util/AGENTS.md: the weak-refs.h row now lists WeakOwner<T>, but its notes column still only describes tryAddStrongRef() / runIfAlive(fn). WeakOwner is used differently: attach a kj::Own<WeakOwner<T>> to the promise chain, give continuations addWeak(), and call tryGet() then get(). A short note would help readers find the right pattern.

I checked WeakOwner (src/workerd/util/weak-refs.h) and its tests, the PtrTarget/addWeak() additions (OutputGate, ActorCacheInterface, IoContext_IncomingRequest, StoredExternalHandler, ChannelTokenHandler, WritableStreamSink), and the conversions in actor-cache.c++, io-context.c++ and html-rewriter.c++.

• WeakOwner calls invalidateWeak() in its destructor before value is destroyed. The second test checks exactly this.
• The finishFlush() / finishFlushDeleteAll() code in actor-cache.c++ is moved over unchanged. The getAlarm() rewrite only dereferences the weak handle when !options.noCache, and its result is the same as before.
• The abortFromHangTask continuation in io-context.c++ is noexcept. It now returns a rejected promise when the context is gone instead of throwing, which avoids terminating the process.
• In html-rewriter.c++, the evalLater(...).wait() code moves into waitForThunk / waitForReplacerThunk. Because the promise is waited on synchronously, its [&] captures are safe.

This review did not trace every remaining API conversion or every rule in the expanded clang-tidy check.

[SUGGESTION] src/workerd/io/actor-cache.c++: the flush path converts the outer then to weakThis, but it still attaches kj::defer([&self]() { --self.flushesEnqueued; }) to the returned promise. That defer runs when the promise is destroyed, which may happen while ActorCache is being torn down. The behaviour is the same as the old [this], but it is the one self-reference in this function that is not converted. Consider a weak handle with a null check, or a comment explaining why the bare reference is safe here.

🔒 Security: ✅ LGTM

The change turns potential use-after-free in continuations into exceptions (KJ_REQUIRE_NONNULL). It reduces memory-safety risk and changes no trust boundary, input path or access control.

⚡ Performance: ✅ LGTM

Each continuation now pays a small cost to create a weak handle and check it for null. This adds no unbounded growth, blocking I/O or complexity regression.

📝 Documentation: ✅ LGTM

The new rows in the async-patterns.md capture table describe the KJ parameter-lifetime contract and the static-storage case, and they match the check's new behaviour.