feat: Phase 1 — extract the client (web SPA + desktop) to dtoro/oikos-web

Problem: the hexagonal refactor churns the backend tree for nine more
phases; the UI delivery stack (web/ SPA, cmd/desktop Wails wrapper,
compose/web image) must move to its own repo first so doc/layout
rewrites land once on a backend-only tree.

Change:
- New repo git.hubris.network/dtoro/oikos-web (v0.33.0): web/, desktop/
  (updateURL repointed to oikos-web releases), compose/, own CI (web +
  desktop jobs), own deploy script (CI-green gate, TOCTOU guard,
  version-tagged images, prune-to-3), own webhook receiver on :9798 +
  launchd unit, own compose project publishing the same 8091:80.
- Cutover executed on mac-mini in order: oikos stack's web service
  stopped+removed, oikos-web project brought up on 8091; outer Caddy
  untouched (targets the published port) — serving + Authentik flow +
  /wails 404 quirk verified post-cutover.
- Stripped from oikos: web/, cmd/desktop/, compose/web/, desktop CI
  workflow, ci.yml web job, Makefile ui/desktop/desktop-package/install
  targets, the compose web service, oikos-web from deploy.sh's fallback
  prune list; wails + go-keyring dropped from go.mod, vendor synced.
- README / CONTRIBUTING / AGENTS.md / .agents dev+operations docs now
  point at the new repo; mbse + mascot design docs carry a path note.

Risk: production SPA serving depends on the new pipeline now; rollback
is versioned-image re-up of the old web service from a pre-split
checkout (port 8091). Desktop builds installed before the split still
check dtoro/oikos releases — one manual reinstall, noted in the
oikos-web release notes.

Verification: go vet, make test (race), make generate-check, golangci
(no new findings; baseline down 400→365); post-cutover curls —
localhost:8091 200, /wails/runtime.js 404, outer Caddy 302 Authentik.

web/node_modules/runed/dist/utilities/scroll-state/scroll-state.svelte.d.ts

@@ -0,0 +1,122 @@
+import type { MaybeGetter } from "../../internal/types.js";
+export interface ScrollStateOptions {
+    /**
+     * The scroll container.
+     *
+     * Can be an HTMLElement, Window, or Document, or a getter returning one of these.
+     */
+    element: MaybeGetter<HTMLElement | Window | Document | null | undefined>;
+    /**
+     * Debounce timeout (ms) after scrolling ends.
+     *
+     * @default 200
+     */
+    idle?: MaybeGetter<number | undefined>;
+    /**
+     * Pixel offset thresholds for determining "arrived" state on each scroll edge.
+     */
+    offset?: MaybeGetter<{
+        left?: number;
+        right?: number;
+        top?: number;
+        bottom?: number;
+    } | undefined>;
+    /**
+     * Called during scroll events.
+     */
+    onScroll?: (e: Event) => void;
+    /**
+     * Called after scroll ends (after debounce).
+     */
+    onStop?: (e: Event) => void;
+    /**
+     * Scroll event listener options.
+     *
+     * @default { capture: false, passive: true }
+     */
+    eventListenerOptions?: AddEventListenerOptions;
+    /**
+     * Scroll behavior when using `scrollTo`, `scrollToTop`, or `scrollToBottom`,
+     *
+     * @default 'auto'
+     */
+    behavior?: MaybeGetter<ScrollBehavior | undefined>;
+    /**
+     * Optional error handler.
+     *
+     * @default console.error
+     */
+    onError?: (error: unknown) => void;
+}
+/**
+ * A reactive utility for tracking scroll position, direction,
+ * and edge arrival states, while supporting programmatic scrolling.
+ *
+ * @see https://vueuse.org/useScroll for the inspiration behind this utility.
+ * @param element
+ * @param options
+ */
+export declare class ScrollState {
+    #private;
+    element: Window | Document | HTMLElement | null | undefined;
+    idle: number;
+    offset: {
+        left?: number;
+        right?: number;
+        top?: number;
+        bottom?: number;
+    };
+    onScroll: (e: Event) => void;
+    onStop: (e: Event) => void;
+    eventListenerOptions: AddEventListenerOptions;
+    behavior: "auto" | "instant" | "smooth";
+    onError: (error: unknown) => void;
+    /** State */
+    internalX: number;
+    internalY: number;
+    get x(): number;
+    set x(v: number);
+    get y(): number;
+    set y(v: number);
+    isScrolling: boolean;
+    arrived: {
+        left: boolean;
+        right: boolean;
+        top: boolean;
+        bottom: boolean;
+    };
+    directions: {
+        left: boolean;
+        right: boolean;
+        top: boolean;
+        bottom: boolean;
+    };
+    progress: {
+        x: number;
+        y: number;
+    };
+    constructor(options: ScrollStateOptions);
+    /**
+     * Updates direction and edge arrival states based on the current scroll position.
+     * Takes into account writing mode, flex direction, and RTL layouts.
+     */
+    setArrivedState: () => void;
+    /**
+     * Programmatically scroll to a specific position.
+     */
+    scrollTo(x: number | undefined, y: number | undefined): void;
+    /**
+     * Scrolls to the top of the element.
+     */
+    scrollToTop(): void;
+    /**
+     * Scrolls to the bottom of the element.
+     */
+    scrollToBottom(): void;
+    onScrollEnd: (e: Event) => void;
+    onScrollEndDebounced: ((this: unknown, e: Event) => Promise<void>) & {
+        cancel: () => void;
+        runScheduledNow: () => Promise<void>;
+        pending: boolean;
+    };
+}