Vendor OpenClaw source as Adolf fork baseline

Adolf is a fork/vendored clone of github.com/openclaw/openclaw (v2026.6.11),
free to diverge. Tree copied sans upstream .git; upstream remote added for
future syncs. Node pinned to 24 (.nvmrc); engines already require >=22.19.
Preserves docs/ARCHITECTURE.md.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LeqyaxJF2nbRXJtae2kNB2

ui/src/app-route-paths.ts

@@ -0,0 +1,115 @@
+import { normalizeRouteBasePath, normalizeRoutePath } from "@openclaw/uirouter";
+import type { RouteLocation } from "@openclaw/uirouter";
+
+export const APP_ROUTE_DEFINITIONS = {
+  chat: { path: "/chat" },
+  overview: { path: "/overview" },
+  activity: { path: "/activity" },
+  agents: { path: "/agents" },
+  channels: { path: "/channels" },
+  config: { path: "/config" },
+  communications: { path: "/communications" },
+  appearance: { path: "/appearance" },
+  automation: { path: "/automation" },
+  mcp: { path: "/mcp" },
+  infrastructure: { path: "/infrastructure" },
+  "ai-agents": { path: "/ai-agents" },
+  workboard: { path: "/workboard" },
+  instances: { path: "/instances" },
+  sessions: { path: "/sessions" },
+  usage: { path: "/usage" },
+  debug: { path: "/debug" },
+  logs: { path: "/logs" },
+  "skill-workshop": { path: "/skills/workshop" },
+  skills: { path: "/skills" },
+  cron: { path: "/cron" },
+  nodes: { path: "/nodes" },
+  dreams: { path: "/dreaming", aliases: ["/dreams"] },
+} as const;
+
+export type RouteId = keyof typeof APP_ROUTE_DEFINITIONS;
+export const APP_ROUTE_IDS = Object.keys(APP_ROUTE_DEFINITIONS) as RouteId[];
+
+export function isRouteId(routeId: string): routeId is RouteId {
+  return routeId in APP_ROUTE_DEFINITIONS;
+}
+
+export function normalizeBasePath(basePath: string): string {
+  return normalizeRouteBasePath(basePath);
+}
+
+export function normalizePath(path: string): string {
+  return normalizeRoutePath(path);
+}
+
+export function pathForRoute(routeId: RouteId, basePath = ""): string {
+  const normalizedBasePath = normalizeBasePath(basePath);
+  const path = APP_ROUTE_DEFINITIONS[routeId].path;
+  return normalizedBasePath ? `${normalizedBasePath}${path}` : path;
+}
+
+export function routeIdFromPath(pathname: string, basePath = ""): RouteId | null {
+  const normalizedPath = normalizePath(pathname);
+  const normalizedBasePath = normalizeBasePath(basePath);
+  const isWithinBasePath =
+    !normalizedBasePath ||
+    normalizedPath === normalizedBasePath ||
+    normalizedPath.startsWith(`${normalizedBasePath}/`);
+  if (!isWithinBasePath) {
+    return null;
+  }
+  const routePath = normalizedBasePath
+    ? normalizedPath.slice(normalizedBasePath.length) || "/"
+    : normalizedPath;
+  for (const routeId of APP_ROUTE_IDS) {
+    const definition = APP_ROUTE_DEFINITIONS[routeId];
+    const paths: readonly string[] =
+      "aliases" in definition ? [definition.path, ...definition.aliases] : [definition.path];
+    if (paths.some((candidate) => normalizePath(candidate) === routePath)) {
+      return routeId;
+    }
+  }
+  return null;
+}
+
+export function inferBasePathFromPathname(pathname: string): string {
+  const isMountRoot = pathname.trim().endsWith("/");
+  const normalizedPath = normalizePath(pathname);
+  if (normalizedPath.toLowerCase().endsWith("/index.html")) {
+    return normalizeBasePath(normalizedPath.slice(0, -"/index.html".length));
+  }
+  if (normalizedPath === "/") {
+    return "";
+  }
+  const segments = normalizedPath.split("/").filter(Boolean);
+  const routePaths = APP_ROUTE_IDS.flatMap((routeId) => {
+    const definition = APP_ROUTE_DEFINITIONS[routeId];
+    const paths: string[] = [definition.path];
+    if ("aliases" in definition) {
+      paths.push(...definition.aliases);
+    }
+    return paths;
+  });
+  for (let index = 0; index < segments.length; index += 1) {
+    const candidate = `/${segments.slice(index).join("/")}`;
+    const routePath = routePaths.find((path) => normalizePath(path) === candidate);
+    if (!routePath) {
+      continue;
+    }
+    const previousSegment = segments[index - 1];
+    const firstRouteSegment = routePath.split("/").find(Boolean);
+    if (index > 0 && previousSegment === firstRouteSegment && candidate === routePath) {
+      return "";
+    }
+    return index ? `/${segments.slice(0, index).join("/")}` : "";
+  }
+  return isMountRoot && segments.length ? `/${segments.join("/")}` : "";
+}
+
+export function locationForRoute(routeId: RouteId, basePath: string): RouteLocation {
+  return {
+    pathname: pathForRoute(routeId, basePath),
+    search: "",
+    hash: "",
+  };
+}