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/lib/rules/no-implicit-globals.js

@@ -0,0 +1,187 @@
+/**
+ * @fileoverview Rule to check for implicit global variables, functions and classes.
+ * @author Joshua Peek
+ */
+
+"use strict";
+
+const ASSIGNMENT_NODES = new Set([
+	"AssignmentExpression",
+	"ForInStatement",
+	"ForOfStatement",
+]);
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		defaultOptions: [
+			{
+				lexicalBindings: false,
+			},
+		],
+
+		docs: {
+			description: "Disallow declarations in the global scope",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-implicit-globals",
+		},
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					lexicalBindings: {
+						type: "boolean",
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		messages: {
+			globalNonLexicalBinding:
+				"Unexpected {{kind}} declaration in the global scope, wrap in an IIFE for a local variable, assign as global property for a global variable.",
+			globalLexicalBinding:
+				"Unexpected {{kind}} declaration in the global scope, wrap in a block or in an IIFE.",
+			globalVariableLeak:
+				"Global variable leak, declare the variable if it is intended to be local.",
+			assignmentToReadonlyGlobal:
+				"Unexpected assignment to read-only global variable.",
+			redeclarationOfReadonlyGlobal:
+				"Unexpected redeclaration of read-only global variable.",
+		},
+	},
+
+	create(context) {
+		const [{ lexicalBindings: checkLexicalBindings }] = context.options;
+		const sourceCode = context.sourceCode;
+
+		/**
+		 * Reports the node.
+		 * @param {ASTNode} node Node to report.
+		 * @param {string} messageId Id of the message to report.
+		 * @param {string|undefined} kind Declaration kind, can be 'var', 'const', 'let', function or class.
+		 * @returns {void}
+		 */
+		function report(node, messageId, kind) {
+			context.report({
+				node,
+				messageId,
+				data: {
+					kind,
+				},
+			});
+		}
+
+		return {
+			Program(node) {
+				const scope = sourceCode.getScope(node);
+
+				scope.variables.forEach(variable => {
+					// Only ESLint global variables have the `writable` key.
+					const isReadonlyEslintGlobalVariable =
+						variable.writeable === false;
+					const isWritableEslintGlobalVariable =
+						variable.writeable === true;
+
+					if (isWritableEslintGlobalVariable) {
+						// Everything is allowed with writable ESLint global variables.
+						return;
+					}
+
+					// Variables exported by "exported" block comments
+					if (variable.eslintExported) {
+						return;
+					}
+
+					variable.defs.forEach(def => {
+						const defNode = def.node;
+
+						if (
+							def.type === "FunctionName" ||
+							(def.type === "Variable" &&
+								def.parent.kind === "var")
+						) {
+							if (isReadonlyEslintGlobalVariable) {
+								report(
+									defNode,
+									"redeclarationOfReadonlyGlobal",
+								);
+							} else {
+								report(
+									defNode,
+									"globalNonLexicalBinding",
+									def.type === "FunctionName"
+										? "function"
+										: `'${def.parent.kind}'`,
+								);
+							}
+						}
+
+						if (checkLexicalBindings) {
+							if (
+								def.type === "ClassName" ||
+								(def.type === "Variable" &&
+									(def.parent.kind === "let" ||
+										def.parent.kind === "const"))
+							) {
+								if (isReadonlyEslintGlobalVariable) {
+									report(
+										defNode,
+										"redeclarationOfReadonlyGlobal",
+									);
+								} else {
+									report(
+										defNode,
+										"globalLexicalBinding",
+										def.type === "ClassName"
+											? "class"
+											: `'${def.parent.kind}'`,
+									);
+								}
+							}
+						}
+					});
+
+					if (
+						isReadonlyEslintGlobalVariable &&
+						variable.defs.length === 0
+					) {
+						variable.references.forEach(reference => {
+							if (reference.isWrite() && !reference.isRead()) {
+								let assignmentParent =
+									reference.identifier.parent;
+
+								while (
+									assignmentParent &&
+									!ASSIGNMENT_NODES.has(assignmentParent.type)
+								) {
+									assignmentParent = assignmentParent.parent;
+								}
+
+								report(
+									assignmentParent ?? reference.identifier,
+									"assignmentToReadonlyGlobal",
+								);
+							}
+						});
+					}
+				});
+
+				// Undeclared assigned variables.
+				scope.implicit.variables.forEach(variable => {
+					// def.node is an AssignmentExpression, ForInStatement or ForOfStatement.
+					variable.defs.forEach(def => {
+						report(def.node, "globalVariableLeak");
+					});
+				});
+			},
+		};
+	},
+};