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/vitest/dist/worker.js

@@ -0,0 +1,141 @@
+import { pathToFileURL } from 'node:url';
+import { createStackString, parseStacktrace } from '@vitest/utils/source-map';
+import { workerId } from 'tinypool';
+import { ViteNodeRunner, ModuleCacheMap } from 'vite-node/client';
+import { readFileSync } from 'node:fs';
+import { resolve, normalize } from 'pathe';
+import { e as environments } from './chunks/index.K90BXFOx.js';
+import { s as setupInspect } from './chunks/inspector.70d6emsh.js';
+import { c as createRuntimeRpc, a as rpcDone } from './chunks/rpc.C3q9uwRX.js';
+import { i as isChildProcess, s as setProcessTitle } from './chunks/utils.C8RiOc4B.js';
+import { d as disposeInternalListeners } from './chunks/utils.Cn0zI1t3.js';
+import 'node:console';
+import 'node:module';
+import '@vitest/utils';
+import './chunks/index.68735LiX.js';
+
+function isBuiltinEnvironment(env) {
+  return env in environments;
+}
+const _loaders = /* @__PURE__ */ new Map();
+async function createEnvironmentLoader(options) {
+  if (!_loaders.has(options.root)) {
+    const loader = new ViteNodeRunner(options);
+    await loader.executeId("/@vite/env");
+    _loaders.set(options.root, loader);
+  }
+  return _loaders.get(options.root);
+}
+async function loadEnvironment(ctx, rpc) {
+  const name = ctx.environment.name;
+  if (isBuiltinEnvironment(name)) {
+    return environments[name];
+  }
+  const loader = await createEnvironmentLoader({
+    root: ctx.config.root,
+    fetchModule: async (id) => {
+      const result = await rpc.fetch(id, "ssr");
+      if (result.id) {
+        return { code: readFileSync(result.id, "utf-8") };
+      }
+      return result;
+    },
+    resolveId: (id, importer) => rpc.resolveId(id, importer, "ssr")
+  });
+  const root = loader.root;
+  const packageId = name[0] === "." || name[0] === "/" ? resolve(root, name) : (await rpc.resolveId(`vitest-environment-${name}`, void 0, "ssr"))?.id ?? resolve(root, name);
+  const pkg = await loader.executeId(normalize(packageId));
+  if (!pkg || !pkg.default || typeof pkg.default !== "object") {
+    throw new TypeError(
+      `Environment "${name}" is not a valid environment. Path "${packageId}" should export default object with a "setup" or/and "setupVM" method.`
+    );
+  }
+  const environment = pkg.default;
+  if (environment.transformMode !== "web" && environment.transformMode !== "ssr") {
+    throw new TypeError(
+      `Environment "${name}" is not a valid environment. Path "${packageId}" should export default object with a "transformMode" method equal to "ssr" or "web".`
+    );
+  }
+  return environment;
+}
+
+if (isChildProcess()) {
+  setProcessTitle(`vitest ${workerId}`);
+  const isProfiling = process.execArgv.some(
+    (execArg) => execArg.startsWith("--prof") || execArg.startsWith("--cpu-prof") || execArg.startsWith("--heap-prof") || execArg.startsWith("--diagnostic-dir")
+  );
+  if (isProfiling) {
+    process.on("SIGTERM", () => {
+      process.exit();
+    });
+  }
+}
+async function execute(method, ctx) {
+  disposeInternalListeners();
+  const prepareStart = performance.now();
+  const inspectorCleanup = setupInspect(ctx);
+  process.env.VITEST_WORKER_ID = String(ctx.workerId);
+  process.env.VITEST_POOL_ID = String(workerId);
+  try {
+    if (ctx.worker[0] === ".") {
+      throw new Error(
+        `Path to the test runner cannot be relative, received "${ctx.worker}"`
+      );
+    }
+    const file = ctx.worker.startsWith("file:") ? ctx.worker : pathToFileURL(ctx.worker).toString();
+    const testRunnerModule = await import(file);
+    if (!testRunnerModule.default || typeof testRunnerModule.default !== "object") {
+      throw new TypeError(
+        `Test worker object should be exposed as a default export. Received "${typeof testRunnerModule.default}"`
+      );
+    }
+    const worker = testRunnerModule.default;
+    if (!worker.getRpcOptions || typeof worker.getRpcOptions !== "function") {
+      throw new TypeError(
+        `Test worker should expose "getRpcOptions" method. Received "${typeof worker.getRpcOptions}".`
+      );
+    }
+    const { rpc, onCancel } = createRuntimeRpc(worker.getRpcOptions(ctx));
+    const beforeEnvironmentTime = performance.now();
+    const environment = await loadEnvironment(ctx, rpc);
+    if (ctx.environment.transformMode) {
+      environment.transformMode = ctx.environment.transformMode;
+    }
+    const state = {
+      ctx,
+      // here we create a new one, workers can reassign this if they need to keep it non-isolated
+      moduleCache: new ModuleCacheMap(),
+      config: ctx.config,
+      onCancel,
+      environment,
+      durations: {
+        environment: beforeEnvironmentTime,
+        prepare: prepareStart
+      },
+      rpc,
+      providedContext: ctx.providedContext,
+      onFilterStackTrace(stack) {
+        return createStackString(parseStacktrace(stack));
+      }
+    };
+    const methodName = method === "collect" ? "collectTests" : "runTests";
+    if (!worker[methodName] || typeof worker[methodName] !== "function") {
+      throw new TypeError(
+        `Test worker should expose "runTests" method. Received "${typeof worker.runTests}".`
+      );
+    }
+    await worker[methodName](state);
+  } finally {
+    await rpcDone().catch(() => {
+    });
+    inspectorCleanup();
+  }
+}
+function run(ctx) {
+  return execute("run", ctx);
+}
+function collect(ctx) {
+  return execute("collect", ctx);
+}
+
+export { collect, run };