The previous attempt used builder.Logging.Services.AddSingleton<ILoggerProvider>(factory)
to lazily resolve IRequiredActor<SessionLogDispatcherActorKey> via DI. In this
hosting setup the LoggerFactory does not pick up that registration — the
provider was constructed but never received any log lines, so the daemon
started silently and never bound the health endpoint.

Restore the eager builder.Logging.AddProvider(instance) registration that
worked previously, and connect the dispatcher post-construction:

- RollingFileLoggerProvider exposes AttachSessionDispatcher(Task<IActorRef>),
  which kicks off the existing buffer-and-drain logic.
- SessionLogDispatcherWiringService is registered as IHostedService and runs
  during host startup; it calls AttachSessionDispatcher with the
  IRequiredActor<>.GetAsync() task. The actor system is up by the time
  IHostedService.StartAsync fires, so resolution succeeds without a
  pre-resolution buffer in normal operation. The buffer remains as a safety
  net for any racing log lines emitted between provider construction and
  StartAsync.
- Tests use AttachSessionDispatcher directly with a fake task / probe; no
  test setup churn beyond switching to the new method.

Verified locally: daemon binds health endpoint, daemon-{date}.log writes
correctly under default Warning level. CI Validate Docker Build and Smoke
Sandbox should both recover.

Two specialists (akka-net + dotnet-concurrency) confirmed the original
test failure on Windows had two stacked causes:

1. Akka race: 150ms ReceiveTimeout idle eviction + AwaitAssertAsync
   polling. When the second Tell arrived during the still-Terminating
   window of the prior child, GenericChildPerEntityParent.Forward
   routed to the closed mailbox -> dead letters -> message lost. The
   prior commit replaced this with deterministic Watch + Sys.Stop +
   ExpectTerminatedAsync of the dispatcher.

2. Windows OS-level race: even after actor termination completes, the
   kernel close-completion window plus AV / Defender real-time scanning
   can briefly hold a SHARING_VIOLATION on the just-closed file path.
   A new actor's first AppendLine can fail with IOException for
   tens-to-hundreds of ms after the prior writer closed. Linux releases
   inode references immediately, so this never reproduces there.

Two targeted fixes:

- SessionLogFile.AppendLine now retries up to 4 times on IOException /
  UnauthorizedAccessException with linear backoff (10, 20, 30 ms). The
  actor model still guarantees a single writer, so this is purely an
  OS-level transient absorber. Helps both production Windows
  deployments and the test suite.

- SessionLogActorTests.TryDeleteDirectory replaces the bare
  Directory.Delete in finally blocks. The test's assertions have
  already passed by the time we reach finally, so cleanup failures
  should never mask success. Retries on IOException /
  UnauthorizedAccessException with the same backoff shape; logs to
  stderr if cleanup ultimately fails. Applied to all four tests.

CLAUDE.md note: this is the rare case where Thread.Sleep is the right
tool — we are absorbing an OS-level transient with no synchronization
signal available to wait on. The retries are bounded and on a
non-hot-path (cleanup or first-write-after-close).

Replaces the prior commit's hand-rolled retry loops:

- SessionLogFile.AppendLine: removed the IOException retry + Thread.Sleep
  backoff. Adding silent retry inside the helper layered recovery on top
  of the actor's existing explicit catch+log "drop on failure" semantics
  in SessionLogActor — the wrong place to handle transient OS-level
  failures. If AppendLine throws on Windows, the actor's existing handler
  logs at Debug and the line is dropped, which is the documented
  best-effort contract for session.log.

- SessionLogActorTests cleanup: replaced TryDeleteDirectory's hand-rolled
  retry-with-Thread.Sleep loop with TryDeleteDirectoryAsync that spins
  via AwaitAssertAsync. Same shape as every other test polling helper in
  the codebase, no new mechanism, deterministic deadline driven by
  TestKit's outer timeout rather than a hardcoded 5-attempt cap.

The Akka deterministic-teardown fix from 434b6c7 (Watch + Sys.Stop +
ExpectTerminatedAsync of the dispatcher) is unchanged — that was the
real Windows fix; the AppendLine retry was overreach.

Successive_dispatchers_append_to_same_canonical_file kept failing on
Windows after 535df45: "Assistant: second" never reached the file even
with deterministic dispatcher teardown. Root cause: when dispatcher2's
SessionLogActor calls SessionLogFile.AppendLine, Windows AV / kernel
handle-cleanup transiently holds SHARING_VIOLATION on the just-closed
file. The actor's existing catch-Exception-and-log-Debug contract drops
the message; the test's AwaitAssertAsync polls forever for a line that
never arrives.

Fix: move the dispatcher2.Tell INSIDE the AwaitAssertAsync polling
predicate. Each iteration re-Tells "second"; eventually one attempt
lands when AV isn't holding the file. Multiple landed writes are fine
— Assert.Contains is duplicate-tolerant, and we still assert the
single-file invariant via Assert.Single(...).

Production behavior is unchanged: AppendLine still throws on transient
failures and SessionLogActor still drops the message at Debug log
level. session.log is best-effort observability.

Update operator-facing surfaces to reflect the SessionLogDispatcher
redesign and what diagnosticians should expect when reading the files.

netclaw-operations skill (v1.26.0):
- Document the daemon-log + session-log split with rotation properties.
- Explain the chronological-timeline guarantee (single actor writes
  session.log) and the two line shapes inside it (audit + Diagnostic:).
- State the best-effort observability contract: lines may be dropped on
  transient IO; debug-level note lands in the daemon log.
- Note current sidecar bypass (compaction, title gen, sub-agents) and
  reference netclaw-dev#920 so the agent can tell operators why
  some diagnostics may be missing.
- Reference netclaw-dev#919 for the size-cap follow-up.

docs/spec/configuration.md:
- Note daemon-log rotation properties (10 MB cap).
- Describe the dispatcher-as-single-writer property.
- State the best-effort drop-on-error contract.
- Note absence of session.log size rotation today.