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/eslint-plugin-svelte/lib/rules/prefer-style-directive.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+const css_utils_1 = require("../utils/css-utils");
+const ast_utils_1 = require("../utils/ast-utils");
+const compat_1 = require("../utils/compat");
+/** Checks wether the given node is string literal or not  */
+function isStringLiteral(node) {
+    return node.type === 'Literal' && typeof node.value === 'string';
+}
+exports.default = (0, utils_1.createRule)('prefer-style-directive', {
+    meta: {
+        docs: {
+            description: 'require style directives instead of style attribute',
+            category: 'Stylistic Issues',
+            recommended: false,
+            conflictWithPrettier: false
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            unexpected: 'Can use style directives instead.'
+        },
+        type: 'suggestion'
+    },
+    create(context) {
+        const sourceCode = (0, compat_1.getSourceCode)(context);
+        /**
+         * Process for `style=" ... "`
+         */
+        function processStyleValue(node, root) {
+            for (const child of root.nodes) {
+                if (child.type === 'decl') {
+                    processDeclaration(node, root, child);
+                }
+                else if (child.type === 'inline') {
+                    processInline(node, root, child);
+                }
+            }
+        }
+        /**
+         * Process for declaration
+         */
+        function processDeclaration(attrNode, root, decl) {
+            if (decl.important || decl.unknownInterpolations.length || decl.prop.interpolations.length)
+                return;
+            if (attrNode.parent.attributes.some((attr) => attr.type === 'SvelteStyleDirective' && attr.key.name.name === decl.prop.name)) {
+                // has style directive
+                return;
+            }
+            context.report({
+                node: attrNode,
+                loc: decl.loc,
+                messageId: 'unexpected',
+                *fix(fixer) {
+                    const styleDirective = `style:${decl.prop.name}="${sourceCode.text.slice(...decl.value.range)}"`;
+                    if (root.nodes.length === 1 && root.nodes[0] === decl) {
+                        yield fixer.replaceTextRange(attrNode.range, styleDirective);
+                    }
+                    else {
+                        yield removeStyle(fixer, root, decl);
+                        if (root.nodes[0] === decl) {
+                            yield fixer.insertTextBeforeRange(attrNode.range, `${styleDirective} `);
+                        }
+                        else {
+                            yield fixer.insertTextAfterRange(attrNode.range, ` ${styleDirective}`);
+                        }
+                    }
+                }
+            });
+        }
+        /**
+         * Process for inline
+         */
+        function processInline(attrNode, root, inline) {
+            const node = inline.node.expression;
+            if (node.type !== 'ConditionalExpression') {
+                return;
+            }
+            if (!isStringLiteral(node.consequent) || !isStringLiteral(node.alternate)) {
+                return;
+            }
+            if (node.consequent.value && node.alternate.value) {
+                // e.g. t ? 'top: 20px' : 'left: 30px'
+                return;
+            }
+            const positive = !node.alternate.value;
+            const inlineRoot = inline.getInlineStyle(positive ? node.consequent : node.alternate);
+            if (!inlineRoot || inlineRoot.nodes.length !== 1) {
+                return;
+            }
+            const decl = inlineRoot.nodes[0];
+            if (decl.type !== 'decl') {
+                return;
+            }
+            if (attrNode.parent.attributes.some((attr) => attr.type === 'SvelteStyleDirective' && attr.key.name.name === decl.prop.name)) {
+                // has style directive
+                return;
+            }
+            context.report({
+                node,
+                messageId: 'unexpected',
+                *fix(fixer) {
+                    let valueText = sourceCode.text.slice(node.test.range[0], node.consequent.range[0]);
+                    if (positive) {
+                        valueText +=
+                            sourceCode.text[node.consequent.range[0]] +
+                                decl.value.value +
+                                sourceCode.text[node.consequent.range[1] - 1];
+                    }
+                    else {
+                        valueText += 'null';
+                    }
+                    valueText += sourceCode.text.slice(node.consequent.range[1], node.alternate.range[0]);
+                    if (positive) {
+                        valueText += 'null';
+                    }
+                    else {
+                        valueText +=
+                            sourceCode.text[node.alternate.range[0]] +
+                                decl.value.value +
+                                sourceCode.text[node.alternate.range[1] - 1];
+                    }
+                    const styleDirective = `style:${decl.prop.name}={${valueText}}`;
+                    if (root.nodes.length === 1 && root.nodes[0] === inline) {
+                        yield fixer.replaceTextRange(attrNode.range, styleDirective);
+                    }
+                    else {
+                        yield removeStyle(fixer, root, inline);
+                        if (root.nodes[0] === inline) {
+                            yield fixer.insertTextBeforeRange(attrNode.range, `${styleDirective} `);
+                        }
+                        else {
+                            yield fixer.insertTextAfterRange(attrNode.range, ` ${styleDirective}`);
+                        }
+                    }
+                }
+            });
+        }
+        /** Remove style */
+        function removeStyle(fixer, root, node) {
+            const index = root.nodes.indexOf(node);
+            const after = root.nodes[index + 1];
+            if (after) {
+                return fixer.removeRange([node.range[0], after.range[0]]);
+            }
+            const before = root.nodes[index - 1];
+            if (before) {
+                return fixer.removeRange([before.range[1], node.range[1]]);
+            }
+            return fixer.removeRange(node.range);
+        }
+        return {
+            'SvelteStartTag > SvelteAttribute'(node) {
+                if (!(0, ast_utils_1.isHTMLElementLike)(node.parent.parent) || node.key.name !== 'style') {
+                    return;
+                }
+                const root = (0, css_utils_1.parseStyleAttributeValue)(node, context);
+                if (root) {
+                    processStyleValue(node, root);
+                }
+            }
+        };
+    }
+});