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/flatted/php/flatted.php

@@ -0,0 +1,156 @@
+<?php
+
+/*!
+ * ISC License
+ * 
+ * Copyright (c) 2018-2021, Andrea Giammarchi, @WebReflection
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+ * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+ * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+ * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+ * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+class FlattedString {
+  public $value = '';
+  public function __construct($value) {
+    $this->value = $value;
+  }
+}
+
+class Flatted {
+
+  // public utilities
+  public static function parse($json, $assoc = false, $depth = 512, $options = 0) {
+    $input = array_map(
+      'Flatted::asString',
+      array_map(
+        'Flatted::wrap',
+        json_decode($json, $assoc, $depth, $options)
+      )
+    );
+    $value = &$input[0];
+    $set = array();
+    $set[] = &$value;
+    if (is_array($value))
+      return Flatted::loop(false, array_keys($value), $input, $set, $value);
+    if (is_object($value))
+      return Flatted::loop(true, Flatted::keys($value), $input, $set, $value);
+    return $value;
+  }
+
+  public static function stringify($value, $options = 0, $depth = 512) {
+    $known = new stdClass;
+    $known->key = array();
+    $known->value = array();
+    $input = array();
+    $output = array();
+    $i = intval(Flatted::index($known, $input, $value));
+    while ($i < count($input)) {
+      $output[$i] = Flatted::transform($known, $input, $input[$i]);
+      $i++;
+    }
+    return json_encode($output, $options, $depth);
+  }
+
+  // private helpers
+  private static function asString($value) {
+    return $value instanceof FlattedString ? $value->value : $value;
+  }
+
+  private static function index(&$known, &$input, &$value) {
+    $input[] = &$value;
+    $index = strval(count($input) - 1);
+    $known->key[] = &$value;
+    $known->value[] = &$index;
+    return $index;
+  }
+
+  private static function keys(&$value) {
+    $obj = new ReflectionObject($value);
+    $props = $obj->getProperties();
+    $keys = array();
+    foreach ($props as $prop)
+      $keys[] = $prop->getName();
+    return $keys;
+  }
+
+  private static function loop($obj, $keys, &$input, &$set, &$output) {
+    foreach ($keys as $key) {
+      $value = $obj ? $output->$key : $output[$key];
+      if ($value instanceof FlattedString)
+        Flatted::ref($obj, $key, $input[$value->value], $input, $set, $output);
+    }
+    return $output;
+  }
+
+  private static function relate(&$known, &$input, &$value) {
+    if (is_string($value) || is_array($value) || is_object($value)) {
+      $key = array_search($value, $known->key, true);
+      if ($key !== false)
+        return $known->value[$key];
+      return Flatted::index($known, $input, $value);
+    }
+    return $value;
+  }
+
+  private static function ref($obj, &$key, &$value, &$input, &$set, &$output) {
+    if (is_array($value) && !in_array($value, $set, true)) {
+      $set[] = $value;
+      $value = Flatted::loop(false, array_keys($value), $input, $set, $value);
+    }
+    elseif (is_object($value) && !in_array($value, $set, true)) {
+      $set[] = $value;
+      $value = Flatted::loop(true, Flatted::keys($value), $input, $set, $value);
+    }
+    if ($obj) {
+      $output->$key = &$value;
+    }
+    else {
+      $output[$key] = &$value;
+    }
+  }
+
+  private static function transform(&$known, &$input, &$value) {
+    if (is_array($value)) {
+      return array_map(
+        function ($value) use(&$known, &$input) {
+          return Flatted::relate($known, $input, $value);
+        },
+        $value
+      );
+    }
+    if (is_object($value)) {
+      $object = new stdClass;
+      $keys = Flatted::keys($value);
+      foreach ($keys as $key)
+        $object->$key = Flatted::relate($known, $input, $value->$key);
+      return $object;
+    }
+    return $value;
+  }
+
+  private static function wrap($value) {
+    if (is_string($value)) {
+      return new FlattedString($value);
+    }
+    if (is_array($value)) {
+      return array_map('Flatted::wrap', $value);
+    }
+    if (is_object($value)) {
+      $keys = Flatted::keys($value);
+      foreach ($keys as $key) {
+        $value->$key = self::wrap($value->$key);
+      }
+    }
+    return $value;
+  }
+}
+?>