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/tinyexec/dist/main.d.ts

@@ -0,0 +1,70 @@
+import { ChildProcess, SpawnOptions } from 'node:child_process';
+import { Readable } from 'node:stream';
+
+declare class NonZeroExitError extends Error {
+    readonly result: Result;
+    readonly output?: Output;
+    get exitCode(): number | undefined;
+    constructor(result: Result, output?: Output);
+}
+
+interface Output {
+    stderr: string;
+    stdout: string;
+    exitCode: number | undefined;
+}
+interface PipeOptions extends Options {
+}
+type KillSignal = Parameters<ChildProcess['kill']>[0];
+interface OutputApi extends AsyncIterable<string> {
+    pipe(command: string, args?: string[], options?: Partial<PipeOptions>): Result;
+    process: ChildProcess | undefined;
+    kill(signal?: KillSignal): boolean;
+    get pid(): number | undefined;
+    get aborted(): boolean;
+    get killed(): boolean;
+    get exitCode(): number | undefined;
+}
+type Result = PromiseLike<Output> & OutputApi;
+interface Options {
+    signal: AbortSignal;
+    nodeOptions: SpawnOptions;
+    timeout: number;
+    persist: boolean;
+    stdin: ExecProcess;
+    throwOnError: boolean;
+}
+interface TinyExec {
+    (command: string, args?: string[], options?: Partial<Options>): Result;
+}
+declare class ExecProcess implements Result {
+    protected _process?: ChildProcess;
+    protected _aborted: boolean;
+    protected _options: Partial<Options>;
+    protected _command: string;
+    protected _args: string[];
+    protected _resolveClose?: () => void;
+    protected _processClosed: Promise<void>;
+    protected _thrownError?: Error;
+    get process(): ChildProcess | undefined;
+    get pid(): number | undefined;
+    get exitCode(): number | undefined;
+    constructor(command: string, args?: string[], options?: Partial<Options>);
+    kill(signal?: KillSignal): boolean;
+    get aborted(): boolean;
+    get killed(): boolean;
+    pipe(command: string, args?: string[], options?: Partial<PipeOptions>): Result;
+    [Symbol.asyncIterator](): AsyncIterator<string>;
+    protected _waitForOutput(): Promise<Output>;
+    then<TResult1 = Output, TResult2 = never>(onfulfilled?: ((value: Output) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    protected _streamOut?: Readable;
+    protected _streamErr?: Readable;
+    spawn(): void;
+    protected _resetState(): void;
+    protected _onError: (err: Error) => void;
+    protected _onClose: () => void;
+}
+declare const x: TinyExec;
+declare const exec: TinyExec;
+
+export { ExecProcess, type KillSignal, NonZeroExitError, type Options, type Output, type OutputApi, type PipeOptions, type Result, type TinyExec, exec, x };