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-warning-comments.js

@@ -0,0 +1,209 @@
+/**
+ * @fileoverview Rule that warns about used warning comments
+ * @author Alexander Schmidt <https://github.com/lxanders>
+ */
+
+"use strict";
+
+const escapeRegExp = require("escape-string-regexp");
+const astUtils = require("./utils/ast-utils");
+
+const CHAR_LIMIT = 40;
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		defaultOptions: [
+			{
+				location: "start",
+				terms: ["todo", "fixme", "xxx"],
+			},
+		],
+
+		docs: {
+			description: "Disallow specified warning terms in comments",
+			recommended: false,
+			frozen: true,
+			url: "https://eslint.org/docs/latest/rules/no-warning-comments",
+		},
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					terms: {
+						type: "array",
+						items: {
+							type: "string",
+						},
+					},
+					location: {
+						enum: ["start", "anywhere"],
+					},
+					decoration: {
+						type: "array",
+						items: {
+							type: "string",
+							pattern: "^\\S$",
+						},
+						minItems: 1,
+						uniqueItems: true,
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		messages: {
+			unexpectedComment:
+				"Unexpected '{{matchedTerm}}' comment: '{{comment}}'.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const [{ decoration, location, terms: warningTerms }] = context.options;
+		const escapedDecoration = escapeRegExp(
+			decoration ? decoration.join("") : "",
+		);
+		const selfConfigRegEx = /\bno-warning-comments\b/u;
+
+		/**
+		 * Convert a warning term into a RegExp which will match a comment containing that whole word in the specified
+		 * location ("start" or "anywhere"). If the term starts or ends with non word characters, then the match will not
+		 * require word boundaries on that side.
+		 * @param {string} term A term to convert to a RegExp
+		 * @returns {RegExp} The term converted to a RegExp
+		 */
+		function convertToRegExp(term) {
+			const escaped = escapeRegExp(term);
+
+			/*
+			 * When matching at the start, ignore leading whitespace, and
+			 * there's no need to worry about word boundaries.
+			 *
+			 * These expressions for the prefix and suffix are designed as follows:
+			 * ^   handles any terms at the beginning of a comment.
+			 *     e.g. terms ["TODO"] matches `//TODO something`
+			 * $   handles any terms at the end of a comment
+			 *     e.g. terms ["TODO"] matches `// something TODO`
+			 * \b  handles terms preceded/followed by word boundary
+			 *     e.g. terms: ["!FIX", "FIX!"] matches `// FIX!something` or `// something!FIX`
+			 *          terms: ["FIX"] matches `// FIX!` or `// !FIX`, but not `// fixed or affix`
+			 *
+			 * For location start:
+			 * [\s]* handles optional leading spaces
+			 *     e.g. terms ["TODO"] matches `//    TODO something`
+			 * [\s\*]* (where "\*" is the escaped string of decoration)
+			 *     handles optional leading spaces or decoration characters (for "start" location only)
+			 *     e.g. terms ["TODO"] matches `/**** TODO something ... `
+			 */
+			const wordBoundary = "\\b";
+
+			let prefix = "";
+
+			if (location === "start") {
+				prefix = `^[\\s${escapedDecoration}]*`;
+			} else if (/^\w/u.test(term)) {
+				prefix = wordBoundary;
+			}
+
+			const suffix = /\w$/u.test(term) ? wordBoundary : "";
+			const flags = "iu"; // Case-insensitive with Unicode case folding.
+
+			/*
+			 * For location "start", the typical regex is:
+			 *   /^[\s]*ESCAPED_TERM\b/iu.
+			 * Or if decoration characters are specified (e.g. "*"), then any of
+			 * those characters may appear in any order at the start:
+			 *   /^[\s\*]*ESCAPED_TERM\b/iu.
+			 *
+			 * For location "anywhere" the typical regex is
+			 *   /\bESCAPED_TERM\b/iu
+			 *
+			 * If it starts or ends with non-word character, the prefix and suffix are empty, respectively.
+			 */
+			return new RegExp(`${prefix}${escaped}${suffix}`, flags);
+		}
+
+		const warningRegExps = warningTerms.map(convertToRegExp);
+
+		/**
+		 * Checks the specified comment for matches of the configured warning terms and returns the matches.
+		 * @param {string} comment The comment which is checked.
+		 * @returns {Array} All matched warning terms for this comment.
+		 */
+		function commentContainsWarningTerm(comment) {
+			const matches = [];
+
+			warningRegExps.forEach((regex, index) => {
+				if (regex.test(comment)) {
+					matches.push(warningTerms[index]);
+				}
+			});
+
+			return matches;
+		}
+
+		/**
+		 * Checks the specified node for matching warning comments and reports them.
+		 * @param {ASTNode} node The AST node being checked.
+		 * @returns {void} undefined.
+		 */
+		function checkComment(node) {
+			const comment = node.value;
+
+			if (
+				astUtils.isDirectiveComment(node) &&
+				selfConfigRegEx.test(comment)
+			) {
+				return;
+			}
+
+			const matches = commentContainsWarningTerm(comment);
+
+			matches.forEach(matchedTerm => {
+				let commentToDisplay = "";
+				let truncated = false;
+
+				for (const c of comment.trim().split(/\s+/u)) {
+					const tmp = commentToDisplay
+						? `${commentToDisplay} ${c}`
+						: c;
+
+					if (tmp.length <= CHAR_LIMIT) {
+						commentToDisplay = tmp;
+					} else {
+						truncated = true;
+						break;
+					}
+				}
+
+				context.report({
+					node,
+					messageId: "unexpectedComment",
+					data: {
+						matchedTerm,
+						comment: `${commentToDisplay}${truncated ? "..." : ""}`,
+					},
+				});
+			});
+		}
+
+		return {
+			Program() {
+				const comments = sourceCode.getAllComments();
+
+				comments
+					.filter(token => token.type !== "Shebang")
+					.forEach(checkComment);
+			},
+		};
+	},
+};