fix(provider): raise explicit error when interrupting inactive session so reactor force-clears

Follow-up to 5a63be9. The previous change silenced the error but also
broke the reactor's catchCause path: `interruptTurn` would return
successfully when no active session existed (isActive === false), which
meant the reactor NEVER ran its force-clear code, and the "Working"
indicator stayed stuck on any thread whose provider session was
orphaned between restarts.

Raise a specific `ProviderValidationError` from `interruptTurn` when
the routed session is inactive, so the reactor's existing catchCause
handler always runs, always dispatches a `thread.session.set` with
status="interrupted", and always surfaces the visible "Turn
force-stopped" activity. The contract's `Effect<void, ProviderServiceError>`
return type is preserved — the failure is exactly what the reactor
already knows how to handle.

User-reported repro: thread `013848ab-2305-4125-92b9-9ed3c6faeffe` stuck
on "Working" for hours; clicking Stop now correctly transitions the
thread to an interrupted/error-free state so the user can send a new
message to re-establish the provider session.

Verified:
- Typecheck: 9/9 packages clean
- @marcode/server: 995 pass, 5 skipped (24 ProviderCommandReactor,
  26 ProviderService).
- @marcode/web: 1074 pass.

Author: tyulyukov

apps/server/src/provider/Layers/ProviderService.ts

@@ -474,10 +474,11 @@ const makeProviderService = Effect.fn("makeProviderService")(function* (
       return yield* Effect.gen(function* () {
         // Don't resurrect a dead session just to kill it. If the provider has
         // no active session (process crashed, app was closed mid-turn, or
-        // recovery has no resume cursor), interrupt is a no-op from the
-        // adapter's perspective — the session is already gone. The reactor
-        // still force-clears the orchestration thread state regardless, so
-        // the UI unblocks.
+        // recovery has no resume cursor), raise a validation error — the
+        // reactor's catchCause force-clears the orchestration thread state
+        // so the UI unblocks from "Working". Raising here (vs. returning
+        // silently) guarantees the reactor's catch path always runs for
+        // orphaned sessions.
         const routed = yield* resolveRoutableSession({
           threadId: input.threadId,
           operation: "ProviderService.interruptTurn",
@@ -490,9 +491,13 @@ const makeProviderService = Effect.fn("makeProviderService")(function* (
           "provider.thread_id": input.threadId,
           "provider.turn_id": input.turnId,
         });
-        if (routed.isActive) {
-          yield* routed.adapter.interruptTurn(routed.threadId, input.turnId);
+        if (!routed.isActive) {
+          return yield* toValidationError(
+            "ProviderService.interruptTurn",
+            `Provider session for thread '${input.threadId}' is not active; nothing to interrupt.`,
+          );
         }
+        yield* routed.adapter.interruptTurn(routed.threadId, input.turnId);
       }).pipe(
         withMetrics({
           counter: providerTurnsTotal,