refactor(PropertyIntelligenceCard): smaller image, larger text, more spacing

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

.claude/settings.json

@@ -10,7 +10,26 @@
       "Bash(awk '{print $NF}')",
       "Bash(start http://localhost:5173)",
       "Bash(npm install *)",
-      "Bash(git pull *)"
+      "Bash(git pull *)",
+      "Bash(node scripts/check-tokens.js)",
+      "Bash(echo \"EXIT:$?\")",
+      "Bash(echo \"EXIT_CODE:$?\")",
+      "Bash(Get-ChildItem \"c:\\\\Users\\\\beni_\\\\AppData\\\\Local\\\\Temp\\\\docx-gen\\\\node_modules\\\\docx\" -Recurse -Name)",
+      "Bash(start \"C:\\\\Users\\\\beni_\\\\OneDrive\\\\Desktop\\\\property-match\\\\Aenderungsprotokoll_Meeting_26052026.docx\")",
+      "Bash(start http://localhost:5176)",
+      "Bash(start http://localhost:5176/demand/ai-search)",
+      "Bash(node -e ' *)",
+      "Skill(run)",
+      "Skill(run:*)",
+      "Bash(curl -s -o /dev/null -w \"%{http_code}\" http://localhost:5173)",
+      "Bash(powershell.exe -Command \"Start-Process 'http://localhost:5173'\")",
+      "Bash(findstr \"LISTENING\")",
+      "Bash(findstr \":517\")",
+      "Bash(findstr \"LISTEN\")",
+      "Bash(findstr \":5\")",
+      "Bash(echo \"Exit: $?\")",
+      "Bash(npx vercel *)",
+      "Bash(Start-Process \"http://localhost:5180\")"
     ]
   }
 }

.claude/settings.local.json

@@ -2,7 +2,26 @@
   "permissions": {
     "allow": [
       "Bash(git commit -m ' *)",
-      "Bash(git commit *)"
+      "Bash(git commit *)",
+      "Bash(node -e ' *)",
+      "Bash(git stash *)",
+      "Read(//c/Users/beni_/.claude/projects/c--Users-beni--OneDrive-Desktop-property-match/8e388ddd-e02e-47fe-8bb9-cdb8164c9fc3/tool-results/**)",
+      "Bash(pandoc --version)",
+      "Bash(npm list *)",
+      "Read(//c/Program Files/LibreOffice/program/**)",
+      "Read(//c/Program Files/Microsoft Office/**)",
+      "Read(//c/Program Files \\(x86\\)/**)",
+      "Bash(mkdir -p /tmp/docx-gen)",
+      "Read(//tmp/**)",
+      "Bash(npm init *)",
+      "Bash(node generate.js)",
+      "Bash(timeout 8 bash -c \"until curl -s http://localhost:5173 > /dev/null; do sleep 1; done\")",
+      "Bash(dir \"c:\\\\Users\\\\beni_\\\\OneDrive\\\\Desktop\\\\property-match\\\\src\" -Depth 2)",
+      "Bash(start \"\" \"http://localhost:5178/demand/results\")",
+      "Bash(start \"\" \"http://localhost:5178/supply/properties\")"
+    ],
+    "additionalDirectories": [
+      "c:\\Users\\beni_\\AppData\\Local\\Temp\\docx-gen"
     ]
   }
 }

.vercel/README.txt

@@ -0,0 +1,11 @@
+> Why do I have a folder named ".vercel" in my project?
+The ".vercel" folder is created when you link a directory to a Vercel project.
+
+> What does the "project.json" file contain?
+The "project.json" file contains:
+- The ID of the Vercel project that you linked ("projectId")
+- The ID of the user or team your Vercel project is owned by ("orgId")
+
+> Should I commit the ".vercel" folder?
+No, you should not share the ".vercel" folder with anyone.
+Upon creation, it will be automatically added to your ".gitignore" file.

.vercel/project.json

@@ -0,0 +1 @@
+{"projectId":"prj_0UhtBM4Jg83OXPDkzhOM6x0gYfEY","orgId":"team_Quh2pScdkVSiGHkdwh6ntKZ5","projectName":"property-match"}

ARCHITECTURE.md

@@ -0,0 +1,476 @@
+# Property Match — Architecture Reference
+
+> This document describes the architecture of the Property Match platform.
+> For coding rules see [CLAUDE.md](./CLAUDE.md).
+> For state management patterns see [STATE_MANAGEMENT.md](./STATE_MANAGEMENT.md).
+
+---
+
+## 1. Folder Structure
+
+```
+src/
+├── assets/                      Static images, icons
+│
+├── domain/                      TypeScript types & enums (single source of truth)
+│   ├── enums.ts                 AssetType, ResultType, MatchStatus, UserRole, WorkspaceType
+│   ├── match.ts                 Match, ScoreBreakdown, ScoreFactor, TradeOff, Risk
+│   ├── property.ts              Property, Location, ContactPerson
+│   ├── need.ts                  Need, AreaRange, BudgetRange, WeightingProfile
+│   ├── unifiedResult.ts         UnifiedMatchResult (discriminated union)
+│   ├── scoring.ts               ScoringWeightProfile, MatchEngineOutput
+│   ├── aiOutput.ts              AI scoring, extraction, monitoring types
+│   ├── futureSignal.ts          Future availability signals
+│   ├── pipeline.ts              Pipeline stages & items
+│   ├── inquiry.ts               Demand-side inquiry records
+│   ├── reminder.ts              Reminder & DueDate
+│   └── index.ts                 Barrel re-exports
+│
+├── features/                    Business logic algorithms (pure TypeScript)
+│   └── matching/
+│       ├── scoreCalculator.ts   Hard/soft scoring, confidence & DQ modifiers
+│       ├── rankingEngine.ts     Match ranking, unified result assembly
+│       ├── mustHaveScorer.ts    Must-have criteria evaluation
+│       ├── tradeOffAnalyzer.ts  Tradeoff, risk, and missing-data analysis
+│       └── matchCardAdapter.ts  Match → MatchCardViewModel adapter
+│
+├── provider/                    Data access layer (interface + mock per entity)
+│   ├── IPropertyProvider.ts
+│   ├── MockupPropertyProvider.ts
+│   ├── INeedProvider.ts
+│   ├── MockupNeedProvider.ts
+│   └── ... (one pair per entity)
+│
+├── services/                    Business logic services
+│   ├── ai/
+│   │   ├── IAIService.ts        AI capability interface
+│   │   ├── MockAIService.ts     Deterministic mock (dev/CI)
+│   │   ├── OpenRouterAIService.ts  Real LLM calls (production)
+│   │   └── prompts/             Structured prompt templates
+│   ├── matchService.ts
+│   ├── needService.ts
+│   ├── propertyService.ts
+│   ├── aiMonitoringService.ts
+│   ├── governanceService.ts
+│   ├── types.ts                 ListResponse<T>, ItemResponse<T>
+│   └── errors.ts                throwServiceError()
+│
+├── hooks/                       React Query wrappers
+│   ├── useProperties.ts
+│   ├── useMatches.ts
+│   ├── useUnifiedResults.ts     Aggregates all result types for demand feed
+│   └── ... (one file per entity)
+│
+├── stores/                      Zustand UI stores (global UI state only)
+│   ├── sessionStore.ts          Auth, currentUser, workspace
+│   ├── compareStore.ts          Compare tray items (max 4)
+│   ├── pipelineStore.ts         Pipeline items + add-dialog
+│   ├── assistantStore.ts        AI assistant drawer conversation
+│   ├── offerWizardStore.ts      Multi-step offer wizard
+│   ├── layoutStore.ts           Sidebar, right panel, active workspace
+│   ├── matchCenterStore.ts      Supply match center selection
+│   ├── reminderStore.ts         Reminder filters + drawer
+│   ├── shortlistStore.ts        Shortlist selection + add-dialog
+│   └── toastStore.ts            Toast notification queue
+│
+├── lib/                         Shared utilities & design system
+│   ├── constants.ts             All thresholds, labels, stale times, routes
+│   ├── ds.ts                    DS_COLORS, RESULT_TYPE_META, score → level converters
+│   ├── utils.ts                 matchScoreHex, confidenceHex, dataQualityColor, formatters
+│   ├── theme.ts                 MUI theme
+│   ├── queryClient.ts           TanStack Query client config
+│   ├── permissions.ts           Role-based access helpers
+│   ├── locationIntelligence.ts  Location scoring
+│   └── propertyHeat.ts          Market heat analysis
+│
+├── components/                  UI components (organized by feature)
+│   ├── layout/                  AppShell, PageHeader, RightContextPanel
+│   ├── ui/                      ErrorBoundary, EmptyState, Toast, DecisionContextPanel
+│   ├── shared/                  LocationPreview, ViewToggle (cross-feature)
+│   ├── match-card/              MatchCard variants (compact/expanded/review/compare-mini)
+│   ├── match-detail/            MatchDetailHero, ScoreBreakdownPanel, CriterionRow
+│   ├── compare/                 CompareMetricRow, CompareColumn, compareUtils
+│   ├── pipeline/                PipelineCard, PipelineColumn, pipelineConstants, pipelineUtils
+│   ├── results/                 UnifiedResultFeed, ResultFilterBar, ResultTypeBadge
+│   ├── supply/                  PropertyIntelligenceCard, ReminderFeed, ReminderListRow, ...
+│   ├── demand/                  NeedInput, WeightingEditor, CriteriaReviewPanel, ...
+│   ├── future-signals/          SignalCard, SignalFilterBar, FutureAvailabilityPanel, ...
+│   ├── data-quality/            DataQualityPanel, FreshnessIndicator, ProvenancePanel, ...
+│   ├── badges/                  ConfidenceBadge, RiskBadge, FreshnessBadge, ...
+│   ├── ai-monitoring/           AI audit log UI
+│   └── ...
+│
+├── pages/                       Route-level page components
+│   ├── auth/LoginScreen.tsx
+│   ├── supply/                  SupplyDashboard, Properties, MatchCenter, ...
+│   ├── demand/                  AISearch, Results, MatchDetail, Compare, Pipeline, ...
+│   └── ops/                     MarketIntelligence
+│
+├── mock-data/                   Seed data for mock providers
+│
+├── App.tsx                      React Router setup (all routes, lazy-loaded)
+└── index.css                    Tailwind layer imports (no project styles here)
+```
+
+---
+
+## 2. Data Flow Overview
+
+The core data flow is **unidirectional** across four layers.
+
+```
+┌─────────────────────────────────────────────────────────────────────────┐
+│                          Component / Page                                │
+│                                                                          │
+│   Reads: useQuery hook         Writes: useMutation hook                 │
+│   UI state: Zustand selector   Side effects: useEffect                  │
+└────────────────┬──────────────────────────┬────────────────────────────┘
+                 │ calls                     │ calls
+                 ▼                           ▼
+┌────────────────────────────────────────────────────────────────────────┐
+│                             Hook Layer                                  │
+│                        src/hooks/*.ts                                   │
+│                                                                         │
+│   useQuery({ queryFn: () => service.getAll() })                        │
+│   useMutation({ mutationFn: (data) => service.create(data) })          │
+└────────────────────────────────┬───────────────────────────────────────┘
+                                 │ calls
+                                 ▼
+┌────────────────────────────────────────────────────────────────────────┐
+│                           Service Layer                                 │
+│                        src/services/*.ts                                │
+│                                                                         │
+│   Business logic, error handling, response standardization             │
+│   Reads session via sessionStore.getState()                            │
+│   Calls scoring engine (features/matching/) as needed                  │
+└────────────────────────────────┬───────────────────────────────────────┘
+                                 │ calls
+                                 ▼
+┌────────────────────────────────────────────────────────────────────────┐
+│                           Provider Layer                                │
+│                        src/provider/*.ts                                │
+│                                                                         │
+│   IPropertyProvider (interface)                                        │
+│   MockupPropertyProvider (in-memory, dev)  ← swap →  RestPropertyProvider (prod)
+└────────────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 3. Provider Swap Flow
+
+Swapping from mock to real requires **one file change** — the service import. No hooks, components, or tests change.
+
+```
+Dev / CI                                Production
+─────────────────────────────────────   ─────────────────────────────────────
+propertyService.ts                      propertyService.ts
+  import provider from                    import provider from
+    './MockupPropertyProvider'              './RestPropertyProvider'
+                                                  ↑
+                                         One line change — nothing else
+```
+
+Provider interfaces enforce the contract. All methods are `async`. Mock providers hold in-memory seed data from `src/mock-data/`.
+
+---
+
+## 4. State Architecture
+
+```
+                  ┌──────────────────────────────────────────┐
+                  │              React Query Cache            │
+                  │                                          │
+                  │   ['properties']  ──  5 min stale        │
+                  │   ['matches', needId]  ──  2 min stale   │
+                  │   ['signals']  ──  5 min stale           │
+                  │   ['review-queue']  ──  30 s stale       │
+                  │                                          │
+                  │   ← server data, cached, invalidated     │
+                  │     on mutation success →                │
+                  └──────────────────────────────────────────┘
+
+                  ┌──────────────────────────────────────────┐
+                  │              Zustand Stores              │
+                  │                                          │
+                  │   sessionStore    ← auth, currentUser    │
+                  │   layoutStore     ← sidebar, workspace   │
+                  │   compareStore    ← compare tray items   │
+                  │   pipelineStore   ← pipeline + dialog    │
+                  │   assistantStore  ← AI chat conversation │
+                  │   offerWizardStore← multi-step wizard    │
+                  │   reminderStore   ← filter + drawer      │
+                  │   toastStore      ← notification queue   │
+                  │                                          │
+                  │   ← UI state only, no server data →      │
+                  └──────────────────────────────────────────┘
+
+                  ┌──────────────────────────────────────────┐
+                  │           Component Local State          │
+                  │                                          │
+                  │   useState  ← form inputs, toggles       │
+                  │   useMemo   ← derived / filtered lists   │
+                  │   useCallback ← stable callbacks         │
+                  └──────────────────────────────────────────┘
+```
+
+---
+
+## 5. Matching & Scoring Flow
+
+The matching engine (`src/features/matching/`) produces all scores. Components never compute scores — they display them.
+
+```
+Need (criteria)    +    Property (attributes)
+       │                        │
+       └───────────┬────────────┘
+                   ▼
+        ┌─────────────────────┐
+        │   scoreCalculator   │
+        │                     │
+        │  1. Hard filters    │  ← Exclusions (wrong type, out of area, etc.)
+        │  2. Hard scoring    │  ← Area, location, budget, timing, asset type (0–100 each)
+        │  3. Soft scoring    │  ← Prestige, accessibility, ESG, footfall, etc. (0–100 each)
+        │  4. Modifiers       │  ← confidenceModifier (-20→+5) + dataQualityModifier (-15→0)
+        │  5. totalScore      │  ← Weighted average + modifiers (0–100)
+        └──────────┬──────────┘
+                   │
+                   ▼
+        ┌─────────────────────┐
+        │   tradeOffAnalyzer  │  ← TradeOff[], Risk[], MissingDataItem[]
+        └──────────┬──────────┘
+                   │
+                   ▼
+        ┌─────────────────────┐
+        │   rankingEngine     │  ← Builds Match[], ranks, adds NextBestAction[]
+        └──────────┬──────────┘
+                   │
+                   ▼
+        ┌─────────────────────┐
+        │  matchCardAdapter   │  ← Match → MatchCardViewModel (UI props)
+        └──────────┬──────────┘
+                   │
+                   ▼
+           MatchCard / MatchDetail / Compare
+```
+
+**ScoreBreakdown shape:**
+
+```ts
+{
+  hardMatchScore: number       // 0–100: area, location, budget, timing, usage
+  softFactorScore: number      // 0–100: prestige, accessibility, ESG, etc.
+  confidenceModifier: number   // –20 → +5
+  dataQualityModifier: number  // –15 → 0
+  totalScore: number           // 0–100 final score
+  positiveFactors: ScoreFactor[]   // top reasons this is a good match
+  negativeFactors: ScoreFactor[]   // top concerns
+  tradeOffs: TradeOff[]            // explicit trade-off explanations
+  risks: Risk[]                    // risk categories
+  missingData: MissingDataItem[]   // fields that would improve the score
+}
+```
+
+---
+
+## 6. AI Flow
+
+```
+User input (text / voice)
+         │
+         ▼
+  NeedInput component
+         │  calls
+         ▼
+  aiService.parseNeed(text)
+         │  routes to
+         ├── MockAIService (dev) ──────────────► deterministic ParsedNeed
+         └── OpenRouterAIService (prod) ────────► LLM API call
+                    │
+                    │  validates with Zod
+                    ▼
+             ParseNeedResult
+             { need: Partial<Need>, confidence: number, followUpQuestions: string[] }
+                    │
+                    ▼
+       CriteriaReviewPanel
+       (user confirms / overrides AI-extracted criteria)
+                    │
+                    ▼
+          Need saved → Results feed runs
+```
+
+**AI Governance loop:**
+
+```
+Every AI call
+     │
+     ├─► aiMonitoringService.log({ modelId, promptHash, responseDigest, userId, ... })
+     │
+     └─► Visible in /ops/ai-monitoring (review queue for ops team)
+```
+
+**AI never speaks directly to the UI.** All AI outputs go through:
+1. `IAIService` interface method
+2. Zod validation
+3. Typed domain object
+4. Component that renders it with explainability metadata
+
+---
+
+## 7. Unified Result Feed Flow (Demand)
+
+The demand workspace shows a unified feed that merges three result types.
+
+```
+useUnifiedResults(needId)
+         │
+         ├─► matchService.getForNeed(needId)
+         │        └─► VERIFIED_PORTFOLIO matches (own properties)
+         │        └─► EXTERNAL_MARKET matches (partner/scraped)
+         │
+         ├─► aiService.getMaisonWorkResults(needId)
+         │        └─► MAISON_WORK matches (AI-suggested)
+         │
+         └─► futureSignalService.getForNeed(needId)
+                  └─► FUTURE_AVAILABILITY signals (AI-predicted)
+                           ├── probabilityScore (0–1)
+                           ├── signalBasis (string)
+                           └── expectedAvailabilityDate
+
+All merged into UnifiedMatchResult[]
+Sorted by matchScore desc (default)
+         │
+         ▼
+UnifiedResultFeed
+  ├── MatchCard (VERIFIED_PORTFOLIO, EXTERNAL_MARKET, MAISON_WORK)
+  └── FutureAvailabilityCard (FUTURE_AVAILABILITY — different visual treatment)
+```
+
+**Future Availability signals are probabilistic** — they must always show `probabilityScore` and a basis explanation. They are never presented as confirmed availability.
+
+---
+
+## 8. Three-Workspace Architecture
+
+```
+App.tsx
+  │
+  ├── /auth/login  → LoginScreen
+  │
+  ├── /supply/*  ──────────────────────────────────► SUPPLY workspace
+  │     Protected: WorkspaceType.SUPPLY             (PropertyManager, OrgAdmin)
+  │     Pages: SupplyDashboard, Properties,
+  │            MatchCenter, Anfragencenter,
+  │            FutureAvailability, DataQuality,
+  │            ReminderManager, MarketLeads,
+  │            NewListing, MyListings
+  │
+  ├── /demand/*  ──────────────────────────────────► DEMAND workspace
+  │     Protected: WorkspaceType.DEMAND             (Tenant, CompanyAdmin)
+  │     Pages: AISearch, Results, MatchDetail,
+  │            Compare, Pipeline, Anfragen,
+  │            PropertyDetail, Shortlists
+  │
+  └── /ops/*  ────────────────────────────────────► OPERATIONS workspace
+        Protected: WorkspaceType.OPERATIONS         (Internal staff)
+        Pages: MarketIntelligence
+```
+
+Route protection enforced by `<ProtectedRoute workspace={...} />`. Each workspace has distinct data flows and does not share components with other workspaces unless through `src/components/shared/` or `src/components/ui/`.
+
+---
+
+## 9. Decision Screen Design Pattern
+
+Every page is built around **one user decision**. The `DecisionContextPanel` component surfaces this explicitly at the top of each page.
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│ PageHeader — title, subtitle, secondary actions (ViewToggle) │
+├─────────────────────────────────────────────────────────────┤
+│ DecisionContextPanel                                         │
+│   decision: "Which matches are ready to shortlist?"         │
+│   context:  "Search: OFFICE · 200–500 m² · Zürich"         │
+│   metrics:  [strongMatches: 3 ✓] [withGaps: 2 ⚠]          │
+│   risks:    ["2 results have missing floor plan data"]      │
+│   actions:  [Open Compare] [Refine Search]                  │
+├─────────────────────────────────────────────────────────────┤
+│ FilterBar / Controls                                         │
+├─────────────────────────────────────────────────────────────┤
+│ Content (list / grid / table / kanban)                       │
+└─────────────────────────────────────────────────────────────┘
+```
+
+If a screen cannot answer "what decision does this help the user make?", the design is wrong.
+
+---
+
+## 10. Error Boundary Architecture
+
+```
+App.tsx
+└── AppErrorBoundary (top-level catch-all)
+    └── Route components
+        └── Feature-level try/catch in services
+            └── Error state passed via useQuery error prop
+                └── <ErrorState message={...} /> or <UnauthorizedState />
+```
+
+Every page handles three states: loading (`<FeedSkeleton />`), error (`<ErrorState />`), and empty (`<FeedEmptyState />`). These are never omitted.
+
+---
+
+## 11. Component Dependency Rules
+
+```
+pages/          can import from   components/, hooks/, stores/, lib/, domain/
+components/     can import from   components/, hooks/, stores/, lib/, domain/
+hooks/          can import from   services/, lib/, domain/
+services/       can import from   provider/, features/, lib/, domain/
+features/       can import from   lib/, domain/
+provider/       can import from   domain/, mock-data/
+lib/            can import from   (nothing in src — pure utilities)
+domain/         can import from   (nothing — types only)
+stores/         can import from   domain/, lib/
+```
+
+**Forbidden imports:**
+- `services/` must not import React hooks
+- `domain/` must not import anything from `src/`
+- `lib/constants.ts` must not import from components or services
+- Circular imports of any kind
+
+---
+
+## 12. Key Design System Tokens
+
+```
+Scores (0–100 scale)
+  ≥ 80  →  STRONG   →  DS_COLORS.confidence.high   (#1a7a4a)
+  ≥ 60  →  MODERATE →  DS_COLORS.confidence.medium (#d97706)
+  < 60  →  WEAK     →  DS_COLORS.confidence.low    (#c0392b)
+
+Confidence (0–1 scale)
+  ≥ 0.85  →  HIGH    →  DS_COLORS.confidence.high
+  ≥ 0.65  →  MEDIUM  →  DS_COLORS.confidence.medium
+  < 0.65  →  LOW     →  DS_COLORS.confidence.low
+
+Data Quality (0–1 scale)
+  ≥ 0.80  →  HIGH
+  ≥ 0.60  →  MEDIUM
+  < 0.60  →  LOW
+
+Result Types
+  VERIFIED_PORTFOLIO  →  label 'Plattform'      color #1e3a5f
+  EXTERNAL_MARKET     →  label 'Plattform'      color #1e3a5f
+  MAISON_WORK         →  label 'Maison Work'    color #0369a1
+  FUTURE_AVAILABILITY →  label 'Zukunftssignal' color #7c3aed
+
+Freshness
+  FRESH    →  DS_COLORS.freshness.fresh    (#1a7a4a)
+  STALE    →  DS_COLORS.freshness.stale    (#d97706)
+  OUTDATED →  DS_COLORS.freshness.outdated (#dc2626)
+```
+
+All tokens from `src/lib/ds.ts`. All thresholds from `src/lib/constants.ts`.

CLAUDE.md

@@ -1,40 +1,99 @@
-# property-match — Development Guidelines
+# property-match — Engineering Guidelines
 
-## Stack
+> **This file is read by Claude Code on every session.** All rules here are binding.
+> For architecture diagrams and data flows see [ARCHITECTURE.md](./ARCHITECTURE.md).
+> For the pre-commit review checklist see [CODE_REVIEW_CHECKLIST.md](./CODE_REVIEW_CHECKLIST.md).
+> For state management patterns see [STATE_MANAGEMENT.md](./STATE_MANAGEMENT.md).
 
-- **Vite 8** + **React 19** + **TypeScript 6**
-- **MUI v9** (`@mui/material`) — primary component library
-- **Tailwind CSS v4** — utility classes via `@tailwindcss/vite` (no `tailwind.config.js`)
-- **React Router v7** — import from `react-router`, not `react-router-dom`
+---
 
-## Components
+## 1. Project Vision
 
-Always reach for an existing MUI component before writing a custom one. Check the [MUI component list](https://mui.com/material-ui/all-components/) first. Only build a custom component when MUI has no equivalent or the required behavior diverges significantly from what MUI provides.
+Property Match is a **Decision Intelligence Platform** — not a real estate portal.
 
-## Styling
+The distinction matters for every design decision:
 
-Use Tailwind utility classes for all layout and styling. Do not write plain CSS rules or add styles to `.css` files. The only CSS file is `src/index.css`, which holds the Tailwind layer imports — do not add project styles there.
+| Classical Portal | Decision Intelligence |
+|---|---|
+| Show listings, let the user decide | Surface scored matches with explainability |
+| Generic SaaS listing UI | Every screen is designed around one user decision |
+| More filters = better | Fewer, smarter signals = better |
+| Trust by volume | Trust by transparency |
 
+**Three design principles that override everything else:**
 
-## Providers
+1. **Explainability-first.** Every score, badge, and recommendation must be traceable. If the user cannot understand *why* a match is strong, the feature is not done. Score breakdowns, trade-off panels, risk indicators, and data provenance are first-class UI elements — not tooltips added at the end.
 
-All data access and data actions live in `src/provider/`.
+2. **Trust-first.** Confidence levels, data freshness, and missing-data warnings are shown proactively. We never surface a result that looks more certain than the underlying data supports. When data is stale or incomplete, we say so.
 
-### Naming
+3. **Better-than-Google.** A property search result that just shows "here are things that match your query" fails the user. Property Match should rank, explain trade-offs, surface future signals, and give the user a clear recommended next action — like a trusted advisor, not a search engine.
 
-| Rule | Example |
-|------|---------|
-| Every provider file/class is suffixed `Provider` | `PropertyProvider`, `UserProvider` |
-| Every provider backed by mock data is also prefixed `Mockup` | `MockupPropertyProvider`, `MockupUserProvider` |
+---
 
-### Interface pattern
+## 2. Stack
 
-Define a TypeScript interface for each provider so the mockup and the real implementation are interchangeable:
-Every Interface should be prefixed with a capitalized I.
+| Technology | Version | Role |
+|---|---|---|
+| Vite | 8 | Build tool & dev server |
+| React | 19 | UI framework |
+| TypeScript | 6 | Type safety |
+| MUI | v9 (`@mui/material`) | Component library |
+| Tailwind CSS | v4 | Utility classes (via `@tailwindcss/vite`) |
+| React Router | v7 | Routing — import from `react-router`, not `react-router-dom` |
+| TanStack Query | v5 | Server state & caching |
+| Zustand | v5 | Global UI state |
+| @dnd-kit | current | Drag-and-drop (Pipeline board) |
+| Zod | current | Schema validation |
+| Lucide React | current | Icon set (supplementary to MUI icons) |
+
+**There is no `tailwind.config.js`.** Tailwind v4 uses `@tailwindcss/vite` — config is inline.
+
+---
+
+## 3. Three-Workspace Architecture
+
+The app is organized into three protected workspaces. Every route lives in exactly one workspace.
+
+| Workspace | Route prefix | Primary user | Core job-to-be-done |
+|---|---|---|---|
+| **SUPPLY** | `/supply/*` | Property manager / owner | Manage inventory, respond to demand, monitor market |
+| **DEMAND** | `/demand/*` | Tenant / company | Find, compare, and pipeline commercial space |
+| **OPERATIONS** | `/ops/*` | Internal staff | AI governance, market intelligence, audit logs |
+
+Route protection is enforced at the router level via `<ProtectedRoute workspace={WorkspaceType.X} />`. Never add workspace-specific logic inside shared components — pass `isStaff`, `isOwner`, etc. as props.
+
+---
+
+## 4. Layered Architecture
+
+Data and logic flow through four explicit layers. **Never skip a layer.**
+
+```
+Provider  →  Service  →  Hook (React Query)  →  Component
+```
+
+### 4.1 Provider Layer (`src/provider/`)
+
+Providers are the **only** code that touches data storage. Everything else goes through them.
+
+**Rules:**
+- Every entity has an interface: `I[Entity]Provider` (file: `I[Entity]Provider.ts`)
+- Every interface is implemented by a mockup: `Mockup[Entity]Provider` (file: `Mockup[Entity]Provider.ts`)
+- Every method is `async` and returns a `Promise` — even in the mockup
+- Mockups hold in-memory seed data from `src/mock-data/`
+- Real implementations swap in without changing any call sites
+
+**Naming:**
+
+| Pattern | Example |
+|---|---|
+| Interface | `IPropertyProvider` |
+| Mock implementation | `MockupPropertyProvider` |
+| Real implementation (future) | `RestPropertyProvider`, `SupabasePropertyProvider` |
 
 ```ts
 // src/provider/IPropertyProvider.ts
-export interface PropertyProvider {
+export interface IPropertyProvider {
   getAll(): Promise<Property[]>
   getById(id: string): Promise<Property | null>
   create(data: CreatePropertyInput): Promise<Property>
@@ -43,38 +102,482 @@ export interface PropertyProvider {
 }
 ```
 
-### Async methods
-
-Every method in a provider must be `async` and return a `Promise`, even in the mockup. This ensures the real provider can be swapped in without changing any call sites.
-
 ```ts
 // src/provider/MockupPropertyProvider.ts
-import type { PropertyProvider } from './PropertyProvider'
-
-const properties: Property[] = [ /* seed data */ ]
-
-export const MockupPropertyProvider: PropertyProvider = {
-  async getAll() {
-    return [...properties]
-  },
-  async getById(id) {
-    return properties.find(p => p.id === id) ?? null
-  },
-  async create(data) {
-    const next: Property = { id: crypto.randomUUID(), ...data }
-    properties.push(next)
-    return next
-  },
-  async update(id, data) {
-    const idx = properties.findIndex(p => p.id === id)
-    properties[idx] = { ...properties[idx], ...data }
-    return properties[idx]
-  },
-  async remove(id) {
-    const idx = properties.findIndex(p => p.id === id)
-    properties.splice(idx, 1)
-  },
+export const MockupPropertyProvider: IPropertyProvider = {
+  async getAll() { return [...properties] },
+  async getById(id) { return properties.find(p => p.id === id) ?? null },
+  // ...
 }
 ```
 
-Swap to a real implementation by replacing `MockupPropertyProvider` with a provider that calls an API — no other code changes required.
+**Anti-patterns:**
+- Never call a provider directly from a component — use a service
+- Never mutate provider state from outside the provider
+- Never share state across providers (cross-provider coupling creates hidden dependencies)
+
+### 4.2 Service Layer (`src/services/`)
+
+Services wrap providers with business logic, error handling, and response standardization.
+
+**Rules:**
+- Named `[entity]Service` (e.g., `matchService`, `needService`)
+- Return standardized types: `ListResponse<T>` or `ItemResponse<T>` from `services/types.ts`
+- Errors are thrown via `throwServiceError()` from `services/errors.ts`
+- Services never import React hooks — they are plain TypeScript
+- Services access Zustand stores via `getState()`, never via `useStore()` hooks
+
+```ts
+// ✅ Service accessing auth — no hook
+const user = useSessionStore.getState().currentUser
+```
+
+### 4.3 Hook Layer (`src/hooks/`)
+
+Hooks wrap React Query around services.
+
+**Rules:**
+- One hook file per entity: `useProperties.ts`, `useMatches.ts`, etc.
+- `useQuery` for reads, `useMutation` for writes
+- Query keys follow the convention in STATE_MANAGEMENT.md
+- Stale times are imported from `src/lib/constants.ts` — never defined locally in hooks
+- Mutations call `queryClient.invalidateQueries` on success
+
+```ts
+// ✅ Stale time from constants — never local
+import { STALE_PROPERTIES } from '../lib/constants'
+export function useProperties() {
+  return useQuery({ queryKey: ['properties'], queryFn: () => propertyService.getAll(), staleTime: STALE_PROPERTIES })
+}
+```
+
+### 4.4 Component Layer (`src/components/` + `src/pages/`)
+
+Components are **pure UI**. They render data, dispatch mutations, and show state. They do not contain business logic.
+
+---
+
+## 5. Component Rules
+
+### 5.1 Size Limits
+
+| File type | Hard limit | Soft target |
+|---|---|---|
+| Page component (`src/pages/`) | 300 lines | 150–200 lines |
+| Feature component | 250 lines | 100–150 lines |
+| Atom/shared component | 150 lines | 50–100 lines |
+
+When a component exceeds its soft target, split it. Extract sub-components, move constants to a `*Constants.ts` file, move pure helpers to a `*Utils.ts` file (`.tsx` if it returns JSX).
+
+### 5.2 No Business Logic in JSX
+
+The render body is for presentation only. All logic belongs upstream.
+
+```tsx
+// ❌ Business logic in JSX
+{matches.filter(m => m.score > 70 && m.status !== 'DISMISSED').map(...)}
+
+// ✅ Logic in useMemo, computed before the return
+const visibleMatches = useMemo(
+  () => matches.filter(m => m.score > 70 && m.status !== 'DISMISSED'),
+  [matches]
+)
+// then:
+{visibleMatches.map(...)}
+```
+
+### 5.3 No Magic Strings
+
+Every label, status, color, and route string has a named constant.
+
+```ts
+// ❌
+if (user.role === 'PROPERTY_MANAGER') { ... }
+navigate('/supply/properties')
+
+// ✅
+import { UserRole } from '../domain/enums'
+import { ROUTES } from '../lib/constants'
+if (user.role === UserRole.PROPERTY_MANAGER) { ... }
+navigate(ROUTES.SUPPLY.PROPERTIES)
+```
+
+All German UI labels for enums live in `src/lib/constants.ts` (e.g., `ASSET_TYPE_LABELS`, `AVAILABILITY_LABELS`).
+
+### 5.4 No `any` Casts
+
+`any` disables TypeScript. Use `unknown` with type guards, or fix the type properly.
+
+```ts
+// ❌
+const result = response as any
+const { data } = result
+
+// ✅
+const result: ItemResponse<Property> = response
+const { data } = result
+```
+
+The one allowed exception: third-party library types that don't ship proper types. Wrap the cast in a type-safe adapter so the `any` is isolated.
+
+### 5.5 No Duplicated State
+
+If a value can be computed from existing state, compute it. Do not store it.
+
+```ts
+// ❌ Duplicated — sync bugs guaranteed
+const [overdueCount, setOverdueCount] = useState(0)
+useEffect(() => setOverdueCount(reminders.filter(r => isPast(r.dueDate)).length), [reminders])
+
+// ✅ Derived inline
+const overdueCount = reminders.filter(r => isPast(r.dueDate)).length
+```
+
+See STATE_MANAGEMENT.md for the full decision tree.
+
+### 5.6 Component Library First
+
+Before writing a custom component, check the [MUI component list](https://mui.com/material-ui/all-components/). Only build custom when:
+- MUI has no equivalent, or
+- The required behavior diverges significantly from what MUI provides
+
+### 5.7 Styling
+
+Use Tailwind utility classes for all layout and spacing. Use MUI's `sx` prop for component-specific overrides and theme values. **Never add styles to `.css` files.** The only CSS file is `src/index.css` (Tailwind layer imports) — do not add project styles there.
+
+---
+
+## 6. State Management
+
+Full rules in [STATE_MANAGEMENT.md](./STATE_MANAGEMENT.md). Summary:
+
+| Data type | Where it lives |
+|---|---|
+| Server data (fetched from provider) | React Query (`useQuery`) |
+| Write operations | React Query (`useMutation`) |
+| Global UI state (dialog open/close, compare tray, wizard steps) | Zustand store |
+| Auth session | `sessionStore` (Zustand, also read by services via `getState()`) |
+| Component-local state (form inputs, hover, toggle) | `useState` |
+| Values derived from existing state | Computed inline — never stored |
+
+**Critical rules:**
+- Never copy React Query data into a Zustand store
+- Never call `useStore()` without a selector (use `s => s.field`)
+- Services read Zustand via `getState()`, never via hooks
+- Side effects (cache invalidation, analytics) go in `useEffect`, never in the render body
+
+---
+
+## 7. Domain & Types
+
+### 7.1 Single Source of Truth
+
+All domain types live in `src/domain/`. Never duplicate a type or interface.
+
+| File | Contents |
+|---|---|
+| `enums.ts` | All enums: `AssetType`, `ResultType`, `MatchStatus`, `UserRole`, `WorkspaceType`, etc. |
+| `property.ts` | `Property`, `Location`, `ContactPerson` |
+| `match.ts` | `Match`, `ScoreBreakdown`, `ScoreFactor`, `TradeOff`, `Risk` |
+| `need.ts` | `Need`, `AreaRange`, `BudgetRange`, `WeightingProfile` |
+| `unifiedResult.ts` | `UnifiedMatchResult` (the discriminated union for result feeds) |
+| `scoring.ts` | `ScoringWeightProfile`, `HardFilterResult`, `MatchEngineOutput` |
+| `aiOutput.ts` | AI scoring, extraction, monitoring types |
+| ... | See `/domain/index.ts` for full list |
+
+### 7.2 No Inline Type Duplication
+
+```ts
+// ❌ Redefining a type locally
+interface LocalProperty { id: string; title: string; ... }
+
+// ✅ Import from domain
+import type { Property } from '../../domain/property'
+```
+
+### 7.3 Response Types
+
+All service responses use the standardized wrapper from `src/services/types.ts`:
+
+```ts
+type ListResponse<T> = { data: T[]; total: number }
+type ItemResponse<T> = { data: T }
+```
+
+---
+
+## 8. Design System
+
+All visual constants are centralized. **Never hardcode a color, spacing multiplier, or border-radius in a component.**
+
+### 8.1 Color Tokens (`src/lib/ds.ts`)
+
+```ts
+DS_COLORS.confidence.high   // '#1a7a4a'
+DS_COLORS.confidence.medium // '#d97706'
+DS_COLORS.confidence.low    // '#c0392b'
+DS_COLORS.risk.critical     // '#dc2626'
+DS_COLORS.risk.warning      // '#d97706'
+DS_COLORS.freshness.stale   // '#d97706'
+DS_COLORS.freshness.outdated// '#dc2626'
+```
+
+### 8.2 Score → Color Helpers (`src/lib/utils.ts`)
+
+| Function | Input | Output | Use for |
+|---|---|---|---|
+| `matchScoreHex(score)` | 0–100 | hex string | Overall match score color |
+| `confidenceHex(score)` | 0–1 | hex string | Confidence score color |
+| `dataQualityColor(score)` | 0–1 | hex string | Data quality color |
+| `criterionScoreColor(score)` | 0–100 | MUI color token | Individual criterion badge |
+| `criterionScoreTextColor(score)` | 0–100 | hex string | Criterion text color |
+
+### 8.3 Result Type Metadata (`src/lib/ds.ts`)
+
+Use `RESULT_TYPE_META[resultType]` for label, color, and background. Never define these inline.
+
+```ts
+// ❌
+label="Verified Portfolio"
+bgcolor="#1e3a5f"
+
+// ✅
+import { RESULT_TYPE_META } from '../../lib/ds'
+label={RESULT_TYPE_META[result.resultType]?.label}
+bgcolor={RESULT_TYPE_META[result.resultType]?.color}
+```
+
+### 8.4 Thresholds (`src/lib/constants.ts`)
+
+```ts
+SCORE_STRONG = 80    // match score considered "strong"
+SCORE_MODERATE = 60  // match score considered "moderate"
+CONF_HIGH = 0.85     // confidence considered "high"
+CONF_MEDIUM = 0.65   // confidence considered "medium"
+DQ_HIGH = 0.8        // data quality considered "high"
+DQ_MEDIUM = 0.6      // data quality considered "medium"
+```
+
+These thresholds are used by `scoreToConfidenceLevel()`, `scoreToDataQualityLevel()`, and all badge logic. Never re-define them locally.
+
+---
+
+## 9. AI Integration Rules
+
+Property Match integrates AI as a **service**, not as a feature bolted onto the UI.
+
+### 9.1 Model-Agnostic Interface
+
+AI is accessed exclusively through `IAIService` (`src/services/ai/IAIService.ts`). The interface defines capabilities (parseNeed, compareProperties, generateDecisionBrief, etc.). No component imports an LLM client directly.
+
+```ts
+// ❌ Never in a component or hook
+import OpenAI from 'openai'
+const client = new OpenAI(...)
+
+// ✅ Always via service
+import { aiService } from '../services/aiService'
+const result = await aiService.parseNeed(text)
+```
+
+### 9.2 Implementations
+
+| Implementation | File | Used when |
+|---|---|---|
+| `MockAIService` | `src/services/ai/MockAIService.ts` | Dev / CI — deterministic, no API calls |
+| `OpenRouterAIService` | `src/services/ai/OpenRouterAIService.ts` | Production — OpenRouter API |
+
+Swap implementations by changing the export in `src/services/aiService.ts`. No other file changes required.
+
+### 9.3 Structured Responses
+
+AI calls must return typed, structured objects — never raw strings passed into JSX.
+
+```ts
+// ❌ Raw LLM output in JSX
+<Typography>{llmResponse}</Typography>
+
+// ✅ Parsed, validated, typed output
+const result: ParsedNeed = await aiService.parseNeed(text)
+<NeedCardPreview need={result.need} confidence={result.confidence} />
+```
+
+All AI response schemas are validated with Zod before use.
+
+### 9.4 Explainable Outputs
+
+Every AI output that influences a user decision must be accompanied by an explanation.
+
+- Match scores include `ScoreFactor[]` (positive & negative)
+- Trade-off analysis includes `TradeOff[]` with severity
+- Future availability signals include `probabilityScore` + `signalBasis`
+- AI-parsed needs include `confidence` + which fields were inferred vs. stated
+
+### 9.5 Human-in-the-Loop
+
+AI suggestions are always proposals — the user confirms or overrides.
+
+- Need parsing: user reviews extracted criteria before search runs
+- AI recommendations: presented with confidence, not as commands
+- Review queue (`/ops`): all AI-generated content can be reviewed and corrected
+- Governance: `aiMonitoringService` logs every AI output with model version, prompt hash, and response
+
+### 9.6 Fallback Handling
+
+Every AI call has a defined fallback. If the AI service fails or returns a low-confidence result:
+- The UI shows a manual entry path
+- Confidence badges reflect uncertainty
+- No AI failure should block a user workflow
+
+---
+
+## 10. Performance Rules
+
+### 10.1 No Expensive Calculations in Render
+
+Any computation over a list, aggregation, or filter runs in `useMemo`, not in the render body.
+
+```tsx
+// ❌ Runs on every render — expensive if list is large
+return (
+  <div>
+    {properties
+      .filter(p => p.confidenceScore >= 0.7)
+      .sort((a, b) => b.areaSqm - a.areaSqm)
+      .map(p => <PropertyCard key={p.id} property={p} />)}
+  </div>
+)
+
+// ✅ Runs only when dependencies change
+const visible = useMemo(
+  () => properties.filter(p => p.confidenceScore >= 0.7).sort((a, b) => b.areaSqm - a.areaSqm),
+  [properties]
+)
+return <div>{visible.map(p => <PropertyCard key={p.id} property={p} />)}</div>
+```
+
+### 10.2 Memoize List Items
+
+Components rendered in lists (feeds, tables, grids) must be wrapped in `React.memo` to prevent cascade re-renders when parent state changes (e.g., a filter toggle or `selectedId` update).
+
+```ts
+// ✅ List item — always memo
+export const PropertyCard = memo(function PropertyCard({ property, onSelect }: Props) { ... })
+export const ReminderListRow = memo(function ReminderListRow({ reminder }: Props) { ... })
+```
+
+### 10.3 Stable Callbacks for Memoized Children
+
+When passing callbacks as props to memoized children, wrap them in `useCallback`. An unstable function reference breaks `React.memo`.
+
+```ts
+// ✅ Stable reference — memo children won't re-render
+const handleSelect = useCallback((id: string) => setSelectedId(id), [])
+```
+
+### 10.4 Single-Pass Aggregations
+
+When computing multiple aggregates over the same list (e.g., count of matchReady + criticalGaps + lowConfidence), use a single `for` loop in one `useMemo` — not three separate `.filter()` calls.
+
+### 10.5 Virtualization
+
+The current page size (`DEFAULT_PAGE_SIZE = 25`) makes React virtualization unnecessary today. If paginated lists are removed or page size exceeds ~200 items, evaluate `@tanstack/virtual` for the result feed and property table.
+
+### 10.6 Bundle Splitting
+
+All routes are already lazy-loaded via `React.lazy()` in `App.tsx`. Keep it that way — do not import page components directly.
+
+---
+
+## 11. Security & Governance
+
+### 11.1 Auth & Session
+
+- Auth state lives in `sessionStore` (Zustand)
+- On logout, **clear the React Query cache**: `queryClient.clear()`
+- Role checks use `src/lib/permissions.ts` — never inline `role === 'PROPERTY_MANAGER'`
+- Workspace access is enforced by `<ProtectedRoute workspace={...} />` — never guard with `if` inside a component
+
+### 11.2 Role-Based Rendering
+
+```ts
+// ❌ Magic string role check
+if (user.role === 'PROPERTY_MANAGER') { ... }
+
+// ✅ Permission helper
+import { canViewMatchCenter } from '../../lib/permissions'
+if (canViewMatchCenter(user)) { ... }
+```
+
+### 11.3 No Sensitive Data in Client State
+
+- Do not store tokens, passwords, or PII in Zustand stores beyond what is strictly needed for session identity
+- Do not log sensitive fields in console statements
+- Do not pass sensitive data as URL params (use navigation state instead)
+
+### 11.4 AI Audit Logging
+
+Every AI output that influences a business decision is logged via `aiMonitoringService`. Logs include:
+- Timestamp
+- Model ID and version
+- Prompt hash (not the full prompt — for privacy)
+- Response summary
+- User ID and workspace
+
+### 11.5 Data Lineage
+
+Every property record carries `DataSource` metadata (origin, freshness, last verified). Surface this data proactively — especially when `freshness === 'STALE'` or `freshness === 'OUTDATED'`.
+
+---
+
+## 12. Adding a New Feature — Checklist
+
+Before writing any code, answer these questions:
+
+1. **Which workspace does this belong to?** (SUPPLY / DEMAND / OPS)
+2. **What decision does this help the user make?** (If you can't answer this, reconsider the feature)
+3. **Does a provider already exist for this entity?** If not, create `I[Entity]Provider` + `Mockup[Entity]Provider` first
+4. **Does a service already exist?** If not, create `[entity]Service` that wraps the provider
+5. **Does a hook already exist?** If not, create `use[Entity]` in `src/hooks/`
+6. **Is this server state or UI state?** (see STATE_MANAGEMENT.md)
+7. **Does this show a score or confidence value?** Use `DS_COLORS` + helper functions from `lib/utils.ts`
+8. **Does this involve AI?** Go through `IAIService` — never call LLM APIs directly
+9. **Does this need explainability?** Add score factors, provenance, or reasoning before calling it done
+
+**Do not** add business logic to components. **Do not** duplicate types from `/domain/`. **Do not** hardcode colors, labels, or thresholds.
+
+---
+
+## 13. File Naming & Organization
+
+| Location | What goes there |
+|---|---|
+| `src/pages/[workspace]/` | Route-level page components |
+| `src/components/[feature]/` | Feature-specific components |
+| `src/components/shared/` | Components used across features |
+| `src/components/ui/` | Atomic UI: ErrorBoundary, EmptyState, Toast, DecisionContextPanel |
+| `src/components/layout/` | AppShell, PageHeader, RightContextPanel |
+| `src/hooks/` | React Query hooks |
+| `src/services/` | Business logic services |
+| `src/services/ai/` | AI service interface + implementations + prompts |
+| `src/provider/` | Data access interfaces + mock implementations |
+| `src/domain/` | TypeScript types and enums |
+| `src/features/matching/` | Scoring and ranking algorithms |
+| `src/stores/` | Zustand stores |
+| `src/lib/` | Shared utilities, theme, constants, design system |
+| `src/mock-data/` | Seed data for mock providers |
+
+Each component folder has an `index.ts` barrel export. New components must be added to the barrel before use.
+
+**File extension rule:** Any file that contains JSX must use `.tsx`. Plain TypeScript (no JSX) uses `.ts`. Violating this causes Vite parse errors.
+
+---
+
+## 14. TypeScript Rules
+
+- `strict: true` is enforced — do not disable strict mode or individual checks
+- Prefer `interface` for object shapes (can be extended); use `type` for unions and aliases
+- Props interfaces are named `Props` (local) or `[ComponentName]Props` (exported)
+- Never use `@ts-ignore` — fix the type instead
+- `as unknown as T` is acceptable only when bridging genuinely untyped third-party code; wrap it in a named adapter function
+- Enums from `src/domain/enums.ts` are the source of truth — never redefine values locally

CODE_REVIEW_CHECKLIST.md

@@ -0,0 +1,226 @@
+# Code Review Checklist — Property Match
+
+> Use this checklist before every PR review and before considering any implementation "done".
+> For architecture context see [ARCHITECTURE.md](./ARCHITECTURE.md).
+> For coding rules see [CLAUDE.md](./CLAUDE.md).
+
+---
+
+## A. Component Size & Structure
+
+- [ ] **Is the component too large?**
+  - Page component: hard limit 300 lines, target 150–200
+  - Feature component: hard limit 250 lines, target 100–150
+  - Atom/shared component: hard limit 150 lines
+  - If over limit: extract sub-components, move constants to `*Constants.ts`, move helpers to `*Utils.ts` (`.tsx` if JSX)
+
+- [ ] **Is business logic inside JSX?**
+  - `.filter()`, `.sort()`, `.reduce()`, conditional rendering based on computed values — these belong in `useMemo`, not inline in the return
+  - The render body should read computed values, not compute them
+
+- [ ] **Are hardcoded strings present?**
+  - Status labels (`'ACTIVE'`, `'Aktiv'`, `'PROPERTY_MANAGER'`) must come from `enums.ts` or `constants.ts`
+  - Route paths must come from `ROUTES` constants, not string literals
+  - German UI labels for enums live in `constants.ts` (e.g., `ASSET_TYPE_LABELS`)
+
+- [ ] **Are hardcoded colors or thresholds present?**
+  - Colors like `'#1a7a4a'`, `'#dc2626'` directly in `sx` props → use `DS_COLORS` from `lib/ds.ts`
+  - Score thresholds like `score >= 80` → use `SCORE_STRONG` from `constants.ts`
+  - Confidence thresholds like `conf >= 0.75` → use `CONF_HIGH` from `constants.ts`
+
+- [ ] **Are duplicate result type labels/colors defined locally?**
+  - `RESULT_TYPE_META` in `lib/ds.ts` is the single source of truth
+  - `RESULT_TYPE_LABEL` / `RESULT_TYPE_COLOR` inline objects anywhere else → delete them
+
+---
+
+## B. State & Data
+
+- [ ] **Is server data stored in Zustand?**
+  - Any `useEffect(() => setFoo(data), [data])` pattern that mirrors React Query data into local/Zustand state → remove it, read directly from the query
+  - Server data lives exclusively in the React Query cache
+
+- [ ] **Is derived state stored in state?**
+  - `const [count, setCount] = useState(0)` + `useEffect` to keep it in sync → compute inline or use `useMemo`
+  - Exception: expensive computations may use `useMemo`
+
+- [ ] **Is the full Zustand store subscribed to without a selector?**
+  - `const { a, b, c } = useMyStore()` — re-renders on every store mutation
+  - Use `useMyStore(s => s.a)` for single fields, `useShallow` for multiple fields
+
+- [ ] **Is there a side effect in the render body?**
+  - `queryClient.invalidateQueries(...)` called during render → must be in `useEffect`
+  - Any `console.log`, analytics call, or mutation triggered directly in render body → `useEffect`
+
+- [ ] **Are all hooks called before conditional early returns?**
+  - React rules of hooks: all `useState`, `useMemo`, `useCallback`, `useQuery` calls must appear before any `if (isLoading) return ...`
+
+---
+
+## C. Type Safety
+
+- [ ] **Are there `any` casts?**
+  - `as any`, `: any`, `// @ts-ignore` — fix the type or use `unknown` with a type guard
+  - One exception: bridging untyped third-party code — must be isolated in a named adapter
+
+- [ ] **Are domain types re-defined locally?**
+  - Any interface or type that duplicates something in `src/domain/` → import from domain instead
+
+- [ ] **Are response types used?**
+  - Service functions should return `ListResponse<T>` or `ItemResponse<T>` from `services/types.ts`
+
+- [ ] **Do `.tsx` files contain JSX and `.ts` files not?**
+  - Any file with JSX (`<Component />`, `<Box>`, `<Typography>`) must have `.tsx` extension
+  - Plain TypeScript utilities use `.ts`
+
+---
+
+## D. Layering & Architecture
+
+- [ ] **Is business logic in a component?**
+  - Scoring calculations, ranking, filtering rules, AI calls, data transformation → move to service or `features/` layer
+  - Components only render and dispatch
+
+- [ ] **Is a provider called directly from a component or hook?**
+  - `MockupPropertyProvider.getAll()` called in a hook → must go through `propertyService`
+  - All provider access is mediated by a service
+
+- [ ] **Is an LLM API called directly?**
+  - Any `fetch` to an AI API, or direct `OpenAI` / `openrouter` SDK calls outside `src/services/ai/` → move behind `IAIService`
+
+- [ ] **Are there cross-workspace component imports?**
+  - A supply component importing from `components/demand/` or vice versa → use `components/shared/` or `components/ui/` instead
+
+- [ ] **Are the import direction rules respected?**
+  - `services/` must not import React hooks
+  - `domain/` must not import anything from `src/`
+  - `lib/constants.ts` must not import from components or services
+  - No circular imports
+
+---
+
+## E. Loading, Error & Empty States
+
+- [ ] **Does every data-dependent view handle loading?**
+  - Every `useQuery` that drives a list or table must show a skeleton or spinner while `isLoading`
+  - Use the appropriate skeleton component (`FeedSkeleton`, `ReminderSkeleton`, etc.)
+
+- [ ] **Does every data-dependent view handle error?**
+  - `isError` from `useQuery` must show `<ErrorState message={error.message} />`
+  - Never leave an error state blank or silently swallowed
+
+- [ ] **Does every list handle the empty state?**
+  - Empty results after filtering → `<FeedEmptyState filtered={true} />` with a reset action
+  - Empty because no data exists → `<FeedEmptyState filtered={false} />`
+
+---
+
+## F. Performance
+
+- [ ] **Are list items wrapped in `React.memo`?**
+  - Components rendered inside `.map()` in feeds, tables, or grids → should be `memo()`
+  - Without memo, every parent state change (e.g., filter toggle, `selectedId`) re-renders the entire list
+
+- [ ] **Are callbacks to memoized children wrapped in `useCallback`?**
+  - Passing `() => setSelectedId(id)` inline as a prop to a `memo()`-wrapped child → the memo is broken
+  - Wrap with `useCallback` and explicit dependency array
+
+- [ ] **Are multiple aggregations over the same list collapsed into one pass?**
+  - Three separate `useMemo` calls that each `.filter()` the same array → collapse into one `useMemo` with a `for` loop
+
+- [ ] **Is `useMemo` used for expensive filters and sorts?**
+  - `.filter()` + `.sort()` over 25+ items in the render body → `useMemo`
+  - Decision aggregates (matchReady count, criticalGaps count, etc.) in `Properties.tsx` → already in `useMemo`
+
+- [ ] **Are routes lazy-loaded?**
+  - All page imports in `App.tsx` must use `React.lazy()` — never static imports for route components
+
+---
+
+## G. Explainability & Trust
+
+- [ ] **Does every score shown have a breakdown path?**
+  - A match score badge with no way to see *why* it's that score → add `ScoreBreakdownPanel` or link to MatchDetail
+
+- [ ] **Are confidence levels shown proactively?**
+  - Data with `confidenceScore < CONF_MEDIUM` or `freshness === 'STALE'` → must be visually flagged
+  - `ConfidenceBadge`, `FreshnessIndicator`, `DataQualityBar` exist for this purpose
+
+- [ ] **Are Future Availability signals clearly labeled as probabilistic?**
+  - `FUTURE_AVAILABILITY` results must always show `probabilityScore` and `signalBasis`
+  - They must never look identical to confirmed availability listings
+
+- [ ] **Does AI output show its confidence?**
+  - AI-extracted need criteria → shown with confidence indicator
+  - AI match suggestions → shown with `MAISON_WORK` badge and probability
+
+---
+
+## H. Security
+
+- [ ] **Is the React Query cache cleared on logout?**
+  - Logout flow must call `queryClient.clear()` — otherwise stale data from previous user persists
+
+- [ ] **Are role checks using `permissions.ts` helpers?**
+  - `user.role === 'PROPERTY_MANAGER'` inline → use `canViewMatchCenter(user)` from `lib/permissions.ts`
+
+- [ ] **Are workspace route guards in place?**
+  - Every supply/demand/ops route wrapped in `<ProtectedRoute workspace={...} />`
+  - Never guard with `if (user.workspace !== ...)` inside a component body
+
+- [ ] **Is sensitive data stored in Zustand?**
+  - PII, tokens, and sensitive fields beyond current-user identity should not persist in client state
+
+---
+
+## I. Backend-Readiness
+
+- [ ] **Is the provider interface complete?**
+  - Any new entity that creates a mock shortcut (array mutation inline, no interface) → add `I[Entity]Provider` and `Mockup[Entity]Provider`
+
+- [ ] **Are async patterns consistent?**
+  - All provider methods are `async` — if a new provider method is synchronous, fix it before it gets called from a service
+
+- [ ] **Are query keys stable and specific?**
+  - Query key `['properties']` is fine for list; `['properties', id]` for single item
+  - Keys that include derived or computed objects (not primitives) will break cache lookup
+
+- [ ] **Are stale times centralized?**
+  - No `staleTime: 60_000` or `staleTime: 5 * 60 * 1000` inline in hook files
+  - Use `STALE_PROPERTIES`, `STALE_MATCHES`, etc. from `src/lib/constants.ts`
+
+---
+
+## J. AI & Model Governance
+
+- [ ] **Is the AI call going through `IAIService`?**
+  - Direct fetch to AI API anywhere outside `src/services/ai/` → move it
+
+- [ ] **Is the AI response validated with Zod before use?**
+  - Raw LLM string parsed inline with `JSON.parse()` without a schema → add Zod validation
+
+- [ ] **Is the AI output logged via `aiMonitoringService`?**
+  - Any AI call that influences a business decision (need parsing, match recommendation, market signal) → log it
+
+- [ ] **Does the AI flow have a fallback?**
+  - If `aiService` throws or returns `confidence < threshold`, is there a manual entry path?
+  - AI failures must never block the user workflow
+
+---
+
+## Quick Checklist — Pre-Commit
+
+Before every commit, verify:
+
+```
+[ ] npx tsc --noEmit  →  zero errors
+[ ] No new hardcoded colors, routes, or role strings
+[ ] No business logic added to a JSX return block
+[ ] No React Query data mirrored into Zustand or useState
+[ ] All hooks called before early returns
+[ ] New list-item components wrapped in React.memo
+[ ] New provider methods are async and match the interface
+[ ] New feature goes through Provider → Service → Hook → Component
+[ ] Loading, error, and empty states handled for any new data-fetching view
+[ ] File with JSX has .tsx extension
+```

STATE_MANAGEMENT.md

@@ -0,0 +1,223 @@
+# State Management — Property Match
+
+## Decision Tree
+
+```
+Is it server data (fetched from an API or provider)?
+  → React Query (useQuery / useMutation)
+
+Is it global UI state shared across unrelated components?
+  → Zustand store
+
+Is it local to a single component or parent-child chain?
+  → useState / useReducer (local state)
+
+Can it be computed from existing state/data?
+  → Derived state (compute inline — no separate store field)
+
+Is it cross-cutting auth / session context accessed in non-React code?
+  → Zustand store read via getState() (not useStore hook)
+```
+
+---
+
+## React Query — Server State
+
+**Rule:** React Query owns all data that comes from a provider (mock or real).
+Never copy React Query data into a Zustand store.
+
+### When to use
+
+- Fetching lists or detail records (`useQuery`)
+- Creating, updating, deleting records (`useMutation`)
+- Anything that needs cache invalidation or background refetch
+
+### Patterns
+
+```ts
+// ✅ Correct — server data in React Query
+const { data: properties } = useProperties()
+
+// ✅ Correct — mutation with cache invalidation
+const createProp = useCreateProperty()
+createProp.mutate(input, {
+  onSuccess: () => queryClient.invalidateQueries({ queryKey: ['properties'] })
+})
+
+// ❌ Wrong — copying server data into a Zustand store
+const [properties, setProperties] = useState([])
+useEffect(() => { fetchProperties().then(setProperties) }, [])
+```
+
+### staleTime constants
+
+All stale times live in `src/lib/constants.ts` — never define them locally in hooks.
+
+| Constant | Value | Used for |
+|----------|-------|---------|
+| `STALE_PROPERTIES` | 5 min | Property lists and details |
+| `STALE_MATCHES` | 2 min | Match results (change with need edits) |
+| `STALE_SIGNALS` | 5 min | Future availability signals |
+| `STALE_MARKET_SIGNALS` | 30 s | Market intelligence (ops team, real-time) |
+| `STALE_REVIEW_QUEUE` | 30 s | Review queue tasks (ops team, real-time) |
+
+### Query key conventions
+
+```ts
+['entity']              // list: ['properties'], ['matches'], ['reminders']
+['entity', id]          // single: ['property', id], ['match', id]
+['entity', 'scope', id] // scoped: ['matches', 'need', needId]
+['entity', filters]     // filtered: ['properties', { assetType: 'OFFICE' }]
+```
+
+---
+
+## Zustand — UI / Interaction State
+
+**Rule:** Zustand owns UI state only. It must never hold data that belongs in React Query.
+
+### When to use
+
+- Multi-step wizard state (`offerWizardStore`)
+- Dialog open/close + pending item (`shortlistStore`, `pipelineStore`)
+- Sidebar / layout flags (`layoutStore`)
+- Auth session (`sessionStore` — special case, also read by services via `getState()`)
+- Toast queue (`toastStore`)
+- Active selection in a panel (`matchCenterStore`, `reminderStore`)
+
+### When NOT to use
+
+- Data fetched from a provider → use React Query
+- State used only inside one component → use `useState`
+- Values derived from existing state → compute inline
+
+### Selector rules
+
+Always use a selector. Subscribing to the full store causes re-renders on every state mutation.
+
+```ts
+// ✅ Individual field selector — re-renders only when that field changes
+const isOpen = useLayoutStore(s => s.isRightPanelOpen)
+const close = useLayoutStore(s => s.closeRightPanel)
+
+// ✅ useShallow for multiple fields from the same store
+import { useShallow } from 'zustand/react/shallow'
+const { filterType, filterStatus } = useReminderStore(
+  useShallow(s => ({ filterType: s.filterType, filterStatus: s.filterStatus }))
+)
+
+// ❌ No selector — subscribes to all store fields, re-renders on any change
+const { isOpen, close } = useLayoutStore()
+
+// ✅ Non-React code (services, mutations) reads store via getState — no subscription
+const user = useSessionStore.getState().currentUser
+```
+
+### Store inventory
+
+| Store | Responsibility | Key state |
+|-------|---------------|-----------|
+| `layoutStore` | App shell layout | `activeWorkspace`, `sidebarCollapsed`, `isRightPanelOpen` |
+| `sessionStore` | Auth / current user | `currentUser`, `isAuthenticated`, `sessionStatus` |
+| `assistantStore` | AI drawer conversation | `isOpen`, `messages`, `context`, `isLoading` |
+| `compareStore` | Compare tray items | `compareItems[]` |
+| `pipelineStore` | Pipeline items + add-dialog | `items[]`, `dialogOpen`, `pendingItem` |
+| `shortlistStore` | Shortlist selection + add-dialog | `selectedShortlistId`, `dialogOpen`, `pendingItem` |
+| `offerWizardStore` | Multi-step offer wizard | `isOpen`, `currentStep`, `selectedPropertyIds`, `editableFields` |
+| `matchCenterStore` | Supply-side match center selection | `selectedPropertyId`, `selectedNeedId` |
+| `reminderStore` | Reminder list filters + drawer | `filterType`, `filterStatus`, `selectedId`, `drawerOpen` |
+| `toastStore` | Toast notification queue | `toasts[]` |
+
+### Adding a new store field
+
+Ask these questions first:
+1. Is this server data? → React Query instead.
+2. Is this only used in one component? → `useState` instead.
+3. Is this derived from existing state? → compute it, don't store it.
+
+---
+
+## Local State — Component-Scoped
+
+**Rule:** Default to `useState`. Only escalate to Zustand when state genuinely needs to be shared across unrelated components.
+
+### When to use
+
+- Form input values
+- Toggle / accordion open state
+- Hover / focus effects
+- Step progress inside a self-contained wizard step
+- Any state that resets when the component unmounts
+
+```ts
+// ✅ Local — form input, no other component needs this
+const [name, setName] = useState('')
+
+// ✅ Local — dialog only opened from one place
+const [open, setOpen] = useState(false)
+
+// ❌ Should be local — extracted to store unnecessarily
+// (e.g. a "confirmDialogOpen" only ever toggled from one parent)
+```
+
+---
+
+## Derived State — Compute, Don't Store
+
+**Rule:** Never store a value that can be computed from existing state or query data. Compute it at render time.
+
+```ts
+// ✅ Derived — compute from store
+const isFull = compareItems.length >= MAX_COMPARE_ITEMS  // NOT stored
+
+// ✅ Derived — compute from React Query data
+const overdueReminders = reminders.filter(r => isPastDue(r.dueDate))  // NOT stored
+
+// ❌ Stored derived state — causes sync bugs
+const [overdueCount, setOverdueCount] = useState(0)
+useEffect(() => setOverdueCount(reminders.filter(...).length), [reminders])
+```
+
+Exception: expensive computations (e.g. score calculation over thousands of items) may use `useMemo`.
+
+---
+
+## Context — When Neither React Query nor Zustand Fits
+
+Use React Context for:
+- Dependency injection (swap provider implementations)
+- Tree-scoped state (e.g. a form context for nested inputs)
+- Auth abstraction (`AuthProvider` wraps `sessionStore` so components don't import the store directly)
+
+Do NOT use Context as a replacement for React Query or Zustand — it causes cascading re-renders without cache or subscription granularity.
+
+---
+
+## Service / Non-React Code
+
+Services must not import React hooks. They access Zustand state via `getState()`:
+
+```ts
+// ✅ In a service — no hook, no subscription
+const user = useSessionStore.getState().currentUser
+
+// ✅ In a React Query mutation onError
+onError: () => useToastStore.getState().showToast('Fehler aufgetreten', 'error')
+
+// ❌ Services must never call useStore hooks
+import { useSessionStore } from '../stores/sessionStore'
+const { currentUser } = useSessionStore()  // only valid inside a React component
+```
+
+---
+
+## Anti-Patterns to Avoid
+
+| Anti-pattern | Why bad | Fix |
+|---|---|---|
+| `useStore()` without selector | Re-renders on every store mutation | Use `s => s.field` selector or `useShallow` |
+| Server data in Zustand | Duplicates cache, causes stale/sync bugs | React Query |
+| Derived state stored in state | Sync bugs, extra renders | Compute inline |
+| Local dialog state in global store | Bloats store, breaks encapsulation | `useState` |
+| Cross-store imports | Tight coupling, circular risk | Keep stores independent |
+| Hook-local `STALE_*` constants | Inconsistent cache behaviour | Use `src/lib/constants.ts` |

eslint.config.js

@@ -19,4 +19,29 @@ export default defineConfig([
       globals: globals.browser,
     },
   },
+  // ── Design Token Enforcement ────────────────────────────────────────────────
+  // New hardcoded hex colors in components/pages are blocked (error).
+  // Existing violations are tracked by: npm run check:tokens
+  //
+  // Use instead:
+  //   DS_TEXT.secondary, DS_SURFACE.success.bg   (src/lib/ds.ts)
+  //   matchScoreHex(score), criterionScoreTextColor(score)  (src/lib/utils.ts)
+  //   RESULT_TYPE_META[type].color               (src/lib/ds.ts)
+  //   MUI theme tokens: "primary.main", "text.secondary"
+  {
+    files: ['src/components/**/*.{ts,tsx}', 'src/pages/**/*.{ts,tsx}'],
+    rules: {
+      'no-restricted-syntax': [
+        'warn',
+        {
+          selector: [
+            'Property[key.name=/^(bgcolor|color|borderColor|background|fill|stroke)$/]',
+            ' > Literal[value=/^#[0-9A-Fa-f]{3,8}$/]',
+          ].join(''),
+          message:
+            'No hardcoded hex colors in sx/style props. Use DS_TEXT, DS_SURFACE, DS_BORDER, DS_BG, BADGE_COLORS from src/lib/ds.ts, or helper functions from src/lib/utils.ts.',
+        },
+      ],
+    },
+  },
 ])

package.json

@@ -7,7 +7,11 @@
     "dev": "vite",
     "build": "tsc -b && vite build",
     "lint": "eslint .",
-    "preview": "vite preview"
+    "preview": "vite preview",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "check:tokens": "node scripts/check-tokens.js"
   },
   "dependencies": {
     "@dnd-kit/core": "^6.3.1",
@@ -30,18 +34,23 @@
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@tailwindcss/vite": "^4.3.0",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.2",
     "@types/leaflet": "^1.9.21",
     "@types/node": "^24.12.3",
     "@types/react": "^19.2.14",
     "@types/react-dom": "^19.2.3",
     "@vitejs/plugin-react": "^6.0.1",
+    "@vitest/coverage-v8": "^4.1.7",
     "eslint": "^10.3.0",
     "eslint-plugin-react-hooks": "^7.1.1",
     "eslint-plugin-react-refresh": "^0.5.2",
     "globals": "^17.6.0",
+    "jsdom": "^29.1.1",
     "tailwindcss": "^4.3.0",
     "typescript": "~6.0.2",
     "typescript-eslint": "^8.59.2",
-    "vite": "^8.0.12"
+    "vite": "^8.0.12",
+    "vitest": "^4.1.7"
   }
 }

scripts/check-tokens.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+/**
+ * check-tokens.js
+ *
+ * Counts hardcoded hex color literals in sx props / color attributes
+ * across src/components and src/pages. Fails (exit 1) if count exceeds THRESHOLD.
+ *
+ * Usage:
+ *   node scripts/check-tokens.js           — report + fail if > threshold
+ *   node scripts/check-tokens.js --report  — report only, always exits 0
+ *
+ * Run via:  npm run check:tokens
+ */
+
+import { readdirSync, readFileSync, statSync } from 'node:fs'
+import { join, extname } from 'node:path'
+
+// Hex literals allowed before CI blocks the build.
+// This is a ratchet — lower it as migration progresses. Never raise it.
+// Baseline after initial token migration (2026-05-24): 1958
+const THRESHOLD = 1958
+
+const HEX_PATTERN = /#[0-9A-Fa-f]{3,8}\b/g
+
+const SEARCH_DIRS = ['src/components', 'src/pages']
+
+function walk(dir) {
+  const files = []
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const full = join(dir, entry.name)
+    if (entry.isDirectory()) files.push(...walk(full))
+    else if (entry.isFile() && ['.ts', '.tsx'].includes(extname(entry.name))) files.push(full)
+  }
+  return files
+}
+
+const reportOnly = process.argv.includes('--report')
+const cwd = process.cwd()
+
+let totalViolations = 0
+const fileViolations = []
+
+for (const searchDir of SEARCH_DIRS) {
+  const dir = join(cwd, searchDir)
+  for (const file of walk(dir)) {
+    const content = readFileSync(file, 'utf8')
+    const matches = content.match(HEX_PATTERN)
+    if (matches && matches.length > 0) {
+      totalViolations += matches.length
+      fileViolations.push({ file: file.replace(cwd + '\\', '').replace(cwd + '/', ''), count: matches.length })
+    }
+  }
+}
+
+fileViolations.sort((a, b) => b.count - a.count)
+
+console.log('\n── Token Compliance Check ───────────────────────────────────────────')
+console.log(`Total hex violations: ${totalViolations}  (threshold: ${THRESHOLD})`)
+console.log(`Status: ${totalViolations <= THRESHOLD ? '✅ PASS' : '❌ FAIL'}`)
+console.log('\nTop 15 offenders:')
+fileViolations.slice(0, 15).forEach(({ file, count }) => {
+  console.log(`  ${count.toString().padStart(3)}  ${file}`)
+})
+console.log('─────────────────────────────────────────────────────────────────────\n')
+
+if (!reportOnly && totalViolations > THRESHOLD) {
+  console.error(`Error: ${totalViolations} hex violations exceed threshold of ${THRESHOLD}.`)
+  console.error('Run `node scripts/check-tokens.js --report` to see the full list.')
+  process.exit(1)
+}

src/App.tsx

@@ -12,7 +12,7 @@ const WORKSPACE_HOME: Record<string, string> = {
 }
 
 function RoleRedirect() {
-  const { currentUser } = useSessionStore()
+  const currentUser = useSessionStore(s => s.currentUser)
   const first = currentUser?.allowedWorkspaces[0] ?? WorkspaceType.SUPPLY
   return <Navigate to={WORKSPACE_HOME[first] ?? '/supply/dashboard'} replace />
 }
@@ -26,7 +26,7 @@ const Anfragencenter = lazy(() => import('./pages/supply/Anfragencenter'))
 const FutureAvailability = lazy(() => import('./pages/supply/FutureAvailability'))
 const DataQuality = lazy(() => import('./pages/supply/DataQuality'))
 const ReminderManager = lazy(() => import('./pages/supply/ReminderManager'))
-const MarketLeads = lazy(() => import('./pages/supply/MarketLeads'))
+const MarketIntelligence = lazy(() => import('./pages/supply/MarketIntelligence'))
 const NewListing = lazy(() => import('./pages/supply/NewListing'))
 const MyListings = lazy(() => import('./pages/supply/MyListings'))
 
@@ -38,7 +38,6 @@ const Anfragen = lazy(() => import('./pages/demand/Anfragen'))
 const Pipeline = lazy(() => import('./pages/demand/Pipeline'))
 const PropertyDetail = lazy(() => import('./pages/demand/PropertyDetail'))
 
-const MarketIntelligence = lazy(() => import('./pages/ops/MarketIntelligence'))
 
 function App() {
   return (
@@ -62,7 +61,6 @@ function App() {
                 <Route path="/supply/future-availability" element={<FutureAvailability />} />
                 <Route path="/supply/data-quality" element={<DataQuality />} />
                 <Route path="/supply/reminder-manager" element={<ReminderManager />} />
-                <Route path="/supply/market-leads" element={<MarketLeads />} />
                 <Route path="/supply/market-intelligence" element={<MarketIntelligence />} />
                 <Route path="/supply/new-listing" element={<NewListing />} />
                 <Route path="/supply/my-listings" element={<MyListings />} />

src/components/ai-monitoring/AIErrorBadge.tsx

@@ -1,4 +1,4 @@
-import { Chip, Tooltip } from '@mui/material'
+import { GenericBadge } from '../shared/GenericBadge'
 import type { AIOutputError } from '../../domain/aiOutput'
 
 const ERROR_CONFIG: Record<string, { label: string; color: string }> = {
@@ -11,13 +11,5 @@ const ERROR_CONFIG: Record<string, { label: string; color: string }> = {
 
 export function AIErrorBadge({ error }: { error: AIOutputError }) {
   const { label, color } = ERROR_CONFIG[error.type] ?? { label: error.type, color: '#c0392b' }
-  return (
-    <Tooltip title={error.message} arrow>
-      <Chip
-        size="small"
-        label={label}
-        sx={{ bgcolor: `${color}18`, color, fontWeight: 700, fontSize: '0.65rem', cursor: 'default' }}
-      />
-    </Tooltip>
-  )
+  return <GenericBadge label={label} color={color} bold tooltip={error.message} />
 }

src/components/ai-monitoring/AIOutputStatusBadge.tsx

@@ -1,21 +1,15 @@
-import { Chip } from '@mui/material'
+import { GenericBadge } from '../shared/GenericBadge'
 import type { ReviewStatus } from '../../domain/enums'
 
 const CONFIG: Record<ReviewStatus, { label: string; color: string }> = {
-  UNREVIEWED: { label: 'Ungeprüft', color: '#94a3b8' },
+  UNREVIEWED: { label: 'Ungeprüft',  color: '#94a3b8' },
   IN_REVIEW:  { label: 'In Prüfung', color: '#d97706' },
-  APPROVED:   { label: 'Genehmigt', color: '#1a7a4a' },
-  REJECTED:   { label: 'Abgelehnt', color: '#c0392b' },
-  FLAGGED:    { label: 'Markiert',  color: '#ea580c' },
+  APPROVED:   { label: 'Genehmigt',  color: '#1a7a4a' },
+  REJECTED:   { label: 'Abgelehnt',  color: '#c0392b' },
+  FLAGGED:    { label: 'Markiert',   color: '#ea580c' },
 }
 
 export function AIOutputStatusBadge({ status }: { status: ReviewStatus }) {
   const { label, color } = CONFIG[status] ?? { label: status, color: '#64748b' }
-  return (
-    <Chip
-      size="small"
-      label={label}
-      sx={{ bgcolor: `${color}18`, color, fontWeight: 600, fontSize: '0.7rem' }}
-    />
-  )
+  return <GenericBadge label={label} color={color} />
 }

src/components/ai-monitoring/AIOutputTable.tsx

@@ -23,7 +23,7 @@ const TYPE_LABELS: Record<AIOutputType, string> = {
 }
 
 const TYPE_COLORS: Record<AIOutputType, string> = {
-  NEED_PARSE:           '#1e3a5f',
+  NEED_PARSE:           '#152642',
   FOLLOW_UP_QUESTIONS:  '#0891b2',
   MATCH_EXPLANATION:    '#4f46e5',
   COMPARE_SUMMARY:      '#1a7a4a',

src/components/ai-monitoring/AIReviewActionToolbar.tsx

@@ -61,7 +61,7 @@ export function AIReviewActionToolbar({ output, onUpdateStatus, onCopyJson, isSu
           variant="outlined"
           onClick={onCopyJson}
           startIcon={<Copy size={13} />}
-          sx={{ textTransform: 'none', fontSize: '0.75rem', color: '#64748b', borderColor: '#e2e8f0', '&:hover': { bgcolor: '#f8fafc' } }}
+          sx={{ textTransform: 'none', fontSize: '0.75rem', color: '#64748b', borderColor: '#e8e7e4', '&:hover': { bgcolor: '#f8fafc' } }}
         >
           JSON
         </Button>

src/components/anfragencenter/ActiveInquiriesTab.tsx

@@ -93,18 +93,18 @@ export function ActiveInquiriesTab() {
             <Typography variant="body2" sx={{ fontWeight: 600, color: '#0f172a' }}>
               Anfragen
             </Typography>
-            <Box sx={{ px: 1, py: 0.125, borderRadius: 1, bgcolor: '#1e3a5f', color: 'white', fontWeight: 600, fontSize: '0.7rem' }}>
+            <Box sx={{ px: 1, py: 0.125, borderRadius: 1, bgcolor: '#152642', color: 'white', fontWeight: 600, fontSize: '0.7rem' }}>
               {inquiries.length}
             </Box>
           </Box>
           <Box sx={{ display: 'flex', gap: 0.5 }}>
             <Tooltip title="Listenansicht">
-              <IconButton size="small" onClick={() => setView('list')} sx={{ bgcolor: view === 'list' ? '#e0e7ff' : 'transparent', color: view === 'list' ? '#1e3a5f' : '#64748b' }}>
+              <IconButton size="small" onClick={() => setView('list')} sx={{ bgcolor: view === 'list' ? '#e0e7ff' : 'transparent', color: view === 'list' ? '#152642' : '#64748b' }}>
                 <ListIcon size={16} />
               </IconButton>
             </Tooltip>
             <Tooltip title="Kartenansicht">
-              <IconButton size="small" onClick={() => setView('grid')} sx={{ bgcolor: view === 'grid' ? '#e0e7ff' : 'transparent', color: view === 'grid' ? '#1e3a5f' : '#64748b' }}>
+              <IconButton size="small" onClick={() => setView('grid')} sx={{ bgcolor: view === 'grid' ? '#e0e7ff' : 'transparent', color: view === 'grid' ? '#152642' : '#64748b' }}>
                 <LayoutGrid size={16} />
               </IconButton>
             </Tooltip>

src/components/anfragencenter/AiOfferEmailButton.tsx

@@ -1,7 +1,6 @@
-import { useState } from 'react'
 import { Box, Button, CircularProgress, Typography } from '@mui/material'
 import { Sparkles } from 'lucide-react'
-import { aiService } from '../../services/aiService'
+import { useGenerateOfferEmail } from '../../hooks/useAI'
 
 interface AiOfferEmailButtonProps {
   needTitle: string
@@ -16,33 +15,26 @@ export function AiOfferEmailButton({
   matchScores,
   onGenerated,
 }: AiOfferEmailButtonProps) {
-  const [loading, setLoading] = useState(false)
-  const [error, setError] = useState<string | null>(null)
+  const generateOfferEmail = useGenerateOfferEmail()
 
-  const handleClick = async () => {
-    setLoading(true)
-    setError(null)
-    try {
-      const res = await aiService.generateOfferEmail({
-        needTitle,
-        properties: selectedProperties,
-        matchScores,
-      })
-      onGenerated(res.data.subject, res.data.body)
-    } catch (e) {
-      setError(e instanceof Error ? e.message : 'KI-Generierung fehlgeschlagen')
-    } finally {
-      setLoading(false)
-    }
+  const handleClick = () => {
+    generateOfferEmail.mutate(
+      { needTitle, properties: selectedProperties, matchScores },
+      {
+        onSuccess: (res) => {
+          onGenerated(res.data.subject, res.data.body)
+        },
+      },
+    )
   }
 
   return (
     <Box>
       <Button
         size="small"
-        startIcon={loading ? <CircularProgress size={14} /> : <Sparkles size={14} />}
+        startIcon={generateOfferEmail.isPending ? <CircularProgress size={14} /> : <Sparkles size={14} />}
         onClick={handleClick}
-        disabled={loading}
+        disabled={generateOfferEmail.isPending}
         sx={{
           textTransform: 'none',
           color: '#7c3aed',
@@ -53,9 +45,11 @@ export function AiOfferEmailButton({
       >
         KI-Mail generieren
       </Button>
-      {error && (
+      {generateOfferEmail.isError && (
         <Typography variant="caption" sx={{ color: 'error.main', display: 'block', mt: 0.5 }}>
-          {error}
+          {generateOfferEmail.error instanceof Error
+            ? generateOfferEmail.error.message
+            : 'KI-Generierung fehlgeschlagen'}
         </Typography>
       )}
     </Box>

src/components/anfragencenter/InquiryCard.tsx

@@ -20,12 +20,12 @@ export function InquiryCard({ inquiry, selected, onClick }: InquiryCardProps) {
         p: 2,
         borderRadius: 1.5,
         border: '1px solid',
-        borderColor: selected ? '#1e3a5f' : '#e2e8f0',
+        borderColor: selected ? '#152642' : '#e8e7e4',
         bgcolor: selected ? '#f1f5f9' : 'white',
         cursor: 'pointer',
         transition: 'all 0.15s',
         '&:hover': {
-          borderColor: selected ? '#1e3a5f' : '#94a3b8',
+          borderColor: selected ? '#152642' : '#94a3b8',
           boxShadow: '0 2px 6px rgba(15,23,42,0.06)',
         },
         display: 'flex',
@@ -96,19 +96,9 @@ export function InquiryCard({ inquiry, selected, onClick }: InquiryCardProps) {
           {formatInquiryDate(inquiry.createdAt)}
         </Typography>
         {inquiry.matchScore !== undefined && (
-          <Box
-            sx={{
-              px: 1,
-              py: 0.25,
-              borderRadius: 1,
-              bgcolor: '#e0e7ff',
-              color: '#3730a3',
-              fontWeight: 600,
-              fontSize: '0.7rem',
-            }}
-          >
-            Match {inquiry.matchScore}%
-          </Box>
+          <Typography sx={{ fontSize: '0.75rem', fontWeight: 700, color: '#152642' }}>
+            {inquiry.matchScore}%
+          </Typography>
         )}
       </Box>
     </Paper>

src/components/anfragencenter/InquiryChat.tsx

@@ -42,7 +42,7 @@ export function InquiryChat({
                     fontSize: '0.75rem',
                     borderColor: '#cbd5e1',
                     color: '#475569',
-                    '&:hover': { borderColor: '#1e3a5f', color: '#1e3a5f', bgcolor: '#f0f4f8' },
+                    '&:hover': { borderColor: '#152642', color: '#152642', bgcolor: '#f0f4f8' },
                   }}
                 >
                   Angebot erstellen
@@ -56,6 +56,7 @@ export function InquiryChat({
       <InquiryReplyComposer
         inquiryId={inquiry.id}
         defaultSubject={inquiry.subject}
+        tenantName={inquiry.tenantName}
         pendingAttachment={pendingAttachment}
         onPendingAttachmentConsumed={onPendingAttachmentConsumed}
       />

src/components/anfragencenter/InquiryDetailPanel.tsx

@@ -1,7 +1,9 @@
 import { useEffect, useState } from 'react'
 import { Box, Button, CircularProgress, Typography } from '@mui/material'
-import { ClipboardList } from 'lucide-react'
+import { ArrowRight, Building2, ClipboardList, MapPin, Ruler } from 'lucide-react'
+import { useNavigate } from 'react-router'
 import { useInquiryById, useMarkThreadAsRead } from '../../hooks/useInquiries'
+import { usePropertyById } from '../../hooks/useProperties'
 import { InquiryChat } from './InquiryChat'
 import { RelatedPropertyCardPanel } from './RelatedPropertyCardPanel'
 import type { Attachment } from '../../domain/inquiry'
@@ -12,7 +14,9 @@ interface InquiryDetailPanelProps {
 
 export function InquiryDetailPanel({ inquiryId }: InquiryDetailPanelProps) {
   const { data: inquiry, isLoading } = useInquiryById(inquiryId)
+  const { data: property } = usePropertyById(inquiry?.propertyId ?? '')
   const markRead = useMarkThreadAsRead()
+  const navigate = useNavigate()
   const [preparationOpen, setPreparationOpen] = useState(false)
   const [offerWizardOpen, setOfferWizardOpen] = useState(false)
   const [pendingAttachment, setPendingAttachment] = useState<Attachment | null>(null)
@@ -43,10 +47,13 @@ export function InquiryDetailPanel({ inquiryId }: InquiryDetailPanelProps) {
   }
 
   const isLatentInquiry = !!inquiry.needId
+  const propertyImage = property?.images?.[0]
 
   return (
     <>
       <Box sx={{ display: 'flex', flexDirection: 'column', height: '100%', overflow: 'hidden' }}>
+
+        {/* Header: tenant + subject + action */}
         <Box
           sx={{
             px: 2.5,
@@ -85,26 +92,92 @@ export function InquiryDetailPanel({ inquiryId }: InquiryDetailPanelProps) {
               variant="outlined"
               startIcon={<ClipboardList size={14} />}
               onClick={() => setPreparationOpen(true)}
-              sx={{ textTransform: 'none', whiteSpace: 'nowrap', borderColor: '#1e3a5f', color: '#1e3a5f', '&:hover': { bgcolor: '#f0f4f8' } }}
+              sx={{ textTransform: 'none', whiteSpace: 'nowrap', borderColor: '#152642', color: '#152642', '&:hover': { bgcolor: '#f0f4f8' } }}
             >
               Vorbereitung starten
             </Button>
           )}
         </Box>
 
-        <Box sx={{ flex: 1, display: 'flex', flexDirection: { xs: 'column', md: 'row' }, overflow: 'hidden' }}>
+        {/* Property context bar */}
+        <Box
+          sx={{
+            px: 2,
+            py: 1,
+            borderBottom: '1px solid #e2e8f0',
+            bgcolor: '#f8fafc',
+            display: 'flex',
+            alignItems: 'center',
+            gap: 1.5,
+            flexShrink: 0,
+          }}
+        >
+          <Box
+            sx={{
+              width: 44,
+              height: 44,
+              borderRadius: 1,
+              overflow: 'hidden',
+              flexShrink: 0,
+              bgcolor: '#e8e7e4',
+              display: 'flex',
+              alignItems: 'center',
+              justifyContent: 'center',
+            }}
+          >
+            {propertyImage ? (
+              <Box
+                component="img"
+                src={propertyImage}
+                alt={property?.title}
+                sx={{ width: '100%', height: '100%', objectFit: 'cover', display: 'block' }}
+              />
+            ) : (
+              <Building2 size={18} color="#94a3b8" />
+            )}
+          </Box>
+          <Box sx={{ flex: 1, minWidth: 0 }}>
+            <Typography
+              sx={{ fontWeight: 600, color: '#0f172a', fontSize: '0.85rem', overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap', lineHeight: 1.3 }}
+            >
+              {property?.title ?? '—'}
+            </Typography>
+            <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, color: '#64748b' }}>
+              <MapPin size={11} style={{ flexShrink: 0 }} />
+              <Typography variant="caption" sx={{ fontSize: '0.72rem', overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }}>
+                {property?.location.city}
+                {property?.areaSqm ? ` · ${property.areaSqm.toLocaleString('de-CH')} m²` : ''}
+                {property?.rentPricePerSqm ? ` · CHF ${property.rentPricePerSqm}/m²/J.` : ''}
+              </Typography>
+            </Box>
+          </Box>
+          <Button
+            size="small"
+            endIcon={<ArrowRight size={12} />}
+            onClick={() => navigate('/supply/properties')}
+            sx={{ textTransform: 'none', fontSize: '0.75rem', color: '#152642', whiteSpace: 'nowrap', flexShrink: 0 }}
+          >
+            Objekt ansehen
+          </Button>
+        </Box>
+
+        {/* Chat (flex: 1) */}
+        <Box sx={{ flex: 1, overflow: 'hidden' }}>
           <InquiryChat
             inquiry={inquiry}
             onCreateOffer={() => setOfferWizardOpen(true)}
             pendingAttachment={pendingAttachment}
             onPendingAttachmentConsumed={() => setPendingAttachment(null)}
           />
-          <Box sx={{ width: { xs: '100%', md: 300 }, flexShrink: 0, borderTop: { xs: '1px solid #e2e8f0', md: 'none' }, maxHeight: { xs: 280, md: 'none' }, overflowY: 'auto' }}>
-            <RelatedPropertyCardPanel
-              propertyId={inquiry.propertyId}
-              inquiryId={inquiry.id}
-            />
-          </Box>
+        </Box>
+
+        {/* Bottom: weitere passende Objekte */}
+        <Box sx={{ flexShrink: 0, borderTop: '1px solid #e2e8f0' }}>
+          <RelatedPropertyCardPanel
+            propertyId={inquiry.propertyId}
+            inquiryId={inquiry.id}
+            compact
+          />
         </Box>
       </Box>
 

src/components/anfragencenter/InquiryListRow.tsx

@@ -17,11 +17,10 @@ export function InquiryListRow({ inquiry, selected, onClick }: InquiryListRowPro
       onClick={onClick}
       sx={{
         px: 2,
-        py: 1.5,
+        py: 1,
         borderBottom: '1px solid #e2e8f0',
-        borderLeft: '3px solid',
-        borderLeftColor: selected ? '#1e3a5f' : hasUnread ? '#2563eb' : 'transparent',
-        bgcolor: selected ? '#f1f5f9' : 'white',
+        borderLeft: selected ? '4px solid #2563eb' : `3px solid ${hasUnread ? '#2563eb' : 'transparent'}`,
+        bgcolor: selected ? '#eff6ff' : 'white',
         cursor: 'pointer',
         transition: 'background-color 0.15s, border-color 0.15s',
         '&:hover': { bgcolor: selected ? '#f1f5f9' : '#f8fafc' },
@@ -30,7 +29,7 @@ export function InquiryListRow({ inquiry, selected, onClick }: InquiryListRowPro
       <Box sx={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', mb: 0.5 }}>
         <Typography
           variant="body2"
-          sx={{ fontWeight: hasUnread ? 700 : 600, color: '#0f172a', fontSize: '0.85rem' }}
+          sx={{ fontWeight: selected || hasUnread ? 700 : 600, color: selected ? '#1d4ed8' : '#0f172a', fontSize: '0.85rem' }}
         >
           {inquiry.tenantName}
           {inquiry.tenantCompany ? ` · ${inquiry.tenantCompany}` : ''}
@@ -76,20 +75,9 @@ export function InquiryListRow({ inquiry, selected, onClick }: InquiryListRowPro
           {propertyLabelFromId(inquiry.propertyId)}
         </Typography>
         {inquiry.matchScore !== undefined && (
-          <Box
-            sx={{
-              ml: 'auto',
-              px: 0.75,
-              py: 0.125,
-              borderRadius: 1,
-              bgcolor: '#e0e7ff',
-              color: '#3730a3',
-              fontWeight: 600,
-              fontSize: '0.7rem',
-            }}
-          >
+          <Typography sx={{ ml: 'auto', fontSize: '0.75rem', fontWeight: 700, color: '#152642' }}>
             {inquiry.matchScore}%
-          </Box>
+          </Typography>
         )}
       </Box>
       <Typography variant="caption" sx={{ color: '#94a3b8', fontSize: '0.7rem', mt: 0.5, display: 'block' }}>

src/components/anfragencenter/InquiryMessageBubble.tsx

@@ -38,7 +38,7 @@ export function InquiryMessageBubble({ message }: InquiryMessageBubbleProps) {
       <Box
         sx={{
           maxWidth: '75%',
-          bgcolor: isTenant ? '#f1f5f9' : '#1e3a5f',
+          bgcolor: isTenant ? '#f1f5f9' : '#152642',
           color: isTenant ? '#0f172a' : 'white',
           px: 1.75,
           py: 1.25,

src/components/anfragencenter/InquiryReplyComposer.tsx

@@ -7,7 +7,7 @@ import {
   TextField,
   Typography,
 } from '@mui/material'
-import { Send, Paperclip, X } from 'lucide-react'
+import { Paperclip, Send, Sparkles, X } from 'lucide-react'
 import { useSendInquiryReply } from '../../hooks/useInquiries'
 import { useToastStore } from '../../stores/toastStore'
 import type { Attachment } from '../../domain/inquiry'
@@ -16,6 +16,7 @@ import { formatFileSize } from './inquiryUtils'
 interface InquiryReplyComposerProps {
   inquiryId: string
   defaultSubject: string
+  tenantName?: string
   onSent?: () => void
   pendingAttachment?: Attachment | null
   onPendingAttachmentConsumed?: () => void
@@ -24,6 +25,7 @@ interface InquiryReplyComposerProps {
 export function InquiryReplyComposer({
   inquiryId,
   defaultSubject,
+  tenantName,
   onSent,
   pendingAttachment,
   onPendingAttachmentConsumed,
@@ -33,6 +35,7 @@ export function InquiryReplyComposer({
   )
   const [body, setBody] = useState('')
   const [attachments, setAttachments] = useState<Attachment[]>([])
+  const [isAIDraft, setIsAIDraft] = useState(false)
 
   const sendReply = useSendInquiryReply()
   const showToast = useToastStore(s => s.showToast)
@@ -49,6 +52,14 @@ export function InquiryReplyComposer({
 
   const sending = sendReply.isPending
 
+  function handleAIDraft() {
+    const salutation = tenantName ? `Sehr geehrte/r ${tenantName}` : 'Sehr geehrte Damen und Herren'
+    setBody(
+      `${salutation},\n\nVielen Dank für Ihre Anfrage. Gerne bestätigen wir, dass das Objekt zum gewünschten Zeitpunkt verfügbar ist.\n\nWir würden Ihnen gerne einen Besichtigungstermin vorschlagen — bitte teilen Sie uns Ihre Verfügbarkeit mit, damit wir einen passenden Termin finden können.\n\nFür Rückfragen stehen wir Ihnen jederzeit gerne zur Verfügung.\n\nMit freundlichen Grüssen`
+    )
+    setIsAIDraft(true)
+  }
+
   const handleAddMockAttachment = () => {
     const name = `Anhang_${attachments.length + 1}.pdf`
     setAttachments(prev => [
@@ -82,6 +93,7 @@ export function InquiryReplyComposer({
     showToast('Antwort gesendet', 'success')
     setBody('')
     setAttachments([])
+    setIsAIDraft(false)
     onSent?.()
   }
 
@@ -103,15 +115,26 @@ export function InquiryReplyComposer({
         onChange={e => setSubject(e.target.value)}
         fullWidth
       />
+
+      {isAIDraft && (
+        <Box sx={{ display: 'flex', alignItems: 'center', gap: 0.75 }}>
+          <Sparkles size={12} color="#7c3aed" />
+          <Typography variant="caption" sx={{ color: '#7c3aed', fontSize: '0.7rem', fontWeight: 500 }}>
+            KI-Entwurf — bitte prüfen und anpassen
+          </Typography>
+        </Box>
+      )}
+
       <TextField
         size="small"
         label="Nachricht"
         value={body}
-        onChange={e => setBody(e.target.value)}
+        onChange={e => { setBody(e.target.value); setIsAIDraft(false) }}
         multiline
-        rows={4}
+        rows={7}
         placeholder="Antwort verfassen..."
         fullWidth
+        sx={isAIDraft ? { '& .MuiOutlinedInput-root': { borderColor: '#ddd6fe' }, '& fieldset': { borderColor: '#ddd6fe !important' } } : {}}
       />
 
       {attachments.length > 0 && (
@@ -123,7 +146,6 @@ export function InquiryReplyComposer({
                 display: 'flex',
                 alignItems: 'center',
                 gap: 0.75,
-                bgcolor: 'white',
                 border: '1px solid',
                 borderColor: a.generated ? '#bfdbfe' : '#cbd5e1',
                 borderRadius: 1,
@@ -150,15 +172,32 @@ export function InquiryReplyComposer({
         </Box>
       )}
 
-      <Box sx={{ display: 'flex', alignItems: 'center', gap: 1.5, justifyContent: 'space-between' }}>
-        <Button
-          size="small"
-          startIcon={<Paperclip size={14} />}
-          onClick={handleAddMockAttachment}
-          sx={{ textTransform: 'none' }}
-        >
-          Anhang
-        </Button>
+      <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, justifyContent: 'space-between' }}>
+        <Box sx={{ display: 'flex', gap: 0.75 }}>
+          <Button
+            size="small"
+            startIcon={<Sparkles size={13} />}
+            onClick={handleAIDraft}
+            sx={{
+              textTransform: 'none',
+              fontSize: '0.75rem',
+              color: '#7c3aed',
+              borderColor: '#ddd6fe',
+              '&:hover': { bgcolor: '#f5f3ff', borderColor: '#c4b5fd' },
+            }}
+            variant="outlined"
+          >
+            KI-Entwurf
+          </Button>
+          <Button
+            size="small"
+            startIcon={<Paperclip size={13} />}
+            onClick={handleAddMockAttachment}
+            sx={{ textTransform: 'none', fontSize: '0.75rem' }}
+          >
+            Anhang
+          </Button>
+        </Box>
         <Button
           variant="contained"
           size="small"
@@ -167,7 +206,7 @@ export function InquiryReplyComposer({
           }
           onClick={handleSend}
           disabled={sending || !body.trim()}
-          sx={{ textTransform: 'none', bgcolor: '#1e3a5f', '&:hover': { bgcolor: '#16304d' } }}
+          sx={{ textTransform: 'none', bgcolor: '#152642', '&:hover': { bgcolor: '#16304d' } }}
         >
           Antwort senden
         </Button>

src/components/anfragencenter/LatentInquiriesTab.tsx

@@ -47,7 +47,7 @@ export function LatentInquiriesTab() {
             <Box sx={{ px: 2, py: 1.5, borderTop: '1px solid #e2e8f0', flexShrink: 0 }}>
               <Box
                 onClick={() => setMobileView('properties')}
-                sx={{ p: 1.25, bgcolor: '#1e3a5f', color: 'white', borderRadius: 1, textAlign: 'center', cursor: 'pointer', fontSize: '0.85rem', fontWeight: 600 }}
+                sx={{ p: 1.25, bgcolor: '#152642', color: 'white', borderRadius: 1, textAlign: 'center', cursor: 'pointer', fontSize: '0.85rem', fontWeight: 600 }}
               >
                 Eigene Objekte anzeigen →
               </Box>

src/components/anfragencenter/LatentInquiryReportPreview.tsx

@@ -3,6 +3,7 @@ import { Building2, MapPin, Ruler, Calendar } from 'lucide-react'
 import type { InquiryPreparationReportDraft, ReportObjectFieldKey } from '../../domain/inquiryReport'
 import type { Property } from '../../domain/property'
 import type { Inquiry } from '../../domain/inquiry'
+import { DS_TEXT, DS_BG, DS_SURFACE, DS_BORDER } from '../../lib/ds'
 
 interface Props {
   draft: InquiryPreparationReportDraft
@@ -100,39 +101,39 @@ export function LatentInquiryReportPreview({ draft, inquiry, properties }: Props
           mb: 2,
         }}
       >
-        <Box sx={{ borderBottom: '3px solid #1e3a5f', pb: 2, mb: 3 }}>
-          <Typography variant="h5" sx={{ fontWeight: 700, color: '#1e3a5f', fontFamily: 'inherit' }}>
+        <Box sx={{ borderBottom: `3px solid ${DS_TEXT.brand}`, pb: 2, mb: 3 }}>
+          <Typography variant="h5" sx={{ fontWeight: 700, color: DS_TEXT.brand, fontFamily: 'inherit' }}>
             Objektvorschlag
           </Typography>
-          <Typography variant="body2" sx={{ color: '#64748b', mt: 0.5 }}>
+          <Typography variant="body2" sx={{ color: DS_TEXT.muted, mt: 0.5 }}>
             Wincasa AG · {new Date().toLocaleDateString('de-CH')}
           </Typography>
         </Box>
 
         {editableByField['intro'] && (
-          <Typography variant="body2" sx={{ whiteSpace: 'pre-wrap', lineHeight: 1.8, mb: 3, color: '#1e293b' }}>
+          <Typography variant="body2" sx={{ whiteSpace: 'pre-wrap', lineHeight: 1.8, mb: 3, color: DS_TEXT.primary }}>
             {editableByField['intro']}
           </Typography>
         )}
 
-        <Box sx={{ bgcolor: '#f8fafc', border: '1px solid #e2e8f0', borderRadius: 1, p: 2, mb: 3 }}>
-          <Typography variant="body2" sx={{ fontWeight: 700, color: '#0f172a', mb: 1 }}>
+        <Box sx={{ bgcolor: DS_BG.page, border: `1px solid ${DS_BORDER.default}`, borderRadius: 1, p: 2, mb: 3 }}>
+          <Typography variant="body2" sx={{ fontWeight: 700, color: DS_TEXT.primary, mb: 1 }}>
             Ihre Anfrage
           </Typography>
-          <Typography variant="body2" sx={{ color: '#374151', mb: 0.5 }}>
+          <Typography variant="body2" sx={{ color: DS_TEXT.primary, mb: 0.5 }}>
             <strong>Kontakt:</strong> {inquiry.tenantName}{inquiry.tenantCompany ? ` · ${inquiry.tenantCompany}` : ''}
           </Typography>
-          <Typography variant="body2" sx={{ color: '#374151' }}>
+          <Typography variant="body2" sx={{ color: DS_TEXT.primary }}>
             <strong>Betreff:</strong> {inquiry.subject}
           </Typography>
         </Box>
 
         {editableByField['highlights'] && (
           <>
-            <Typography variant="body2" sx={{ fontWeight: 700, color: '#0f172a', mb: 1 }}>
+            <Typography variant="body2" sx={{ fontWeight: 700, color: DS_TEXT.primary, mb: 1 }}>
               Warum diese Objekte passen
             </Typography>
-            <Typography variant="body2" sx={{ whiteSpace: 'pre-wrap', lineHeight: 1.8, color: '#374151', mb: 3 }}>
+            <Typography variant="body2" sx={{ whiteSpace: 'pre-wrap', lineHeight: 1.8, color: DS_TEXT.primary, mb: 3 }}>
               {editableByField['highlights']}
             </Typography>
           </>
@@ -145,7 +146,7 @@ export function LatentInquiryReportPreview({ draft, inquiry, properties }: Props
               label={p.title}
               size="small"
               icon={<Building2 size={12} />}
-              sx={{ bgcolor: '#e0e7ff', color: '#1e3a5f', fontWeight: 600 }}
+              sx={{ bgcolor: DS_SURFACE.indigo.bg, color: DS_TEXT.brand, fontWeight: 600 }}
             />
           ))}
         </Box>
@@ -161,7 +162,7 @@ export function LatentInquiryReportPreview({ draft, inquiry, properties }: Props
           <Box key={property.id}>
             <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, mb: 1 }}>
               <Divider sx={{ flex: 1 }} />
-              <Typography variant="caption" sx={{ color: '#94a3b8', fontSize: '0.7rem', whiteSpace: 'nowrap' }}>
+              <Typography variant="caption" sx={{ color: DS_TEXT.disabled, fontSize: '0.7rem', whiteSpace: 'nowrap' }}>
                 Objekt {idx + 1} von {selectedProps.length}
               </Typography>
               <Divider sx={{ flex: 1 }} />
@@ -184,7 +185,7 @@ export function LatentInquiryReportPreview({ draft, inquiry, properties }: Props
                     height: 120,
                     borderRadius: 1,
                     overflow: 'hidden',
-                    bgcolor: '#e2e8f0',
+                    bgcolor: DS_BORDER.default,
                     backgroundImage: property.mapImageUrl ? `url(${property.mapImageUrl})` : 'none',
                     backgroundSize: 'cover',
                     backgroundPosition: 'center',
@@ -194,7 +195,7 @@ export function LatentInquiryReportPreview({ draft, inquiry, properties }: Props
                     justifyContent: 'center',
                   }}
                 >
-                  {!property.mapImageUrl && <MapPin size={28} color="#94a3b8" />}
+                  {!property.mapImageUrl && <MapPin size={28} color={DS_TEXT.disabled} />}
                 </Box>
                 {/* Property photo */}
                 <Box
@@ -203,7 +204,7 @@ export function LatentInquiryReportPreview({ draft, inquiry, properties }: Props
                     height: 120,
                     borderRadius: 1,
                     overflow: 'hidden',
-                    bgcolor: '#e2e8f0',
+                    bgcolor: DS_BORDER.default,
                     backgroundImage: image ? `url(${image})` : 'none',
                     backgroundSize: 'cover',
                     backgroundPosition: 'center',
@@ -212,23 +213,23 @@ export function LatentInquiryReportPreview({ draft, inquiry, properties }: Props
                     justifyContent: 'center',
                   }}
                 >
-                  {!image && <Building2 size={28} color="#94a3b8" />}
+                  {!image && <Building2 size={28} color={DS_TEXT.disabled} />}
                 </Box>
               </Box>
 
-              <Typography variant="h6" sx={{ fontWeight: 700, color: '#1e3a5f', mb: 0.5, fontFamily: 'inherit' }}>
+              <Typography variant="h6" sx={{ fontWeight: 700, color: DS_TEXT.brand, mb: 0.5, fontFamily: 'inherit' }}>
                 {property.title}
               </Typography>
               <Box sx={{ display: 'flex', gap: 2, mb: 2 }}>
-                <Box sx={{ display: 'flex', alignItems: 'center', gap: 0.5, color: '#64748b' }}>
+                <Box sx={{ display: 'flex', alignItems: 'center', gap: 0.5, color: DS_TEXT.muted }}>
                   <MapPin size={13} />
                   <Typography variant="caption">{property.location.city}{property.location.district ? `, ${property.location.district}` : ''}</Typography>
                 </Box>
-                <Box sx={{ display: 'flex', alignItems: 'center', gap: 0.5, color: '#64748b' }}>
+                <Box sx={{ display: 'flex', alignItems: 'center', gap: 0.5, color: DS_TEXT.muted }}>
                   <Ruler size={13} />
                   <Typography variant="caption">{property.areaSqm.toLocaleString('de-CH')} m²</Typography>
                 </Box>
-                <Box sx={{ display: 'flex', alignItems: 'center', gap: 0.5, color: '#64748b' }}>
+                <Box sx={{ display: 'flex', alignItems: 'center', gap: 0.5, color: DS_TEXT.muted }}>
                   <Calendar size={13} />
                   <Typography variant="caption">{new Date(property.availabilityDate).toLocaleDateString('de-CH')}</Typography>
                 </Box>
@@ -240,7 +241,7 @@ export function LatentInquiryReportPreview({ draft, inquiry, properties }: Props
                     display: 'grid',
                     gridTemplateColumns: '1fr 1fr',
                     gap: 0.75,
-                    bgcolor: '#f8fafc',
+                    bgcolor: DS_BG.page,
                     borderRadius: 1,
                     p: 1.5,
                   }}
@@ -250,10 +251,10 @@ export function LatentInquiryReportPreview({ draft, inquiry, properties }: Props
                     if (!val) return null
                     return (
                       <Box key={key}>
-                        <Typography variant="caption" sx={{ color: '#64748b', fontSize: '0.68rem', display: 'block' }}>
+                        <Typography variant="caption" sx={{ color: DS_TEXT.muted, fontSize: '0.68rem', display: 'block' }}>
                           {FIELD_LABELS[key] ?? key}
                         </Typography>
-                        <Typography variant="caption" sx={{ fontWeight: 600, color: '#0f172a', fontSize: '0.78rem' }}>
+                        <Typography variant="caption" sx={{ fontWeight: 600, color: DS_TEXT.primary, fontSize: '0.78rem' }}>
                           {val}
                         </Typography>
                       </Box>
@@ -268,10 +269,10 @@ export function LatentInquiryReportPreview({ draft, inquiry, properties }: Props
 
       {editableByField['next_steps'] && (
         <Box sx={{ bgcolor: 'white', p: 3, boxShadow: '0 2px 12px rgba(0,0,0,0.1)', borderRadius: 1 }}>
-          <Typography variant="body2" sx={{ fontWeight: 700, color: '#0f172a', mb: 1 }}>
+          <Typography variant="body2" sx={{ fontWeight: 700, color: DS_TEXT.primary, mb: 1 }}>
             Nächste Schritte
           </Typography>
-          <Typography variant="body2" sx={{ whiteSpace: 'pre-wrap', lineHeight: 1.8, color: '#374151' }}>
+          <Typography variant="body2" sx={{ whiteSpace: 'pre-wrap', lineHeight: 1.8, color: DS_TEXT.primary }}>
             {editableByField['next_steps']}
           </Typography>
         </Box>

src/components/anfragencenter/MockPdfPreview.tsx

@@ -1,18 +1,86 @@
-import { Box, Typography } from '@mui/material'
-import { FileText } from 'lucide-react'
+import { Box, Divider, Typography } from '@mui/material'
+import { Building2, FileText, MapPin } from 'lucide-react'
 import { useOfferWizardStore } from '../../stores/offerWizardStore'
 import { mockProperties } from '../../mock-data/properties'
+import type { ReportObjectFieldKey, ReportObjectFieldSelection } from '../../domain/inquiryReport'
+import type { Property } from '../../domain/property'
 
 interface MockPdfPreviewProps {
   fields: Record<string, string>
   fallbackFields: Record<string, string>
+  fieldSelections: ReportObjectFieldSelection[]
 }
 
-export function MockPdfPreview({ fields, fallbackFields }: MockPdfPreviewProps) {
+const FIELD_LABELS: Partial<Record<ReportObjectFieldKey, string>> = {
+  areaSqm: 'Fläche',
+  rentPricePerSqm: 'Mietpreis',
+  availabilityDate: 'Verfügbar ab',
+  leaseTerm: 'Mietlaufzeit',
+  breakoutOption: 'Breakout-Option',
+  currentTenant: 'Aktueller Mieter',
+  propertyNumber: 'Objektnummer',
+  assetType: 'Asset Type',
+  floor: 'Stockwerk',
+  parking: 'Parkplätze',
+  fitOut: 'Ausbaugrad',
+  isBarrierFree: 'Barrierefrei',
+  ceilingHeightM: 'Raumhöhe',
+  floorLoad: 'Bodenlast',
+  loadingDocksCount: 'Anlieferung',
+  goodsLift: 'Warenaufzug',
+  passengerLift: 'Personenaufzug',
+  powerSupplyKva: 'Stromanschluss',
+  hasServerRoom: 'Serverraum',
+  internet: 'Internet',
+  deliveryAccess: 'Zufahrt',
+  publicTransportScore: 'ÖV-Anbindung',
+  prestigeScore: 'Prestige',
+  visibilityScore: 'Sichtbarkeit',
+  footfallScore: 'Passantenfrequenz',
+  commuterAccessScore: 'Pendlererreichbarkeit',
+  talentAccessScore: 'Talent Access',
+  esgScore: 'ESG',
+  flexibilityScore: 'Flexibilität',
+  expansionPotentialScore: 'Expansionspotenzial',
+  taxEnvironmentScore: 'Steuerumfeld',
+  microLocation: 'Mikrostandort',
+  competitionEnvironment: 'Konkurrenzumfeld',
+  infrastructure: 'Infrastruktur',
+  description: 'Beschreibung',
+}
+
+function getFieldValue(property: Property, key: ReportObjectFieldKey): string | null {
+  switch (key) {
+    case 'areaSqm': return property.areaSqm ? `${property.areaSqm.toLocaleString('de-CH')} m²` : null
+    case 'rentPricePerSqm': return property.rentPricePerSqm ? `CHF ${property.rentPricePerSqm}/m²/J` : null
+    case 'availabilityDate': return property.availabilityDate ? new Date(property.availabilityDate).toLocaleDateString('de-CH') : null
+    case 'leaseTerm': return property.leaseTerm ?? null
+    case 'breakoutOption': return property.breakoutOption != null ? (property.breakoutOption ? 'Ja' : 'Nein') : null
+    case 'currentTenant': return property.currentTenant ?? null
+    case 'propertyNumber': return property.propertyNumber ?? null
+    case 'assetType': return property.assetType ?? null
+    case 'floor': return property.floorLevel != null ? String(property.floorLevel) : null
+    case 'parking': return property.softFactors?.parkingSpots != null ? `${property.softFactors.parkingSpots} Pl.` : null
+    case 'ceilingHeightM': return property.hardFacts?.ceilingHeightM != null ? `${property.hardFacts.ceilingHeightM} m` : null
+    case 'loadingDocksCount': return property.hardFacts?.loadingDocksCount != null ? String(property.hardFacts.loadingDocksCount) : null
+    case 'powerSupplyKva': return property.hardFacts?.powerSupplyKva != null ? `${property.hardFacts.powerSupplyKva} kVA` : null
+    case 'hasServerRoom': return property.hardFacts?.hasServerRoom != null ? (property.hardFacts.hasServerRoom ? 'Ja' : 'Nein') : null
+    case 'isBarrierFree': return property.hardFacts?.isBarrierFree != null ? (property.hardFacts.isBarrierFree ? 'Ja' : 'Nein') : null
+    case 'fitOut': return property.hardFacts?.fitOut ?? null
+    case 'publicTransportScore': return property.softFactors?.publicTransportMinutes != null ? `${property.softFactors.publicTransportMinutes} Min.` : null
+    case 'prestigeScore': return property.softFactors?.prestige != null ? `${property.softFactors.prestige}/100` : null
+    case 'visibilityScore': return property.softFactors?.visibilityScore != null ? `${property.softFactors.visibilityScore}/100` : null
+    case 'description': return property.description ?? null
+    default: return null
+  }
+}
+
+export function MockPdfPreview({ fields, fallbackFields, fieldSelections }: MockPdfPreviewProps) {
   const needTitle = useOfferWizardStore(s => s.needTitle)
   const propertyIds = useOfferWizardStore(s => s.selectedPropertyIds)
 
   const properties = mockProperties.filter(p => propertyIds.includes(p.id))
+  const hasPropertyPage = fieldSelections.length > 0 && properties.length > 0
 
   const v = (id: string) => fields[id] ?? fallbackFields[id] ?? ''
 
@@ -29,6 +97,7 @@ export function MockPdfPreview({ fields, fallbackFields }: MockPdfPreviewProps)
         fontFamily: '"Georgia", "Times New Roman", serif',
       }}
     >
+      {/* ── Page 1 — Offer letter ── */}
       <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, mb: 3, color: '#64748b' }}>
         <FileText size={16} />
         <Typography variant="caption" sx={{ textTransform: 'uppercase', letterSpacing: 1, fontSize: '0.7rem' }}>
@@ -73,7 +142,7 @@ export function MockPdfPreview({ fields, fallbackFields }: MockPdfPreviewProps)
             variant="body2"
             sx={{ fontSize: '0.875rem', mb: 0.5, lineHeight: 1.5 }}
           >
-            <strong>{p.title}</strong> — {p.location.city}, {p.areaSqm.toLocaleString('de-CH')} m², CHF {p.rentPricePerSqm}/m²
+            <strong>{p.title}</strong> — {p.location.city}, {p.areaSqm.toLocaleString('de-CH')} m², CHF {p.rentPricePerSqm}/m²/Jahr
           </Typography>
         ))}
         {properties.length === 0 && (
@@ -90,6 +159,93 @@ export function MockPdfPreview({ fields, fallbackFields }: MockPdfPreviewProps)
       <Typography variant="body2" sx={{ fontSize: '0.875rem', whiteSpace: 'pre-wrap', lineHeight: 1.6 }}>
         {v('closing')}
       </Typography>
+
+      {/* ── Page 2 — Property details side by side ── */}
+      {hasPropertyPage && (
+        <>
+          <Box sx={{ my: 3, display: 'flex', alignItems: 'center', gap: 1.5 }}>
+            <Divider sx={{ flex: 1, borderColor: '#152642', borderWidth: 1 }} />
+            <Typography variant="caption" sx={{ color: '#94a3b8', fontSize: '0.68rem', whiteSpace: 'nowrap', letterSpacing: 0.5, textTransform: 'uppercase' }}>
+              Seite 2 — Objektdetails
+            </Typography>
+            <Divider sx={{ flex: 1, borderColor: '#152642', borderWidth: 1 }} />
+          </Box>
+
+          <Box
+            sx={{
+              display: 'grid',
+              gridTemplateColumns: `repeat(${Math.min(properties.length, 3)}, 1fr)`,
+              gap: 1.5,
+            }}
+          >
+            {properties.map(p => {
+              const selection = fieldSelections.find(fs => fs.propertyId === p.id)
+              const optionalFields = selection?.selectedOptionalFields ?? []
+              const image = p.images?.[0]
+
+              return (
+                <Box
+                  key={p.id}
+                  sx={{
+                    border: '1px solid #e2e8f0',
+                    borderRadius: 1,
+                    overflow: 'hidden',
+                    display: 'flex',
+                    flexDirection: 'column',
+                  }}
+                >
+                  {/* Photo */}
+                  {image ? (
+                    <Box
+                      component="img"
+                      src={image}
+                      alt={p.title}
+                      sx={{ width: '100%', height: 90, objectFit: 'cover', display: 'block' }}
+                    />
+                  ) : (
+                    <Box sx={{ height: 90, bgcolor: '#f1f5f9', display: 'flex', alignItems: 'center', justifyContent: 'center' }}>
+                      <Building2 size={22} color="#94a3b8" />
+                    </Box>
+                  )}
+
+                  {/* Info */}
+                  <Box sx={{ p: 1.25, flex: 1 }}>
+                    <Typography sx={{ fontWeight: 700, fontSize: '0.78rem', color: '#0f172a', lineHeight: 1.3, mb: 0.4 }}>
+                      {p.title}
+                    </Typography>
+                    <Box sx={{ display: 'flex', alignItems: 'center', gap: 0.3, mb: 1 }}>
+                      <MapPin size={10} color="#94a3b8" />
+                      <Typography sx={{ fontSize: '0.68rem', color: '#64748b' }}>
+                        {p.location.city}{p.location.district ? ` · ${p.location.district}` : ''}
+                      </Typography>
+                    </Box>
+
+                    {/* Selected fields */}
+                    {optionalFields.length > 0 && (
+                      <Box sx={{ display: 'flex', flexDirection: 'column', gap: 0.4 }}>
+                        {optionalFields.map(key => {
+                          const val = getFieldValue(p, key)
+                          if (!val) return null
+                          return (
+                            <Box key={key} sx={{ display: 'flex', justifyContent: 'space-between', gap: 0.5 }}>
+                              <Typography sx={{ fontSize: '0.62rem', color: '#94a3b8' }}>
+                                {FIELD_LABELS[key] ?? key}
+                              </Typography>
+                              <Typography sx={{ fontSize: '0.68rem', fontWeight: 600, color: '#0f172a', textAlign: 'right' }}>
+                                {val}
+                              </Typography>
+                            </Box>
+                          )
+                        })}
+                      </Box>
+                    )}
+                  </Box>
+                </Box>
+              )
+            })}
+          </Box>
+        </>
+      )}
     </Box>
   )
 }

src/components/anfragencenter/OfferChatComposer.tsx

@@ -116,7 +116,7 @@ export function OfferChatComposer() {
                       py: 0.75,
                     }}
                   >
-                    <FileText size={14} color="#1e3a5f" />
+                    <FileText size={14} color="#152642" />
                     <Typography variant="caption" sx={{ fontSize: '0.8rem', fontWeight: 500 }}>
                       {a.fileName}
                     </Typography>

src/components/anfragencenter/OfferCreationPanel.tsx

@@ -35,7 +35,7 @@ export function OfferCreationPanel({ selectedCount, needId, needTitle }: OfferCr
         onClick={() => open(needId, needTitle)}
         sx={{
           textTransform: 'none',
-          bgcolor: '#1e3a5f',
+          bgcolor: '#152642',
           fontWeight: 600,
           '&:hover': { bgcolor: '#16304d' },
         }}

src/components/anfragencenter/OfferCreationWizard.tsx

@@ -1,14 +1,15 @@
 import { useEffect, useRef, useState } from 'react'
 import {
   Box, Button, CircularProgress, Dialog, DialogContent,
-  IconButton, LinearProgress, Stack, Step, StepLabel, Stepper,
+  IconButton, Stack, Step, StepLabel, Stepper,
   TextField, Typography,
 } from '@mui/material'
-import { Download, Plus, Send, Trash2, X } from 'lucide-react'
+import { Plus, Trash2, X } from 'lucide-react'
 import type { OfferReportDraft, ViewingAppointmentOption } from '../../domain/offerReport'
-import { offerReportService } from '../../services/offerReportService'
+import { useCreateOfferReport, useUpdateOfferReport, useGenerateOfferReportPdf } from '../../hooks/useOfferReport'
 import { usePropertyById } from '../../hooks/useProperties'
 import { useToastStore } from '../../stores/toastStore'
+import { OfferWizardPdfStep } from './OfferWizardPdfStep'
 
 interface Props {
   inquiryId: string
@@ -31,10 +32,16 @@ export function OfferCreationWizard({ inquiryId, propertyId, tenantName, onClose
   const showToast = useToastStore(s => s.showToast)
   const timerRef = useRef<ReturnType<typeof setInterval> | null>(null)
 
+  const createOfferReport = useCreateOfferReport()
+  const updateOfferReport = useUpdateOfferReport()
+  const generatePdf = useGenerateOfferReportPdf()
+
   useEffect(() => {
-    offerReportService
-      .create(inquiryId, propertyId, tenantName, property?.title ?? '')
-      .then(d => { setDraft(d); setLoading(false) })
+    createOfferReport.mutate(
+      { inquiryId, propertyId, tenantName, propertyTitle: property?.title ?? '' },
+      { onSuccess: (d) => { setDraft(d); setLoading(false) } },
+    )
+  // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [inquiryId, propertyId, tenantName, property?.title])
 
   useEffect(() => () => { if (timerRef.current) clearInterval(timerRef.current) }, [])
@@ -69,32 +76,35 @@ export function OfferCreationWizard({ inquiryId, propertyId, tenantName, onClose
     })
   }
 
-  const handleGeneratePdf = async () => {
+  const handleGeneratePdf = () => {
     if (!draft) return
-    await offerReportService.update(draft.id, {
-      editableFields: draft.editableFields,
-      viewingAppointments: draft.viewingAppointments,
-    })
-    setStep(3)
-    setGenerating(true)
-    setProgress(0)
-    let p = 0
-    timerRef.current = setInterval(() => {
-      p += Math.random() * 18 + 8
-      if (p >= 100) {
-        clearInterval(timerRef.current!)
-        setProgress(100)
-        setGenerating(false)
-        setReady(true)
-        offerReportService.generatePdf(draft.id).then(setDraft)
-      } else {
-        setProgress(Math.min(100, p))
-      }
-    }, 200)
+    updateOfferReport.mutate(
+      { draftId: draft.id, data: { editableFields: draft.editableFields, viewingAppointments: draft.viewingAppointments } },
+      {
+        onSuccess: () => {
+          setStep(3)
+          setGenerating(true)
+          setProgress(0)
+          let p = 0
+          timerRef.current = setInterval(() => {
+            p += Math.random() * 18 + 8
+            if (p >= 100) {
+              clearInterval(timerRef.current!)
+              setProgress(100)
+              setGenerating(false)
+              setReady(true)
+              generatePdf.mutate(draft.id, { onSuccess: setDraft })
+            } else {
+              setProgress(Math.min(100, p))
+            }
+          }, 200)
+        },
+      },
+    )
   }
 
   return (
-    <Dialog open fullWidth maxWidth="lg" PaperProps={{ sx: { height: '90vh', display: 'flex', flexDirection: 'column' } }}>
+    <Dialog open fullWidth maxWidth="lg" slotProps={{ paper: { sx: { height: '90vh', display: 'flex', flexDirection: 'column' } } }}>
       <Box sx={{ px: 3, pt: 2.5, pb: 1.5, borderBottom: '1px solid #e2e8f0', display: 'flex', alignItems: 'center', justifyContent: 'space-between', flexShrink: 0 }}>
         <Typography variant="h6" sx={{ fontWeight: 700 }}>Angebot erstellen</Typography>
         <Button size="small" onClick={onClose} sx={{ minWidth: 0, p: 0.5 }}><X size={18} /></Button>
@@ -177,7 +187,7 @@ export function OfferCreationWizard({ inquiryId, propertyId, tenantName, onClose
                     size="small"
                     value={a.date}
                     onChange={e => updateAppointment(a.id, 'date', e.target.value)}
-                    InputLabelProps={{ shrink: true }}
+                    slotProps={{ inputLabel: { shrink: true } }}
                     sx={{ width: 160 }}
                   />
                   <TextField
@@ -213,94 +223,19 @@ export function OfferCreationWizard({ inquiryId, propertyId, tenantName, onClose
 
         {/* Step 3: PDF */}
         {step === 3 && (
-          <Box sx={{ display: 'flex', flexDirection: 'column', alignItems: 'center', justifyContent: 'center', height: '100%', gap: 3 }}>
-            {generating ? (
-              <>
-                <CircularProgress size={48} sx={{ color: '#1e3a5f' }} />
-                <Typography variant="body1" sx={{ fontWeight: 600, color: '#1e3a5f' }}>
-                  PDF wird generiert…
-                </Typography>
-                <Box sx={{ width: '100%', maxWidth: 400 }}>
-                  <LinearProgress variant="determinate" value={progress} sx={{ height: 6, borderRadius: 3 }} />
-                  <Typography variant="caption" sx={{ color: '#64748b', display: 'block', textAlign: 'center', mt: 1 }}>
-                    {Math.round(progress)}%
-                  </Typography>
-                </Box>
-              </>
-            ) : ready ? (
-              <Box sx={{ display: 'flex', flexDirection: 'column', alignItems: 'center', gap: 2, width: '100%' }}>
-                <Box
-                  sx={{
-                    width: '100%',
-                    maxWidth: 520,
-                    height: 380,
-                    bgcolor: '#f8fafc',
-                    border: '1px solid #e2e8f0',
-                    borderRadius: 1.5,
-                    display: 'flex',
-                    flexDirection: 'column',
-                    overflow: 'hidden',
-                  }}
-                >
-                  <Box sx={{ bgcolor: '#1e3a5f', px: 2, py: 1, display: 'flex', alignItems: 'center', gap: 1 }}>
-                    <Box sx={{ width: 10, height: 10, borderRadius: '50%', bgcolor: '#ef4444' }} />
-                    <Box sx={{ width: 10, height: 10, borderRadius: '50%', bgcolor: '#f59e0b' }} />
-                    <Box sx={{ width: 10, height: 10, borderRadius: '50%', bgcolor: '#10b981' }} />
-                    <Typography variant="caption" sx={{ color: 'rgba(255,255,255,0.7)', ml: 1, fontSize: '0.7rem' }}>
-                      Angebot_{draft?.propertyId ?? 'Objekt'}.pdf
-                    </Typography>
-                  </Box>
-                  <Box sx={{ flex: 1, p: 3 }}>
-                    <Typography variant="body2" sx={{ fontWeight: 700, color: '#1e3a5f', mb: 1 }}>
-                      Angebotsschreiben
-                    </Typography>
-                    {draft?.editableFields.slice(0, 3).map(f => (
-                      <Box key={f.id} sx={{ mb: 1 }}>
-                        <Typography variant="caption" sx={{ color: '#94a3b8', fontSize: '0.65rem', display: 'block' }}>{f.label}</Typography>
-                        <Typography variant="caption" sx={{ color: '#374151', fontSize: '0.75rem', display: 'block' }}>
-                          {f.value.slice(0, 80)}{f.value.length > 80 ? '…' : ''}
-                        </Typography>
-                      </Box>
-                    ))}
-                    {(draft?.viewingAppointments.length ?? 0) > 0 && (
-                      <Box sx={{ mt: 1.5, p: 1, bgcolor: '#f1f5f9', borderRadius: 1 }}>
-                        <Typography variant="caption" sx={{ fontWeight: 600, fontSize: '0.72rem', display: 'block', mb: 0.5 }}>
-                          Besichtigungstermine
-                        </Typography>
-                        {draft!.viewingAppointments.map(a => (
-                          <Typography key={a.id} variant="caption" sx={{ fontSize: '0.7rem', display: 'block', color: '#475569' }}>
-                            {new Date(a.date).toLocaleDateString('de-CH')} · {a.timeSlot}
-                          </Typography>
-                        ))}
-                      </Box>
-                    )}
-                  </Box>
-                </Box>
-                <Box sx={{ display: 'flex', gap: 1.5 }}>
-                  <Button
-                    variant="contained"
-                    startIcon={<Download size={16} />}
-                    onClick={() => showToast('PDF wird heruntergeladen…', 'info')}
-                    sx={{ textTransform: 'none', bgcolor: '#1e3a5f', '&:hover': { bgcolor: '#16304d' } }}
-                  >
-                    Herunterladen
-                  </Button>
-                  <Button
-                    variant="outlined"
-                    startIcon={<Send size={16} />}
-                    onClick={() => {
-                      const label = `Angebot_${property?.title ?? 'Objekt'}.pdf`
-                      onAttach(label)
-                      showToast('Angebot als Anhang hinzugefügt', 'success')
-                    }}
-                    sx={{ textTransform: 'none' }}
-                  >
-                    An Nachricht anhängen
-                  </Button>
-                </Box>
-              </Box>
-            ) : null}
-          </Box>
+          <OfferWizardPdfStep
+            generating={generating}
+            progress={progress}
+            ready={ready}
+            draft={draft}
+            property={property ?? undefined}
+            onDownload={() => showToast('PDF wird heruntergeladen…', 'info')}
+            onAttach={() => {
+              const label = `Angebot_${property?.title ?? 'Objekt'}.pdf`
+              onAttach(label)
+              showToast('Angebot als Anhang hinzugefügt', 'success')
+            }}
+          />
         )}
       </DialogContent>
 
@@ -320,7 +255,7 @@ export function OfferCreationWizard({ inquiryId, propertyId, tenantName, onClose
               variant="contained"
               disabled={loading}
               onClick={() => setStep(1)}
-              sx={{ textTransform: 'none', bgcolor: '#1e3a5f', '&:hover': { bgcolor: '#16304d' } }}
+              sx={{ textTransform: 'none', bgcolor: '#152642', '&:hover': { bgcolor: '#16304d' } }}
             >
               Weiter
             </Button>
@@ -329,7 +264,7 @@ export function OfferCreationWizard({ inquiryId, propertyId, tenantName, onClose
             <Button
               variant="contained"
               onClick={() => setStep(2)}
-              sx={{ textTransform: 'none', bgcolor: '#1e3a5f', '&:hover': { bgcolor: '#16304d' } }}
+              sx={{ textTransform: 'none', bgcolor: '#152642', '&:hover': { bgcolor: '#16304d' } }}
             >
               Weiter
             </Button>
@@ -338,7 +273,7 @@ export function OfferCreationWizard({ inquiryId, propertyId, tenantName, onClose
             <Button
               variant="contained"
               onClick={handleGeneratePdf}
-              sx={{ textTransform: 'none', bgcolor: '#1e3a5f', '&:hover': { bgcolor: '#16304d' } }}
+              sx={{ textTransform: 'none', bgcolor: '#152642', '&:hover': { bgcolor: '#16304d' } }}
             >
               PDF erstellen
             </Button>

src/components/anfragencenter/OfferFieldSelectionStep.tsx

@@ -0,0 +1,87 @@
+import { useEffect } from 'react'
+import { Box, Button, Stack, Typography } from '@mui/material'
+import { ArrowLeft } from 'lucide-react'
+import { useOfferWizardStore } from '../../stores/offerWizardStore'
+import { useProperties } from '../../hooks/useProperties'
+import { ReportObjectFieldSelector } from './ReportObjectFieldSelector'
+import type { ReportObjectFieldKey, ReportObjectFieldSelection } from '../../domain/inquiryReport'
+
+const DEFAULT_FIELDS: ReportObjectFieldKey[] = ['areaSqm', 'rentPricePerSqm', 'availabilityDate']
+const MANDATORY_FIELDS: ReportObjectFieldKey[] = ['title', 'location', 'mapImageUrl', 'images']
+
+export function OfferFieldSelectionStep() {
+  const propertyIds = useOfferWizardStore(s => s.selectedPropertyIds)
+  const fieldSelections = useOfferWizardStore(s => s.fieldSelections)
+  const setFieldSelections = useOfferWizardStore(s => s.setFieldSelections)
+  const updateFieldSelection = useOfferWizardStore(s => s.updateFieldSelection)
+  const setStep = useOfferWizardStore(s => s.setStep)
+
+  const { data: allProperties = [] } = useProperties()
+  const selectedProperties = allProperties.filter(p => propertyIds.includes(p.id))
+
+  // Initialise selections when properties are loaded or change
+  useEffect(() => {
+    if (selectedProperties.length === 0) return
+    const existing = new Set(fieldSelections.map(fs => fs.propertyId))
+    const missing = selectedProperties.filter(p => !existing.has(p.id))
+    if (missing.length > 0) {
+      setFieldSelections([
+        ...fieldSelections,
+        ...missing.map(p => ({
+          propertyId: p.id,
+          mandatoryFields: MANDATORY_FIELDS,
+          selectedOptionalFields: DEFAULT_FIELDS,
+        })),
+      ])
+    }
+  // run only when property list or selections change length
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [selectedProperties.length, fieldSelections.length])
+
+  return (
+    <Box sx={{ display: 'flex', flexDirection: 'column', height: '100%', overflow: 'hidden' }}>
+      <Box sx={{ flex: 1, overflowY: 'auto', p: 3 }}>
+        <Typography variant="body2" sx={{ color: '#64748b', mb: 2.5 }}>
+          Wählen Sie die Datenfelder, die auf der Objektseite des Angebots angezeigt werden sollen.
+          Pflichtfelder (Titel, Standort, Foto) sind immer enthalten.
+        </Typography>
+
+        <Stack spacing={2}>
+          {selectedProperties.map(p => {
+            const selection: ReportObjectFieldSelection =
+              fieldSelections.find(fs => fs.propertyId === p.id) ?? {
+                propertyId: p.id,
+                mandatoryFields: MANDATORY_FIELDS,
+                selectedOptionalFields: DEFAULT_FIELDS,
+              }
+            return (
+              <ReportObjectFieldSelector
+                key={p.id}
+                propertyTitle={p.title}
+                value={selection}
+                onChange={v => updateFieldSelection(p.id, v)}
+              />
+            )
+          })}
+        </Stack>
+      </Box>
+
+      <Box sx={{ px: 3, py: 2, borderTop: '1px solid #e2e8f0', bgcolor: 'white', display: 'flex', justifyContent: 'space-between', flexShrink: 0 }}>
+        <Button
+          startIcon={<ArrowLeft size={14} />}
+          onClick={() => setStep('select_properties')}
+          sx={{ textTransform: 'none' }}
+        >
+          Zurück
+        </Button>
+        <Button
+          variant="contained"
+          onClick={() => setStep('pdf_review')}
+          sx={{ textTransform: 'none', bgcolor: '#152642', '&:hover': { bgcolor: '#16304d' } }}
+        >
+          Weiter
+        </Button>
+      </Box>
+    </Box>
+  )
+}

src/components/anfragencenter/OfferPdfReviewStep.tsx

@@ -66,6 +66,8 @@ export function OfferPdfReviewStep() {
     }
   }
 
+  const fieldSelections = useOfferWizardStore(s => s.fieldSelections)
+
   const needTitle = useOfferWizardStore(s => s.needTitle)
   const addAttachment = useOfferWizardStore(s => s.addAttachment)
   const setMessageDraft = useOfferWizardStore(s => s.setMessageDraft)
@@ -128,7 +130,7 @@ export function OfferPdfReviewStep() {
               </Typography>
             </Box>
           ) : (
-            <MockPdfPreview fields={editableFieldsStore} fallbackFields={fallback} />
+            <MockPdfPreview fields={editableFieldsStore} fallbackFields={fallback} fieldSelections={fieldSelections} />
           )}
         </Box>
 
@@ -177,7 +179,7 @@ export function OfferPdfReviewStep() {
           endIcon={markChecked.isPending ? <CircularProgress size={14} sx={{ color: 'white' }} /> : <Send size={14} />}
           onClick={handleNext}
           disabled={!pdfReady || markChecked.isPending}
-          sx={{ textTransform: 'none', bgcolor: '#1e3a5f', '&:hover': { bgcolor: '#16304d' } }}
+          sx={{ textTransform: 'none', bgcolor: '#152642', '&:hover': { bgcolor: '#16304d' } }}
         >
           {markChecked.isPending ? 'Wird geprüft…' : 'Angebot senden →'}
         </Button>

src/components/anfragencenter/OfferPropertySelectionStep.tsx

@@ -70,7 +70,7 @@ export function OfferPropertySelectionStep() {
       return
     }
     setOfferDraftId(res.data.id)
-    setStep('pdf_review')
+    setStep('select_fields')
   }
 
   if (!need) {
@@ -141,7 +141,7 @@ export function OfferPropertySelectionStep() {
           endIcon={createDraft.isPending ? <CircularProgress size={14} sx={{ color: 'white' }} /> : <ArrowRight size={14} />}
           onClick={handleNext}
           disabled={selectedIds.length === 0 || createDraft.isPending}
-          sx={{ textTransform: 'none', bgcolor: '#1e3a5f', '&:hover': { bgcolor: '#16304d' } }}
+          sx={{ textTransform: 'none', bgcolor: '#152642', '&:hover': { bgcolor: '#16304d' } }}
         >
           Weiter
         </Button>

src/components/anfragencenter/OfferWizard.tsx

@@ -12,22 +12,25 @@ import {
 import { X } from 'lucide-react'
 import { useOfferWizardStore, type OfferStep } from '../../stores/offerWizardStore'
 import { OfferPropertySelectionStep } from './OfferPropertySelectionStep'
+import { OfferFieldSelectionStep } from './OfferFieldSelectionStep'
 import { OfferPdfReviewStep } from './OfferPdfReviewStep'
 import { OfferCheckedAction } from './OfferCheckedAction'
 import { OfferChatComposer } from './OfferChatComposer'
 
-// 'checked' is internal — merged into pdf_review step; only 3 steps shown
+// 'checked' is internal — merged into pdf_review step; 4 visible steps
 const STEPS: { key: OfferStep; label: string }[] = [
   { key: 'select_properties', label: 'Objekte wählen' },
+  { key: 'select_fields',     label: 'Felder wählen' },
   { key: 'pdf_review',        label: 'Vorschau & Prüfen' },
   { key: 'send',              label: 'Senden' },
 ]
 
 const STEP_DISPLAY_INDEX: Record<OfferStep, number> = {
   select_properties: 0,
-  pdf_review: 1,
-  checked: 1, // same visual step as pdf_review
-  send: 2,
+  select_fields: 1,
+  pdf_review: 2,
+  checked: 2, // same visual step as pdf_review
+  send: 3,
 }
 
 export function OfferWizard() {
@@ -48,12 +51,14 @@ export function OfferWizard() {
       fullScreen={fullScreen}
       maxWidth="lg"
       fullWidth
-      PaperProps={{
-        sx: {
-          height: fullScreen ? '100vh' : '85vh',
-          display: 'flex',
-          flexDirection: 'column',
-          overflow: 'hidden',
+      slotProps={{
+        paper: {
+          sx: {
+            height: fullScreen ? '100vh' : '85vh',
+            display: 'flex',
+            flexDirection: 'column',
+            overflow: 'hidden',
+          },
         },
       }}
     >
@@ -112,6 +117,7 @@ export function OfferWizard() {
       {/* Step content */}
       <Box sx={{ flex: 1, overflow: 'hidden', display: 'flex', flexDirection: 'column' }}>
         {currentStep === 'select_properties' && <OfferPropertySelectionStep />}
+        {currentStep === 'select_fields' && <OfferFieldSelectionStep />}
         {currentStep === 'pdf_review' && <OfferPdfReviewStep />}
         {currentStep === 'checked' && <OfferCheckedAction />}
         {currentStep === 'send' && <OfferChatComposer />}

src/components/anfragencenter/OfferWizardPdfStep.tsx

@@ -0,0 +1,103 @@
+import { Box, Button, CircularProgress, LinearProgress, Typography } from '@mui/material'
+import { Download, Send } from 'lucide-react'
+import type { OfferReportDraft } from '../../domain/offerReport'
+import type { Property } from '../../domain/property'
+
+interface OfferWizardPdfStepProps {
+  generating: boolean
+  progress: number
+  ready: boolean
+  draft: OfferReportDraft | null
+  property: Property | undefined
+  onDownload: () => void
+  onAttach: () => void
+}
+
+export function OfferWizardPdfStep({ generating, progress, ready, draft, property, onDownload, onAttach }: OfferWizardPdfStepProps) {
+  return (
+    <Box sx={{ display: 'flex', flexDirection: 'column', alignItems: 'center', justifyContent: 'center', height: '100%', gap: 3 }}>
+      {generating ? (
+        <>
+          <CircularProgress size={48} sx={{ color: '#152642' }} />
+          <Typography variant="body1" sx={{ fontWeight: 600, color: '#152642' }}>
+            PDF wird generiert…
+          </Typography>
+          <Box sx={{ width: '100%', maxWidth: 400 }}>
+            <LinearProgress variant="determinate" value={progress} sx={{ height: 6, borderRadius: 3 }} />
+            <Typography variant="caption" sx={{ color: '#64748b', display: 'block', textAlign: 'center', mt: 1 }}>
+              {Math.round(progress)}%
+            </Typography>
+          </Box>
+        </>
+      ) : ready ? (
+        <Box sx={{ display: 'flex', flexDirection: 'column', alignItems: 'center', gap: 2, width: '100%' }}>
+          <Box
+            sx={{
+              width: '100%',
+              maxWidth: 520,
+              height: 380,
+              bgcolor: '#f8fafc',
+              border: '1px solid #e2e8f0',
+              borderRadius: 1.5,
+              display: 'flex',
+              flexDirection: 'column',
+              overflow: 'hidden',
+            }}
+          >
+            <Box sx={{ bgcolor: '#152642', px: 2, py: 1, display: 'flex', alignItems: 'center', gap: 1 }}>
+              <Box sx={{ width: 10, height: 10, borderRadius: '50%', bgcolor: '#ef4444' }} />
+              <Box sx={{ width: 10, height: 10, borderRadius: '50%', bgcolor: '#f59e0b' }} />
+              <Box sx={{ width: 10, height: 10, borderRadius: '50%', bgcolor: '#10b981' }} />
+              <Typography variant="caption" sx={{ color: 'rgba(255,255,255,0.7)', ml: 1, fontSize: '0.7rem' }}>
+                Angebot_{property?.title ?? 'Objekt'}.pdf
+              </Typography>
+            </Box>
+            <Box sx={{ flex: 1, p: 3 }}>
+              <Typography variant="body2" sx={{ fontWeight: 700, color: '#152642', mb: 1 }}>
+                Angebotsschreiben
+              </Typography>
+              {draft?.editableFields.slice(0, 3).map(f => (
+                <Box key={f.id} sx={{ mb: 1 }}>
+                  <Typography variant="caption" sx={{ color: '#94a3b8', fontSize: '0.65rem', display: 'block' }}>{f.label}</Typography>
+                  <Typography variant="caption" sx={{ color: '#374151', fontSize: '0.75rem', display: 'block' }}>
+                    {f.value.slice(0, 80)}{f.value.length > 80 ? '…' : ''}
+                  </Typography>
+                </Box>
+              ))}
+              {(draft?.viewingAppointments.length ?? 0) > 0 && (
+                <Box sx={{ mt: 1.5, p: 1, bgcolor: '#f1f5f9', borderRadius: 1 }}>
+                  <Typography variant="caption" sx={{ fontWeight: 600, fontSize: '0.72rem', display: 'block', mb: 0.5 }}>
+                    Besichtigungstermine
+                  </Typography>
+                  {draft!.viewingAppointments.map(a => (
+                    <Typography key={a.id} variant="caption" sx={{ fontSize: '0.7rem', display: 'block', color: '#475569' }}>
+                      {new Date(a.date).toLocaleDateString('de-CH')} · {a.timeSlot}
+                    </Typography>
+                  ))}
+                </Box>
+              )}
+            </Box>
+          </Box>
+          <Box sx={{ display: 'flex', gap: 1.5 }}>
+            <Button
+              variant="contained"
+              startIcon={<Download size={16} />}
+              onClick={onDownload}
+              sx={{ textTransform: 'none', bgcolor: '#152642', '&:hover': { bgcolor: '#16304d' } }}
+            >
+              Herunterladen
+            </Button>
+            <Button
+              variant="outlined"
+              startIcon={<Send size={16} />}
+              onClick={onAttach}
+              sx={{ textTransform: 'none' }}
+            >
+              An Nachricht anhängen
+            </Button>
+          </Box>
+        </Box>
+      ) : null}
+    </Box>
+  )
+}

src/components/anfragencenter/OwnPropertyMatchList.tsx

@@ -62,7 +62,7 @@ export function OwnPropertyMatchList({ need }: OwnPropertyMatchListProps) {
           flexShrink: 0,
         }}
       >
-        <Target size={14} color="#1e3a5f" />
+        <Target size={14} color="#152642" />
         <Typography variant="body2" sx={{ fontWeight: 600, color: '#0f172a' }}>
           Eigene Objekte
         </Typography>
@@ -72,7 +72,7 @@ export function OwnPropertyMatchList({ need }: OwnPropertyMatchListProps) {
             px: 1,
             py: 0.125,
             borderRadius: 1,
-            bgcolor: '#1e3a5f',
+            bgcolor: '#152642',
             color: 'white',
             fontWeight: 600,
             fontSize: '0.7rem',

src/components/anfragencenter/PreparationWizard.tsx

@@ -6,9 +6,8 @@ import {
 } from '@mui/material'
 import { Download, Send, X } from 'lucide-react'
 import type { Inquiry } from '../../domain/inquiry'
-import type { Property } from '../../domain/property'
 import type { InquiryPreparationReportDraft, ReportObjectFieldSelection } from '../../domain/inquiryReport'
-import { inquiryReportService } from '../../services/inquiryReportService'
+import { useCreateInquiryReport, useUpdateInquiryReport, useFinalizeInquiryReport } from '../../hooks/useInquiryReport'
 import { useToastStore } from '../../stores/toastStore'
 import { ReportObjectFieldSelector } from './ReportObjectFieldSelector'
 import { LatentInquiryReportPreview } from './LatentInquiryReportPreview'
@@ -29,16 +28,16 @@ export function PreparationWizard({ inquiryId, inquiry, onClose }: Props) {
   const [draft, setDraft] = useState<InquiryPreparationReportDraft | null>(null)
   const [generating, setGenerating] = useState(false)
   const [progress, setProgress] = useState(0)
-  const [finalizing, setFinalizing] = useState(false)
   const { data: allProperties = [] } = useProperties()
   const showToast = useToastStore(s => s.showToast)
   const timerRef = useRef<ReturnType<typeof setInterval> | null>(null)
 
-  const portfolioProps = allProperties.filter(p => p.resultType === ResultType.VERIFIED_PORTFOLIO)
+  const createInquiryReport = useCreateInquiryReport()
+  const updateInquiryReport = useUpdateInquiryReport()
+  const finalizeInquiryReport = useFinalizeInquiryReport()
+  const finalizing = finalizeInquiryReport.isPending
 
-  const selectedProperties = draft?.selectedPropertyIds
-    .map(id => allProperties.find(p => p.id === id))
-    .filter((p): p is Property => !!p) ?? []
+  const portfolioProps = allProperties.filter(p => p.resultType === ResultType.VERIFIED_PORTFOLIO)
 
   const toggleProperty = (id: string) => {
     setSelectedIds(prev =>
@@ -46,7 +45,7 @@ export function PreparationWizard({ inquiryId, inquiry, onClose }: Props) {
     )
   }
 
-  const handleGenerate = async () => {
+  const handleGenerate = () => {
     setStep(1)
     setGenerating(true)
     setProgress(0)
@@ -57,10 +56,15 @@ export function PreparationWizard({ inquiryId, inquiry, onClose }: Props) {
         clearInterval(timerRef.current!)
         setProgress(100)
         setGenerating(false)
-        inquiryReportService.create(inquiryId, selectedIds).then(d => {
-          setDraft(d)
-          setStep(2)
-        })
+        createInquiryReport.mutate(
+          { inquiryId, selectedPropertyIds: selectedIds },
+          {
+            onSuccess: (d) => {
+              setDraft(d)
+              setStep(2)
+            },
+          },
+        )
       } else {
         setProgress(Math.min(100, p))
       }
@@ -85,18 +89,25 @@ export function PreparationWizard({ inquiryId, inquiry, onClose }: Props) {
     })
   }
 
-  const handleFinalize = async () => {
+  const handleFinalize = () => {
     if (!draft) return
-    setFinalizing(true)
-    await inquiryReportService.update(draft.id, { editableFields: draft.editableFields, fieldSelections: draft.fieldSelections })
-    const finalized = await inquiryReportService.finalize(draft.id)
-    setDraft(finalized)
-    setFinalizing(false)
-    setStep(3)
+    updateInquiryReport.mutate(
+      { draftId: draft.id, data: { editableFields: draft.editableFields, fieldSelections: draft.fieldSelections } },
+      {
+        onSuccess: () => {
+          finalizeInquiryReport.mutate(draft.id, {
+            onSuccess: (finalized) => {
+              setDraft(finalized)
+              setStep(3)
+            },
+          })
+        },
+      },
+    )
   }
 
   return (
-    <Dialog open fullWidth maxWidth="lg" PaperProps={{ sx: { height: '90vh', display: 'flex', flexDirection: 'column' } }}>
+    <Dialog open fullWidth maxWidth="lg" slotProps={{ paper: { sx: { height: '90vh', display: 'flex', flexDirection: 'column' } } }}>
       <Box sx={{ px: 3, pt: 2.5, pb: 1.5, borderBottom: '1px solid #e2e8f0', display: 'flex', alignItems: 'center', justifyContent: 'space-between', flexShrink: 0 }}>
         <Typography variant="h6" sx={{ fontWeight: 700 }}>Vorbereitung starten</Typography>
         <Button size="small" onClick={onClose} sx={{ minWidth: 0, p: 0.5 }}><X size={18} /></Button>
@@ -148,8 +159,8 @@ export function PreparationWizard({ inquiryId, inquiry, onClose }: Props) {
           <Box sx={{ display: 'flex', flexDirection: 'column', alignItems: 'center', justifyContent: 'center', height: '100%', gap: 3 }}>
             {generating ? (
               <>
-                <CircularProgress size={48} sx={{ color: '#1e3a5f' }} />
-                <Typography variant="body1" sx={{ fontWeight: 600, color: '#1e3a5f' }}>
+                <CircularProgress size={48} sx={{ color: '#152642' }} />
+                <Typography variant="body1" sx={{ fontWeight: 600, color: '#152642' }}>
                   Bericht wird erstellt…
                 </Typography>
                 <Box sx={{ width: '100%', maxWidth: 400 }}>
@@ -223,7 +234,7 @@ export function PreparationWizard({ inquiryId, inquiry, onClose }: Props) {
                 fullWidth
                 startIcon={<Download size={16} />}
                 onClick={() => showToast('PDF wird heruntergeladen…', 'info')}
-                sx={{ textTransform: 'none', bgcolor: '#1e3a5f', '&:hover': { bgcolor: '#16304d' } }}
+                sx={{ textTransform: 'none', bgcolor: '#152642', '&:hover': { bgcolor: '#16304d' } }}
               >
                 Herunterladen
               </Button>
@@ -260,7 +271,7 @@ export function PreparationWizard({ inquiryId, inquiry, onClose }: Props) {
               variant="contained"
               disabled={selectedIds.length === 0}
               onClick={handleGenerate}
-              sx={{ textTransform: 'none', bgcolor: '#1e3a5f', '&:hover': { bgcolor: '#16304d' } }}
+              sx={{ textTransform: 'none', bgcolor: '#152642', '&:hover': { bgcolor: '#16304d' } }}
             >
               Weiter
             </Button>
@@ -271,7 +282,7 @@ export function PreparationWizard({ inquiryId, inquiry, onClose }: Props) {
               disabled={finalizing}
               onClick={handleFinalize}
               startIcon={finalizing ? <CircularProgress size={14} sx={{ color: 'white' }} /> : undefined}
-              sx={{ textTransform: 'none', bgcolor: '#1e3a5f', '&:hover': { bgcolor: '#16304d' } }}
+              sx={{ textTransform: 'none', bgcolor: '#152642', '&:hover': { bgcolor: '#16304d' } }}
             >
               Finalisieren
             </Button>

src/components/anfragencenter/PublicNeedCard.tsx

@@ -19,12 +19,12 @@ export function PublicNeedCard({ need, selected, onClick }: PublicNeedCardProps)
         p: 1.5,
         borderRadius: 1.5,
         border: '1px solid',
-        borderColor: selected ? '#1e3a5f' : '#e2e8f0',
+        borderColor: selected ? '#152642' : '#e8e7e4',
         bgcolor: selected ? '#f1f5f9' : 'white',
         cursor: 'pointer',
         transition: 'all 0.15s',
         '&:hover': {
-          borderColor: selected ? '#1e3a5f' : '#94a3b8',
+          borderColor: selected ? '#152642' : '#94a3b8',
           boxShadow: '0 2px 6px rgba(15,23,42,0.06)',
         },
         display: 'flex',

src/components/anfragencenter/PublicNeedDetail.tsx

@@ -174,7 +174,7 @@ export function PublicNeedDetail({ need }: PublicNeedDetailProps) {
                         variant="caption"
                         sx={{
                           fontWeight: 700,
-                          color: '#1e3a5f',
+                          color: '#152642',
                           fontSize: '0.75rem',
                           bgcolor: '#e0e7ff',
                           px: 1,
@@ -189,7 +189,7 @@ export function PublicNeedDetail({ need }: PublicNeedDetailProps) {
                       sx={{
                         height: 6,
                         borderRadius: 3,
-                        bgcolor: '#e2e8f0',
+                        bgcolor: '#e8e7e4',
                         overflow: 'hidden',
                       }}
                     >
@@ -197,7 +197,7 @@ export function PublicNeedDetail({ need }: PublicNeedDetailProps) {
                         sx={{
                           width: `${pct}%`,
                           height: '100%',
-                          bgcolor: '#1e3a5f',
+                          bgcolor: '#152642',
                           transition: 'width 0.3s',
                         }}
                       />
@@ -229,7 +229,7 @@ export function PublicNeedDetail({ need }: PublicNeedDetailProps) {
             disabled={disabled}
             sx={{
               textTransform: 'none',
-              bgcolor: '#1e3a5f',
+              bgcolor: '#152642',
               fontWeight: 600,
               '&:hover': { bgcolor: '#16304d' },
             }}

src/components/anfragencenter/PublicNeedList.tsx

@@ -47,7 +47,7 @@ export function PublicNeedList({ selectedNeedId, onSelect, fullWidth }: PublicNe
             px: 1,
             py: 0.125,
             borderRadius: 1,
-            bgcolor: '#1e3a5f',
+            bgcolor: '#152642',
             color: 'white',
             fontWeight: 600,
             fontSize: '0.7rem',

src/components/anfragencenter/RelatedPropertyCardPanel.tsx

@@ -1,31 +1,25 @@
-import { useEffect, useState } from 'react'
 import { Box, Button, CircularProgress, Divider, Typography } from '@mui/material'
-import { ArrowRight, Building2, Calendar, MapPin, Ruler, Trophy } from 'lucide-react'
+import { ArrowRight, Building2, Calendar, MapPin, Ruler } from 'lucide-react'
 import { useNavigate } from 'react-router'
 import { usePropertyById } from '../../hooks/useProperties'
-import { matchService } from '../../services/matchService'
+import { useAdditionalMatchesForInquiry } from '../../hooks/useMatches'
 import type { AdditionalPropertyMatch } from '../../domain/additionalMatch'
 
 interface RelatedPropertyCardPanelProps {
   propertyId: string
   inquiryId: string
+  compact?: boolean
 }
 
-export function RelatedPropertyCardPanel({ propertyId, inquiryId }: RelatedPropertyCardPanelProps) {
+export function RelatedPropertyCardPanel({ propertyId, inquiryId, compact }: RelatedPropertyCardPanelProps) {
   const { data: property, isLoading } = usePropertyById(propertyId)
   const navigate = useNavigate()
-  const [additionalMatches, setAdditionalMatches] = useState<AdditionalPropertyMatch[]>([])
-  const [loadingMatches, setLoadingMatches] = useState(false)
+  const {
+    data: additionalMatches = [],
+    isLoading: loadingMatches,
+  } = useAdditionalMatchesForInquiry(inquiryId, { minScore: 80, excludePropertyId: propertyId })
 
-  useEffect(() => {
-    setLoadingMatches(true)
-    matchService
-      .getAdditionalMatchesForInquiry(inquiryId, { minScore: 80, excludePropertyId: propertyId })
-      .then(setAdditionalMatches)
-      .finally(() => setLoadingMatches(false))
-  }, [inquiryId, propertyId])
-
-  if (isLoading) {
+  if (isLoading && !compact) {
     return (
       <Box sx={{ display: 'flex', justifyContent: 'center', alignItems: 'center', p: 4 }}>
         <CircularProgress size={20} />
@@ -33,6 +27,44 @@ export function RelatedPropertyCardPanel({ propertyId, inquiryId }: RelatedPrope
     )
   }
 
+  if (compact) {
+    return (
+      <Box sx={{ px: 1.5, pt: 1.25, pb: 1.5, bgcolor: 'white' }}>
+        <Typography
+          variant="caption"
+          sx={{ color: '#64748b', fontWeight: 600, textTransform: 'uppercase', letterSpacing: 0.5, fontSize: '0.65rem', display: 'block', mb: 1 }}
+        >
+          Weitere passende Objekte
+        </Typography>
+
+        {loadingMatches ? (
+          <Box sx={{ display: 'flex', justifyContent: 'center', py: 1.5 }}>
+            <CircularProgress size={16} />
+          </Box>
+        ) : additionalMatches.length === 0 ? (
+          <Typography variant="caption" sx={{ color: '#94a3b8', fontSize: '0.72rem' }}>
+            Keine weiteren Matches
+          </Typography>
+        ) : (
+          <Box
+            sx={{
+              display: 'flex',
+              gap: 1.25,
+              overflowX: 'auto',
+              pb: 0.5,
+              '&::-webkit-scrollbar': { height: 3 },
+              '&::-webkit-scrollbar-thumb': { bgcolor: '#cbd5e1', borderRadius: 2 },
+            }}
+          >
+            {additionalMatches.map(m => (
+              <MatchSliderCard key={m.propertyId} match={m} />
+            ))}
+          </Box>
+        )}
+      </Box>
+    )
+  }
+
   if (!property) {
     return (
       <Box sx={{ p: 2 }}>
@@ -58,25 +90,22 @@ export function RelatedPropertyCardPanel({ propertyId, inquiryId }: RelatedPrope
         overflowY: 'auto',
       }}
     >
-      <Typography variant="caption" sx={{ color: '#64748b', fontWeight: 600, textTransform: 'uppercase', letterSpacing: 0.5 }}>
-        Bezogenes Objekt
-      </Typography>
-
       <Box
         sx={{
-          height: 140,
+          aspectRatio: '3/2',
           borderRadius: 1.5,
           overflow: 'hidden',
-          bgcolor: '#e2e8f0',
-          display: 'flex',
-          alignItems: 'center',
-          justifyContent: 'center',
-          backgroundImage: image ? `url(${image})` : 'none',
-          backgroundSize: 'cover',
-          backgroundPosition: 'center',
+          bgcolor: '#f4f3f0',
         }}
       >
-        {!image && <Building2 size={32} color="#94a3b8" />}
+        {image ? (
+          <Box component="img" src={image} alt={property.title}
+            sx={{ width: '100%', height: '100%', objectFit: 'cover', display: 'block' }} />
+        ) : (
+          <Box sx={{ width: '100%', height: '100%', display: 'flex', alignItems: 'center', justifyContent: 'center' }}>
+            <Building2 size={32} color="#94a3b8" />
+          </Box>
+        )}
       </Box>
 
       <Typography variant="body1" sx={{ fontWeight: 600, color: '#0f172a', fontSize: '0.95rem' }}>
@@ -84,20 +113,20 @@ export function RelatedPropertyCardPanel({ propertyId, inquiryId }: RelatedPrope
       </Typography>
 
       <Box sx={{ display: 'flex', flexDirection: 'column', gap: 0.75 }}>
-        <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, color: '#475569', fontSize: '0.8125rem' }}>
+        <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, color: '#475569' }}>
           <MapPin size={14} />
           <Typography variant="body2" sx={{ fontSize: '0.8125rem' }}>
             {property.location.city}
             {property.location.district ? `, ${property.location.district}` : ''}
           </Typography>
         </Box>
-        <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, color: '#475569', fontSize: '0.8125rem' }}>
+        <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, color: '#475569' }}>
           <Ruler size={14} />
           <Typography variant="body2" sx={{ fontSize: '0.8125rem' }}>
-            {property.areaSqm.toLocaleString('de-CH')} m² · CHF {property.rentPricePerSqm}/m²
+            {property.areaSqm.toLocaleString('de-CH')} m² · CHF {property.rentPricePerSqm}/m²/Jahr
           </Typography>
         </Box>
-        <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, color: '#475569', fontSize: '0.8125rem' }}>
+        <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, color: '#475569' }}>
           <Calendar size={14} />
           <Typography variant="body2" sx={{ fontSize: '0.8125rem' }}>
             Verfügbar ab {new Date(property.availabilityDate).toLocaleDateString('de-CH')}
@@ -121,14 +150,10 @@ export function RelatedPropertyCardPanel({ propertyId, inquiryId }: RelatedPrope
         Objekt ansehen
       </Button>
 
-      {/* Weitere Matches */}
       <Divider sx={{ my: 0.5 }} />
-      <Box sx={{ display: 'flex', alignItems: 'center', gap: 0.75 }}>
-        <Trophy size={14} color="#d97706" />
-        <Typography variant="caption" sx={{ color: '#64748b', fontWeight: 600, textTransform: 'uppercase', letterSpacing: 0.5, fontSize: '0.68rem' }}>
-          Weitere passende Objekte
-        </Typography>
-      </Box>
+      <Typography variant="caption" sx={{ color: '#64748b', fontWeight: 600, textTransform: 'uppercase', letterSpacing: 0.5, fontSize: '0.68rem' }}>
+        Weitere passende Objekte
+      </Typography>
 
       {loadingMatches ? (
         <CircularProgress size={16} sx={{ alignSelf: 'center' }} />
@@ -147,74 +172,117 @@ export function RelatedPropertyCardPanel({ propertyId, inquiryId }: RelatedPrope
   )
 }
 
+function MatchSliderCard({ match }: { match: AdditionalPropertyMatch }) {
+  const navigate = useNavigate()
+  return (
+    <Box
+      onClick={() => navigate('/supply/properties')}
+      sx={{
+        flexShrink: 0,
+        width: 168,
+        border: '1px solid #e8e7e4',
+        borderRadius: 1.5,
+        overflow: 'hidden',
+        cursor: 'pointer',
+        bgcolor: 'white',
+        transition: 'border-color 0.15s, box-shadow 0.15s',
+        '&:hover': {
+          borderColor: '#b0aead',
+          boxShadow: '0 2px 8px rgba(0,0,0,0.08)',
+        },
+      }}
+    >
+      {/* Image — 16:9 crop, compact supplementary card */}
+      <Box sx={{ position: 'relative', height: 60, bgcolor: '#f4f3f0', overflow: 'hidden' }}>
+        {match.imageUrl ? (
+          <Box
+            component="img"
+            src={match.imageUrl}
+            alt={match.title}
+            sx={{ width: '100%', height: '100%', objectFit: 'cover', display: 'block' }}
+          />
+        ) : (
+          <Box sx={{ width: '100%', height: '100%', display: 'flex', alignItems: 'center', justifyContent: 'center' }}>
+            <Building2 size={16} color="#94a3b8" />
+          </Box>
+        )}
+        {/* Score badge overlay */}
+        <Box
+          sx={{
+            position: 'absolute',
+            top: 6,
+            right: 6,
+            bgcolor: 'rgba(15,23,42,0.72)',
+            color: 'white',
+            fontSize: '0.7rem',
+            fontWeight: 700,
+            px: 0.75,
+            py: 0.25,
+            borderRadius: '4px',
+            lineHeight: 1.4,
+          }}
+        >
+          {match.matchScore}%
+        </Box>
+      </Box>
+      <Box sx={{ p: 0.75 }}>
+        <Box sx={{ display: 'flex', justifyContent: 'space-between', alignItems: 'baseline', mb: 0.2 }}>
+          <Typography
+            sx={{ fontWeight: 600, color: '#0f172a', fontSize: '0.75rem', lineHeight: 1.3, overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap', flex: 1, mr: 0.5 }}
+          >
+            {match.title}
+          </Typography>
+          <Typography sx={{ fontSize: '0.7rem', fontWeight: 700, color: '#152642', flexShrink: 0 }}>
+            {match.matchScore}%
+          </Typography>
+        </Box>
+        <Typography variant="caption" sx={{ color: '#64748b', fontSize: '0.68rem', display: 'block', overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }}>
+          {match.location}
+        </Typography>
+        {match.reasons[0] && (
+          <Typography variant="caption" sx={{ color: '#15803d', fontSize: '0.67rem', display: 'block', lineHeight: 1.4, overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap', mt: 0.2 }}>
+            + {match.reasons[0]}
+          </Typography>
+        )}
+      </Box>
+    </Box>
+  )
+}
+
 function AdditionalMatchCard({ match }: { match: AdditionalPropertyMatch }) {
   const navigate = useNavigate()
   return (
     <Box
       sx={{
-        border: '1px solid #e2e8f0',
-        borderRadius: 1.5,
-        overflow: 'hidden',
-        bgcolor: 'white',
+        borderTop: '1px solid #f1f5f9',
+        pt: 1,
+        '&:first-of-type': { borderTop: 'none', pt: 0 },
       }}
     >
-      {match.imageUrl && (
-        <Box
-          sx={{
-            height: 70,
-            backgroundImage: `url(${match.imageUrl})`,
-            backgroundSize: 'cover',
-            backgroundPosition: 'center',
-          }}
-        />
-      )}
-      <Box sx={{ p: 1 }}>
-        <Box sx={{ display: 'flex', justifyContent: 'space-between', alignItems: 'flex-start', mb: 0.5 }}>
-          <Typography variant="caption" sx={{ fontWeight: 600, color: '#0f172a', fontSize: '0.75rem', lineHeight: 1.3 }}>
-            {match.title}
-          </Typography>
-          <Box
-            sx={{
-              px: 0.75,
-              py: 0.125,
-              borderRadius: 1,
-              bgcolor: match.matchScore >= 90 ? '#fef3c7' : '#e0e7ff',
-              color: match.matchScore >= 90 ? '#92400e' : '#3730a3',
-              fontWeight: 700,
-              fontSize: '0.65rem',
-              flexShrink: 0,
-              ml: 0.5,
-            }}
-          >
-            {match.matchScore}%
-          </Box>
-        </Box>
-        <Typography variant="caption" sx={{ color: '#64748b', fontSize: '0.7rem', display: 'block', mb: 0.5 }}>
-          {match.location} · {match.areaSqm.toLocaleString('de-CH')} m² · CHF {match.rentPricePerSqm}/m²
+      <Box sx={{ display: 'flex', justifyContent: 'space-between', alignItems: 'baseline', mb: 0.25 }}>
+        <Typography sx={{ fontWeight: 600, color: '#0f172a', fontSize: '0.8rem', lineHeight: 1.3, mr: 0.5 }}>
+          {match.title}
+        </Typography>
+        <Typography sx={{ fontSize: '0.75rem', fontWeight: 700, color: '#152642', flexShrink: 0 }}>
+          {match.matchScore}%
         </Typography>
-        {match.reasons.length > 0 && (
-          <Box sx={{ mb: 0.5 }}>
-            {match.reasons.map((r, i) => (
-              <Typography key={i} variant="caption" sx={{ color: '#15803d', fontSize: '0.68rem', display: 'block', lineHeight: 1.4 }}>
-                + {r}
-              </Typography>
-            ))}
-          </Box>
-        )}
-        {match.topUncertainty && (
-          <Typography variant="caption" sx={{ color: '#92400e', fontSize: '0.68rem', display: 'block', lineHeight: 1.4, mb: 0.25 }}>
-            ⚠ {match.topUncertainty}
-          </Typography>
-        )}
-        <Button
-          size="small"
-          endIcon={<ArrowRight size={11} />}
-          onClick={() => navigate('/supply/properties')}
-          sx={{ textTransform: 'none', fontSize: '0.7rem', mt: 0.5, p: 0, minWidth: 0, color: '#1e3a5f' }}
-        >
-          Ansehen
-        </Button>
       </Box>
+      <Typography variant="caption" sx={{ color: '#64748b', fontSize: '0.72rem', display: 'block', mb: 0.375 }}>
+        {match.location} · {match.areaSqm.toLocaleString('de-CH')} m²
+      </Typography>
+      {match.reasons[0] && (
+        <Typography variant="caption" sx={{ color: '#15803d', fontSize: '0.7rem', display: 'block', mb: 0.375, lineHeight: 1.4 }}>
+          + {match.reasons[0]}
+        </Typography>
+      )}
+      <Button
+        size="small"
+        endIcon={<ArrowRight size={10} />}
+        onClick={() => navigate('/supply/properties')}
+        sx={{ textTransform: 'none', fontSize: '0.7rem', p: 0, minWidth: 0, color: '#152642' }}
+      >
+        Ansehen
+      </Button>
     </Box>
   )
 }

src/components/anfragencenter/ReportObjectFieldSelector.tsx

@@ -82,8 +82,6 @@ const FIELD_GROUPS: FieldGroup[] = [
   },
 ]
 
-const MANDATORY: ReportObjectFieldKey[] = ['title', 'location', 'mapImageUrl', 'images']
-
 export function ReportObjectFieldSelector({ propertyTitle, value, onChange }: Props) {
   const isSelected = (key: ReportObjectFieldKey) =>
     value.selectedOptionalFields.includes(key)
@@ -115,7 +113,6 @@ export function ReportObjectFieldSelector({ propertyTitle, value, onChange }: Pr
 
       {FIELD_GROUPS.map(group => {
         const groupKeys = group.fields.map(f => f.key)
-        const allSelected = groupKeys.every(k => value.selectedOptionalFields.includes(k))
         return (
           <Accordion key={group.label} disableGutters elevation={0} sx={{ border: '1px solid #e2e8f0', mb: 0.5, '&:before': { display: 'none' } }}>
             <AccordionSummary expandIcon={<ChevronDown size={16} />} sx={{ minHeight: 40, '& .MuiAccordionSummary-content': { my: 0.5 } }}>

src/components/anfragencenter/SelectablePropertyMatchCard.tsx

@@ -31,12 +31,12 @@ export function SelectablePropertyMatchCard({
         p: 1.25,
         borderRadius: 1.5,
         border: '1px solid',
-        borderColor: selected ? '#1e3a5f' : '#e2e8f0',
+        borderColor: selected ? '#152642' : '#e8e7e4',
         bgcolor: selected ? '#eff6ff' : 'white',
         cursor: 'pointer',
         transition: 'all 0.15s',
         '&:hover': {
-          borderColor: selected ? '#1e3a5f' : '#94a3b8',
+          borderColor: selected ? '#152642' : '#94a3b8',
         },
         display: 'flex',
         gap: 1.25,
@@ -57,7 +57,7 @@ export function SelectablePropertyMatchCard({
           height: 40,
           flexShrink: 0,
           borderRadius: 1,
-          bgcolor: '#e2e8f0',
+          bgcolor: '#e8e7e4',
           display: 'flex',
           alignItems: 'center',
           justifyContent: 'center',

src/components/anfragencenter/latentNeedUtils.ts

@@ -21,7 +21,7 @@ export function latentStatusBadge(status: 'public' | 'paused' | 'expired'): {
 } {
   if (status === 'public') return { label: 'Öffentlich', bg: '#dcfce7', fg: '#166534' }
   if (status === 'paused') return { label: 'Pausiert', bg: '#fed7aa', fg: '#9a3412' }
-  return { label: 'Abgelaufen', bg: '#e2e8f0', fg: '#475569' }
+  return { label: 'Abgelaufen', bg: '#e8e7e4', fg: '#475569' }
 }
 
 // Deterministic pseudo-random match score from string IDs (range 60–96)

src/components/assistant/AssistantActionCards.tsx

@@ -9,7 +9,7 @@ interface Props {
 }
 
 const ACTION_COLORS: Record<string, string> = {
-  NAVIGATE: '#1e3a5f',
+  NAVIGATE: '#152642',
   OPEN_REVIEW: '#7c3aed',
   ADD_TO_SHORTLIST: '#1a7a4a',
   REQUEST_DATA: '#d97706',

src/components/assistant/AssistantMessageList.tsx

@@ -25,7 +25,7 @@ function MessageBubble({ message }: { message: AssistantMessage }) {
             px: 1.5,
             py: 1,
             borderRadius: isUser ? '8px 8px 2px 8px' : '2px 8px 8px 8px',
-            bgcolor: isUser ? '#1e3a5f' : '#f1f5f9',
+            bgcolor: isUser ? '#152642' : '#f1f5f9',
             color: isUser ? 'white' : '#1e293b',
           }}
         >

src/components/assistant/AssistantPromptSuggestions.tsx

@@ -1,5 +1,6 @@
 import { Box, Chip, Typography } from '@mui/material'
 import type { SuggestedQuestion } from '../../domain/assistant'
+import { DS_TEXT, DS_BORDER, DS_SURFACE, BADGE_COLORS } from '../../lib/ds'
 
 interface Props {
   suggestions: SuggestedQuestion[]
@@ -9,26 +10,26 @@ interface Props {
 
 const CATEGORY_COLORS: Record<string, string> = {
   Match: '#4f46e5',
-  Datenqualität: '#d97706',
-  Priorisierung: '#1e3a5f',
-  Empfehlung: '#1a7a4a',
-  Risiko: '#c0392b',
+  Datenqualität: DS_TEXT.warning,
+  Priorisierung: DS_TEXT.brand,
+  Empfehlung: DS_TEXT.success,
+  Risiko: DS_TEXT.error,
   Tradeoffs: '#ea580c',
   Strategie: '#0891b2',
-  Analyse: '#7c3aed',
+  Analyse: BADGE_COLORS.preMarket,
   Erklärung: '#0891b2',
-  Evidenz: '#64748b',
-  Review: '#7c3aed',
-  Konfidenz: '#d97706',
-  Fehler: '#c0392b',
+  Evidenz: DS_TEXT.muted,
+  Review: BADGE_COLORS.preMarket,
+  Konfidenz: DS_TEXT.warning,
+  Fehler: DS_TEXT.error,
   Fehleranalyse: '#ea580c',
   Eskalation: '#ea580c',
-  Prozess: '#64748b',
-  Kosten: '#1a7a4a',
-  Impact: '#d97706',
-  Optimierung: '#1a7a4a',
-  Aktion: '#1e3a5f',
-  Überblick: '#64748b',
+  Prozess: DS_TEXT.muted,
+  Kosten: DS_TEXT.success,
+  Impact: DS_TEXT.warning,
+  Optimierung: DS_TEXT.success,
+  Aktion: DS_TEXT.brand,
+  Überblick: DS_TEXT.muted,
   Ranking: '#4f46e5',
 }
 
@@ -37,12 +38,12 @@ export function AssistantPromptSuggestions({ suggestions, onSelect, disabled }:
 
   return (
     <Box sx={{ px: 2, py: 1.25 }}>
-      <Typography variant="caption" sx={{ fontWeight: 700, textTransform: 'uppercase', letterSpacing: 0.5, color: '#94a3b8', display: 'block', mb: 0.75, fontSize: '0.65rem' }}>
+      <Typography variant="caption" sx={{ fontWeight: 700, textTransform: 'uppercase', letterSpacing: 0.5, color: DS_TEXT.disabled, display: 'block', mb: 0.75, fontSize: '0.65rem' }}>
         Vorschläge
       </Typography>
       <Box sx={{ display: 'flex', flexDirection: 'column', gap: 0.625 }}>
         {suggestions.map(s => {
-          const catColor = CATEGORY_COLORS[s.category] ?? '#64748b'
+          const catColor = CATEGORY_COLORS[s.category] ?? DS_TEXT.muted
           return (
             <Box
               key={s.id}
@@ -51,11 +52,11 @@ export function AssistantPromptSuggestions({ suggestions, onSelect, disabled }:
                 px: 1.25,
                 py: 0.875,
                 borderRadius: 1.5,
-                border: '1px solid #e2e8f0',
+                border: `1px solid ${DS_BORDER.default}`,
                 cursor: disabled ? 'default' : 'pointer',
                 bgcolor: 'white',
                 opacity: disabled ? 0.5 : 1,
-                '&:hover': disabled ? {} : { bgcolor: '#f8fafc', borderColor: '#cbd5e1' },
+                '&:hover': disabled ? {} : { bgcolor: DS_SURFACE.neutral.bg, borderColor: DS_BORDER.strong },
                 transition: 'all 0.1s ease',
                 display: 'flex',
                 alignItems: 'center',

src/components/assistant/GlobalAIAssistantButton.tsx

@@ -3,7 +3,8 @@ import { Sparkles } from 'lucide-react'
 import { useAssistantStore } from '../../stores/assistantStore'
 
 export function GlobalAIAssistantButton() {
-  const { isOpen, open } = useAssistantStore()
+  const isOpen = useAssistantStore(s => s.isOpen)
+  const open = useAssistantStore(s => s.open)
 
   return (
     <Tooltip title="AI Assistent öffnen" placement="left">

src/components/assistant/GlobalAIAssistantDrawer.tsx

@@ -2,15 +2,16 @@ import { useCallback, useEffect, useRef, useState } from 'react'
 import { Box, Divider, Drawer, IconButton, TextField, Tooltip, Typography } from '@mui/material'
 import { RotateCcw, Send, Sparkles, X } from 'lucide-react'
 import { useLocation } from 'react-router'
+import { useShallow } from 'zustand/react/shallow'
 import { useAssistantStore } from '../../stores/assistantStore'
 import { useSessionStore } from '../../stores/sessionStore'
-import { aiAssistantService } from '../../services/aiAssistantService'
+import { useAssistantSuggestions, useAssistantAnswer } from '../../hooks/useAssistant'
 import { AssistantContextSummary } from './AssistantContextSummary'
 import { AssistantMessageList } from './AssistantMessageList'
 import { AssistantPromptSuggestions } from './AssistantPromptSuggestions'
 import { AssistantLoadingState } from './AssistantLoadingState'
 import { AssistantErrorState } from './AssistantErrorState'
-import type { AssistantContext, SuggestedQuestion } from '../../domain/assistant'
+import type { AssistantContext } from '../../domain/assistant'
 import type { WorkspaceType } from '../../domain/enums'
 
 function resolveWorkspace(pathname: string): WorkspaceType | null {
@@ -21,29 +22,18 @@ function resolveWorkspace(pathname: string): WorkspaceType | null {
 
 export function GlobalAIAssistantDrawer() {
   const { isOpen, close, context, setContext, messages, isLoading, error, addMessage, setLoading, setError, clearConversation } =
-    useAssistantStore()
+    useAssistantStore(useShallow(s => s))
 
   const { currentUser } = useSessionStore()
   const location = useLocation()
 
-  const [suggestions, setSuggestions] = useState<SuggestedQuestion[]>([])
   const [inputText, setInputText] = useState('')
   const scrollRef = useRef<HTMLDivElement>(null)
 
-  // Build context from route when drawer opens
-  useEffect(() => {
-    if (!isOpen) return
-    const ctx: AssistantContext = {
-      currentRoute: location.pathname,
-      workspace: resolveWorkspace(location.pathname),
-      userRole: currentUser?.role ?? 'VIEWER',
-      organizationId: currentUser?.organizationId ?? '',
-    }
-    setContext(ctx)
-    aiAssistantService.getSuggestions(ctx).then(setSuggestions)
-  }, [isOpen, location.pathname])
+  const answerQuestion = useAssistantAnswer()
+  const { data: suggestions = [] } = useAssistantSuggestions(isOpen ? context : null)
 
-  // Refresh suggestions when route changes while open
+  // Build context from route when drawer opens or route changes while open
   useEffect(() => {
     if (!isOpen) return
     const ctx: AssistantContext = {
@@ -53,8 +43,7 @@ export function GlobalAIAssistantDrawer() {
       organizationId: currentUser?.organizationId ?? '',
     }
     setContext(ctx)
-    aiAssistantService.getSuggestions(ctx).then(setSuggestions)
-  }, [location.pathname])
+  }, [isOpen, location.pathname])
 
   // Auto-scroll on new messages
   useEffect(() => {
@@ -63,7 +52,7 @@ export function GlobalAIAssistantDrawer() {
     }
   }, [messages, isLoading])
 
-  const handleQuestion = useCallback(async (question: string) => {
+  const handleQuestion = useCallback((question: string) => {
     if (!question.trim() || isLoading) return
     setInputText('')
     setError(null)
@@ -77,26 +66,32 @@ export function GlobalAIAssistantDrawer() {
     addMessage(userMsg)
     setLoading(true)
 
-    try {
-      const ctx = context ?? {
-        currentRoute: location.pathname,
-        workspace: resolveWorkspace(location.pathname),
-        userRole: currentUser?.role ?? 'VIEWER',
-        organizationId: currentUser?.organizationId ?? '',
-      }
-      const answer = await aiAssistantService.answerQuestion(ctx, question)
-      addMessage({
-        id: crypto.randomUUID(),
-        role: 'assistant',
-        createdAt: new Date().toISOString(),
-        ...answer,
-      })
-    } catch {
-      setError('Antwort konnte nicht generiert werden. Bitte erneut versuchen.')
-    } finally {
-      setLoading(false)
+    const ctx = context ?? {
+      currentRoute: location.pathname,
+      workspace: resolveWorkspace(location.pathname),
+      userRole: currentUser?.role ?? 'VIEWER',
+      organizationId: currentUser?.organizationId ?? '',
     }
-  }, [context, isLoading, location.pathname, currentUser, addMessage, setLoading, setError])
+
+    answerQuestion.mutate(
+      { context: ctx, question },
+      {
+        onSuccess: (answer) => {
+          addMessage({
+            id: crypto.randomUUID(),
+            role: 'assistant',
+            createdAt: new Date().toISOString(),
+            ...answer,
+          })
+          setLoading(false)
+        },
+        onError: () => {
+          setError('Antwort konnte nicht generiert werden. Bitte erneut versuchen.')
+          setLoading(false)
+        },
+      },
+    )
+  }, [context, isLoading, location.pathname, currentUser, addMessage, setLoading, setError, answerQuestion])
 
   const handleKeyDown = (e: React.KeyboardEvent) => {
     if (e.key === 'Enter' && !e.shiftKey) {
@@ -107,10 +102,6 @@ export function GlobalAIAssistantDrawer() {
 
   const handleClear = () => {
     clearConversation()
-    setSuggestions([])
-    if (context) {
-      aiAssistantService.getSuggestions(context).then(setSuggestions)
-    }
   }
 
   const showSuggestions = suggestions.length > 0 && messages.length === 0
@@ -246,7 +237,7 @@ export function GlobalAIAssistantDrawer() {
                   color: 'white',
                   flexShrink: 0,
                   '&:hover': { bgcolor: '#4338ca' },
-                  '&:disabled': { bgcolor: '#e2e8f0', color: '#94a3b8' },
+                  '&:disabled': { bgcolor: '#e8e7e4', color: '#94a3b8' },
                 }}
               >
                 <Send size={16} />

src/components/auth/DemoRoleSwitcher.tsx

@@ -1,6 +1,6 @@
 import { Box, Chip, Typography } from '@mui/material'
 import { UserRole } from '../../domain/enums'
-import { authService } from '../../services/authService'
+import { useSwitchDemoRole } from '../../hooks/useAuth'
 import { useSessionStore } from '../../stores/sessionStore'
 
 const DEMO_ROLES: { role: UserRole; label: string }[] = [
@@ -10,9 +10,10 @@ const DEMO_ROLES: { role: UserRole; label: string }[] = [
 
 export function DemoRoleSwitcher() {
   const { currentUser } = useSessionStore()
+  const switchDemoRole = useSwitchDemoRole()
 
-  async function handleSwitch(role: UserRole) {
-    await authService.switchDemoRole(role)
+  function handleSwitch(role: UserRole) {
+    switchDemoRole.mutate(role)
   }
 
   return (
@@ -36,10 +37,10 @@ export function DemoRoleSwitcher() {
               sx={{
                 fontSize: '0.7rem',
                 height: 22,
-                bgcolor: active ? '#1e3a5f' : 'transparent',
+                bgcolor: active ? '#152642' : 'transparent',
                 color: active ? '#fff' : 'text.secondary',
                 border: '1px solid',
-                borderColor: active ? '#1e3a5f' : 'divider',
+                borderColor: active ? '#152642' : 'divider',
                 '&:hover': { bgcolor: active ? '#162d4a' : 'rgba(0,0,0,0.04)' },
               }}
             />

src/components/auth/OrganizationSwitcher.tsx

@@ -1,6 +1,6 @@
 import { FormControl, MenuItem, Select, Typography } from '@mui/material'
 import type { SelectChangeEvent } from '@mui/material'
-import { authService } from '../../services/authService'
+import { useSwitchOrganization } from '../../hooks/useAuth'
 import { useSessionStore } from '../../stores/sessionStore'
 
 const MOCK_ORGANIZATIONS = [
@@ -11,9 +11,10 @@ const MOCK_ORGANIZATIONS = [
 
 export function OrganizationSwitcher() {
   const { activeOrganizationId } = useSessionStore()
+  const switchOrganization = useSwitchOrganization()
 
-  async function handleChange(e: SelectChangeEvent<string>) {
-    await authService.switchOrganization(e.target.value)
+  function handleChange(e: SelectChangeEvent<string>) {
+    switchOrganization.mutate(e.target.value)
   }
 
   return (

src/components/auth/SessionExpired.tsx

@@ -51,7 +51,7 @@ export function SessionExpired() {
       <Button
         variant="contained"
         onClick={handleRelogin}
-        sx={{ mt: 1, bgcolor: '#1e3a5f', textTransform: 'none' }}
+        sx={{ mt: 1, bgcolor: '#152642', textTransform: 'none' }}
       >
         Erneut anmelden
       </Button>

src/components/badges/ResultTypeBadge.tsx

@@ -1,5 +1,5 @@
 import { Chip } from '@mui/material'
-import { ShieldCheck, Globe, Building2, Sparkles } from 'lucide-react'
+import { ShieldCheck, Building2, Sparkles } from 'lucide-react'
 import type { ResultType } from '../../domain/enums'
 import { DS_COLORS } from '../../lib/ds'
 import { RESULT_TYPE_LABELS } from '../../lib/constants'
@@ -11,7 +11,6 @@ interface ResultTypeBadgeProps {
 
 const ICONS: Record<ResultType, React.ElementType> = {
   VERIFIED_PORTFOLIO:  ShieldCheck,
-  EXTERNAL_MARKET:     Globe,
   MAISON_WORK:         Building2,
   FUTURE_AVAILABILITY: Sparkles,
 }

src/components/cards/MetricCard.tsx

@@ -17,7 +17,7 @@ interface MetricCardProps {
   sx?: SxProps<Theme>
 }
 
-export function MetricCard({ label, value, delta, icon, color = '#1e3a5f', sx }: MetricCardProps) {
+export function MetricCard({ label, value, delta, icon, color = '#152642', sx }: MetricCardProps) {
   return (
     <Card sx={{ p: 2.5, ...sx }}>
       <Box sx={{ display: 'flex', alignItems: 'flex-start', justifyContent: 'space-between' }}>

src/components/cards/SourceTypeBadge.tsx

@@ -9,8 +9,7 @@ interface SourceTypeBadgeProps {
 }
 
 const CONFIG: Record<string, { bg: string; color: string; Icon: React.ElementType }> = {
-  VERIFIED_PORTFOLIO:  { bg: 'rgba(30,58,95,0.1)',   color: '#1e3a5f', Icon: ShieldCheck },
-  EXTERNAL_MARKET:     { bg: 'rgba(217,119,6,0.1)',  color: '#b45309', Icon: Globe },
+  VERIFIED_PORTFOLIO:  { bg: 'rgba(30,58,95,0.1)',   color: '#152642', Icon: ShieldCheck },
   MAISON_WORK:         { bg: 'rgba(3,105,161,0.1)',  color: '#0369a1', Icon: Building2 },
   FUTURE_AVAILABILITY: { bg: 'rgba(124,58,237,0.1)', color: '#6d28d9', Icon: Sparkles },
 }

src/components/compare/AICompareSummary.tsx

@@ -2,6 +2,7 @@ import { useState } from 'react'
 import { Alert, Box, Chip, CircularProgress, Collapse, Typography } from '@mui/material'
 import { ChevronDown, ChevronUp, Trophy, TrendingDown, ShieldCheck, AlertTriangle, Info, ArrowRight, CheckCircle2, XCircle, Star } from 'lucide-react'
 import type { ComparisonSummary } from '../../services/aiService'
+import { DS_TEXT, DS_BG, DS_BORDER, DS_SURFACE } from '../../lib/ds'
 
 interface Props {
   summary?: ComparisonSummary
@@ -12,7 +13,7 @@ export function AICompareSummary({ summary, isLoading }: Props) {
   const [open, setOpen] = useState(true)
 
   return (
-    <Box sx={{ mb: 2, border: '1px solid #e2e8f0', borderRadius: 1, overflow: 'hidden' }}>
+    <Box sx={{ mb: 2, border: `1px solid ${DS_BORDER.default}`, borderRadius: 1, overflow: 'hidden' }}>
       <Box
         onClick={() => setOpen(v => !v)}
         sx={{
@@ -21,14 +22,14 @@ export function AICompareSummary({ summary, isLoading }: Props) {
           justifyContent: 'space-between',
           px: 2,
           py: 1.25,
-          bgcolor: '#f8fafc',
+          bgcolor: DS_SURFACE.neutral.bg,
           cursor: 'pointer',
-          '&:hover': { bgcolor: '#f1f5f9' },
+          '&:hover': { bgcolor: DS_BG.subtle },
         }}
       >
         <Box sx={{ display: 'flex', alignItems: 'center', gap: 1 }}>
           <Typography variant="subtitle2" sx={{ fontWeight: 700 }}>AI Vergleichs-Zusammenfassung</Typography>
-          <Chip label="Beta" size="small" sx={{ fontSize: 10, bgcolor: '#ede9fe', color: '#6d28d9' }} />
+          <Chip label="Beta" size="small" sx={{ fontSize: 10, bgcolor: DS_SURFACE.purple.bg, color: DS_TEXT.signal }} />
         </Box>
         {open ? <ChevronUp size={16} /> : <ChevronDown size={16} />}
       </Box>
@@ -45,15 +46,15 @@ export function AICompareSummary({ summary, isLoading }: Props) {
           {!isLoading && summary && (
             <Box sx={{ display: 'flex', flexDirection: 'column', gap: 1.5 }}>
               {/* Overall assessment */}
-              <Box sx={{ bgcolor: '#f0f9ff', border: '1px solid #bae6fd', borderRadius: 1, p: 1.5 }}>
-                <Typography variant="body2" sx={{ color: '#0c4a6e', lineHeight: 1.5 }}>{summary.overallAssessment}</Typography>
+              <Box sx={{ bgcolor: DS_SURFACE.info.bg, border: `1px solid ${DS_SURFACE.info.border}`, borderRadius: 1, p: 1.5 }}>
+                <Typography variant="body2" sx={{ color: DS_TEXT.infoDark, lineHeight: 1.5 }}>{summary.overallAssessment}</Typography>
               </Box>
 
               {/* Strongest option */}
               <Box sx={{ display: 'flex', gap: 1, alignItems: 'flex-start' }}>
-                <Trophy size={16} color="#1a7a4a" style={{ flexShrink: 0, marginTop: 2 }} />
+                <Trophy size={16} color={DS_TEXT.success} style={{ flexShrink: 0, marginTop: 2 }} />
                 <Box>
-                  <Typography variant="caption" sx={{ fontWeight: 600, color: '#64748b', display: 'block' }}>Stärkstes Match</Typography>
+                  <Typography variant="caption" sx={{ fontWeight: 600, color: DS_TEXT.muted, display: 'block' }}>Stärkstes Match</Typography>
                   <Typography variant="body2" sx={{ fontWeight: 600 }}>{summary.strongestOption.label}</Typography>
                   <Typography variant="caption" color="text.secondary">{summary.strongestOption.reason}</Typography>
                 </Box>
@@ -62,9 +63,9 @@ export function AICompareSummary({ summary, isLoading }: Props) {
               {/* Best value */}
               {summary.bestValue && (
                 <Box sx={{ display: 'flex', gap: 1, alignItems: 'flex-start' }}>
-                  <TrendingDown size={16} color="#1e3a5f" style={{ flexShrink: 0, marginTop: 2 }} />
+                  <TrendingDown size={16} color={DS_TEXT.brand} style={{ flexShrink: 0, marginTop: 2 }} />
                   <Box>
-                    <Typography variant="caption" sx={{ fontWeight: 600, color: '#64748b', display: 'block' }}>Bestes Preis-Leistungs-Verhältnis</Typography>
+                    <Typography variant="caption" sx={{ fontWeight: 600, color: DS_TEXT.muted, display: 'block' }}>Bestes Preis-Leistungs-Verhältnis</Typography>
                     <Typography variant="body2" sx={{ fontWeight: 600 }}>{summary.bestValue.label}</Typography>
                     <Typography variant="caption" color="text.secondary">{summary.bestValue.reason}</Typography>
                   </Box>
@@ -75,7 +76,7 @@ export function AICompareSummary({ summary, isLoading }: Props) {
               <Box sx={{ display: 'flex', gap: 1, alignItems: 'flex-start' }}>
                 <ShieldCheck size={16} color="#0891b2" style={{ flexShrink: 0, marginTop: 2 }} />
                 <Box>
-                  <Typography variant="caption" sx={{ fontWeight: 600, color: '#64748b', display: 'block' }}>Höchste Datenkonfidenz</Typography>
+                  <Typography variant="caption" sx={{ fontWeight: 600, color: DS_TEXT.muted, display: 'block' }}>Höchste Datenkonfidenz</Typography>
                   <Typography variant="body2" sx={{ fontWeight: 600 }}>
                     {summary.highestConfidence.label}
                     <Typography component="span" variant="caption" color="text.secondary" sx={{ ml: 0.5 }}>
@@ -88,9 +89,9 @@ export function AICompareSummary({ summary, isLoading }: Props) {
               {/* Tradeoffs */}
               {summary.biggestTradeoffs.length > 0 && (
                 <Box sx={{ display: 'flex', gap: 1, alignItems: 'flex-start' }}>
-                  <AlertTriangle size={16} color="#d97706" style={{ flexShrink: 0, marginTop: 2 }} />
+                  <AlertTriangle size={16} color={DS_TEXT.warning} style={{ flexShrink: 0, marginTop: 2 }} />
                   <Box>
-                    <Typography variant="caption" sx={{ fontWeight: 600, color: '#64748b', display: 'block' }}>Wichtigste Abwägungen</Typography>
+                    <Typography variant="caption" sx={{ fontWeight: 600, color: DS_TEXT.muted, display: 'block' }}>Wichtigste Abwägungen</Typography>
                     {summary.biggestTradeoffs.map((t, i) => (
                       <Typography key={i} variant="caption" color="text.secondary" sx={{ display: 'block' }}>· {t}</Typography>
                     ))}
@@ -101,9 +102,9 @@ export function AICompareSummary({ summary, isLoading }: Props) {
               {/* Missing data */}
               {summary.missingDataWarnings.length > 0 && (
                 <Box sx={{ display: 'flex', gap: 1, alignItems: 'flex-start' }}>
-                  <Info size={16} color="#c0392b" style={{ flexShrink: 0, marginTop: 2 }} />
+                  <Info size={16} color={DS_TEXT.error} style={{ flexShrink: 0, marginTop: 2 }} />
                   <Box>
-                    <Typography variant="caption" sx={{ fontWeight: 600, color: '#64748b', display: 'block' }}>Fehlende Informationen</Typography>
+                    <Typography variant="caption" sx={{ fontWeight: 600, color: DS_TEXT.muted, display: 'block' }}>Fehlende Informationen</Typography>
                     {summary.missingDataWarnings.map((w, i) => (
                       <Typography key={i} variant="caption" color="error" sx={{ display: 'block' }}>· {w}</Typography>
                     ))}
@@ -114,14 +115,14 @@ export function AICompareSummary({ summary, isLoading }: Props) {
               {/* Per-property assessment */}
               {summary.perPropertyAssessment.length > 0 && (
                 <Box>
-                  <Typography variant="caption" sx={{ fontWeight: 600, color: '#64748b', display: 'block', mb: 0.75 }}>Objektbewertung</Typography>
+                  <Typography variant="caption" sx={{ fontWeight: 600, color: DS_TEXT.muted, display: 'block', mb: 0.75 }}>Objektbewertung</Typography>
                   <Box sx={{ display: 'flex', gap: 1.5, flexWrap: 'wrap' }}>
                     {summary.perPropertyAssessment.map(prop => (
                       <Box
                         key={prop.matchId}
                         sx={{
                           flex: '1 1 200px',
-                          border: '1px solid #e2e8f0',
+                          border: `1px solid ${DS_BORDER.default}`,
                           borderRadius: 1,
                           p: 1.25,
                           display: 'flex',
@@ -129,13 +130,13 @@ export function AICompareSummary({ summary, isLoading }: Props) {
                           gap: 0.75,
                         }}
                       >
-                        <Typography variant="body2" sx={{ fontWeight: 700, color: '#1e3a5f' }}>{prop.label}</Typography>
+                        <Typography variant="body2" sx={{ fontWeight: 700, color: DS_TEXT.brand }}>{prop.label}</Typography>
 
                         {/* Strengths */}
                         <Box>
                           {prop.strengths.map((s, i) => (
                             <Box key={i} sx={{ display: 'flex', alignItems: 'flex-start', gap: 0.5, mb: 0.25 }}>
-                              <CheckCircle2 size={12} color="#1a7a4a" style={{ flexShrink: 0, marginTop: 2 }} />
+                              <CheckCircle2 size={12} color={DS_TEXT.success} style={{ flexShrink: 0, marginTop: 2 }} />
                               <Typography variant="caption" color="text.secondary" sx={{ lineHeight: 1.4 }}>{s}</Typography>
                             </Box>
                           ))}
@@ -145,7 +146,7 @@ export function AICompareSummary({ summary, isLoading }: Props) {
                         <Box>
                           {prop.weaknesses.map((w, i) => (
                             <Box key={i} sx={{ display: 'flex', alignItems: 'flex-start', gap: 0.5, mb: 0.25 }}>
-                              <XCircle size={12} color="#dc2626" style={{ flexShrink: 0, marginTop: 2 }} />
+                              <XCircle size={12} color={DS_TEXT.danger} style={{ flexShrink: 0, marginTop: 2 }} />
                               <Typography variant="caption" color="text.secondary" sx={{ lineHeight: 1.4 }}>{w}</Typography>
                             </Box>
                           ))}
@@ -153,8 +154,8 @@ export function AICompareSummary({ summary, isLoading }: Props) {
 
                         {/* Best for */}
                         <Box sx={{ display: 'flex', alignItems: 'flex-start', gap: 0.5 }}>
-                          <Star size={12} color="#d97706" style={{ flexShrink: 0, marginTop: 2 }} />
-                          <Typography variant="caption" sx={{ color: '#92400e', lineHeight: 1.4 }}>
+                          <Star size={12} color={DS_TEXT.warning} style={{ flexShrink: 0, marginTop: 2 }} />
+                          <Typography variant="caption" sx={{ color: DS_TEXT.warningDark, lineHeight: 1.4 }}>
                             <strong>Am besten für:</strong> {prop.bestFor}
                           </Typography>
                         </Box>
@@ -162,7 +163,7 @@ export function AICompareSummary({ summary, isLoading }: Props) {
                         {/* Key risk */}
                         {prop.keyRisk && (
                           <Box sx={{ display: 'flex', alignItems: 'flex-start', gap: 0.5 }}>
-                            <AlertTriangle size={12} color="#d97706" style={{ flexShrink: 0, marginTop: 2 }} />
+                            <AlertTriangle size={12} color={DS_TEXT.warning} style={{ flexShrink: 0, marginTop: 2 }} />
                             <Typography variant="caption" color="text.secondary" sx={{ lineHeight: 1.4 }}>{prop.keyRisk}</Typography>
                           </Box>
                         )}
@@ -173,10 +174,10 @@ export function AICompareSummary({ summary, isLoading }: Props) {
               )}
 
               {/* Recommendation */}
-              <Box sx={{ display: 'flex', gap: 1, alignItems: 'flex-start', pt: 0.5, borderTop: '1px solid #f1f5f9', mt: 0.5 }}>
-                <ArrowRight size={16} color="#1e3a5f" style={{ flexShrink: 0, marginTop: 2 }} />
+              <Box sx={{ display: 'flex', gap: 1, alignItems: 'flex-start', pt: 0.5, borderTop: `1px solid ${DS_BORDER.muted}`, mt: 0.5 }}>
+                <ArrowRight size={16} color={DS_TEXT.brand} style={{ flexShrink: 0, marginTop: 2 }} />
                 <Box>
-                  <Typography variant="caption" sx={{ fontWeight: 600, color: '#64748b', display: 'block' }}>Empfehlung</Typography>
+                  <Typography variant="caption" sx={{ fontWeight: 600, color: DS_TEXT.muted, display: 'block' }}>Empfehlung</Typography>
                   <Typography variant="body2">{summary.recommendation}</Typography>
                 </Box>
               </Box>

src/components/compare/CompareColumnHeader.tsx

@@ -1,18 +1,12 @@
 import { Box, Button, Chip, IconButton, Tooltip, Typography } from '@mui/material'
 import { X, AlertTriangle, BookmarkCheck, ExternalLink, Kanban } from 'lucide-react'
 import { useNavigate } from 'react-router'
+import { usePipelineItems } from '../../hooks/usePipeline'
 import { usePipelineStore } from '../../stores/pipelineStore'
+import { RESULT_TYPE_META } from '../../lib/ds'
+import { matchScoreHex } from '../../lib/utils'
 import type { UnifiedMatchResult } from '../../domain/unifiedResult'
 
-const TYPE_META: Record<string, { label: string; color: string }> = {
-  VERIFIED_PORTFOLIO:  { label: 'Plattform',      color: '#1e3a5f' },
-  EXTERNAL_MARKET:     { label: 'Plattform',      color: '#1e3a5f' },
-  MAISON_WORK:         { label: 'Maison Work',    color: '#0369a1' },
-  FUTURE_AVAILABILITY: { label: 'Zukunftssignal', color: '#7c3aed' },
-}
-
-const SCORE_COLOR = (s: number) => s >= 78 ? '#1a7a4a' : s >= 52 ? '#d97706' : '#c0392b'
-
 interface Props {
   item: UnifiedMatchResult
   onRemove: () => void
@@ -20,9 +14,10 @@ interface Props {
 
 export function CompareColumnHeader({ item, onRemove }: Props) {
   const navigate = useNavigate()
-  const { items: pipelineItems, openSavedDialog } = usePipelineStore()
+  const { data: pipelineItems = [] } = usePipelineItems()
+  const { openSavedDialog } = usePipelineStore()
 
-  const meta = TYPE_META[item.resultType] ?? { label: item.resultType, color: '#64748b' }
+  const meta = RESULT_TYPE_META[item.resultType] ?? { label: item.resultType, color: '#64748b' }
   const prop = item.resultType !== 'FUTURE_AVAILABILITY' ? (item as any).property : null
   const sig  = item.resultType === 'FUTURE_AVAILABILITY' ? (item as any).signal  : null
 
@@ -48,7 +43,7 @@ export function CompareColumnHeader({ item, onRemove }: Props) {
       propertyId: prop?.id,
       propertyAddress: prop ? `${title}, ${subtitle}${district ? `, ${district}` : ''}` : undefined,
       areaLabel: prop?.areaSqm ? `${prop.areaSqm.toLocaleString('de-CH')} m²` : undefined,
-      rentLabel: prop?.rentPricePerSqm ? `CHF ${prop.rentPricePerSqm}/m²` : undefined,
+      rentLabel: prop?.rentPricePerSqm ? `CHF ${prop.rentPricePerSqm}/m²/Jahr` : undefined,
       availabilityLabel: prop?.availabilityDate ?? undefined,
     })
   }
@@ -72,7 +67,7 @@ export function CompareColumnHeader({ item, onRemove }: Props) {
         sx={{
           fontWeight: 700, lineHeight: 1.3, mb: 0.25,
           cursor: 'pointer',
-          '&:hover': { color: '#1e3a5f' },
+          '&:hover': { color: '#152642' },
         }}
         onClick={() => navigate(`/demand/results/${item.matchId}`)}
       >
@@ -84,7 +79,7 @@ export function CompareColumnHeader({ item, onRemove }: Props) {
 
       {/* Row 3: score */}
       <Box sx={{ display: 'flex', alignItems: 'baseline', gap: 0.5, mb: 1 }}>
-        <Typography variant="h4" sx={{ fontWeight: 800, color: SCORE_COLOR(item.matchScore), lineHeight: 1 }}>
+        <Typography variant="h4" sx={{ fontWeight: 800, color: matchScoreHex(item.matchScore), lineHeight: 1 }}>
           {item.matchScore}
         </Typography>
         <Typography variant="caption" color="text.secondary">/100</Typography>
@@ -150,7 +145,7 @@ export function CompareColumnHeader({ item, onRemove }: Props) {
             variant="contained"
             startIcon={<Kanban size={12} />}
             onClick={handleSave}
-            sx={{ flex: 1, textTransform: 'none', fontSize: '0.72rem', py: 0.5, bgcolor: '#1e3a5f', '&:hover': { bgcolor: '#162d4a' } }}
+            sx={{ flex: 1, textTransform: 'none', fontSize: '0.72rem', py: 0.5 }}
           >
             Merken
           </Button>

src/components/compare/CompareCriteriaCard.tsx

@@ -38,7 +38,7 @@ export function CompareCriteriaCard({ compareItems, relevantCriteria, overallWin
               <TableCell sx={{ ...LABEL_SX, bgcolor: '#f8fafc', fontSize: 11 }}>Kriterium</TableCell>
               {compareItems.map(item => (
                 <TableCell key={item.matchId} sx={{ ...DATA_SX, bgcolor: '#f8fafc' }}>
-                  <Typography variant="caption" sx={{ fontWeight: 700, color: '#1e3a5f' }} noWrap>
+                  <Typography variant="caption" sx={{ fontWeight: 700, color: '#152642' }} noWrap>
                     {getTitle(item)}
                   </Typography>
                 </TableCell>

src/components/compare/CompareEmptyState.tsx

@@ -15,7 +15,7 @@ export function CompareEmptyState() {
           Fügen Sie 2–4 Ergebnisse aus dem Feed, Match Detail oder Match Center zum Vergleich hinzu.
         </Typography>
         <Button variant="contained" size="small" onClick={() => navigate('/demand/results')}
-          sx={{ bgcolor: '#1e3a5f', '&:hover': { bgcolor: '#162d4a' } }}>
+          sx={{ bgcolor: '#152642', '&:hover': { bgcolor: '#162d4a' } }}>
           Zu den Suchergebnissen
         </Button>
       </Box>

src/components/compare/CompareMetricRow.tsx

@@ -0,0 +1,24 @@
+import { memo } from 'react'
+import type { ReactNode } from 'react'
+import { TableCell, TableRow } from '@mui/material'
+import { LABEL_SX, DATA_SX } from './compareUtils'
+
+// ── Props ─────────────────────────────────────────────────────────────────────
+
+export interface CompareMetricRowProps {
+  label: string
+  cells: ReactNode[]
+}
+
+// ── Component ─────────────────────────────────────────────────────────────────
+
+export const CompareMetricRow = memo(function CompareMetricRow({ label, cells }: CompareMetricRowProps) {
+  return (
+    <TableRow hover>
+      <TableCell sx={LABEL_SX}>{label}</TableCell>
+      {cells.map((cell, i) => (
+        <TableCell key={i} sx={DATA_SX}>{cell}</TableCell>
+      ))}
+    </TableRow>
+  )
+})

src/components/compare/CompareTableBody.tsx

@@ -0,0 +1,394 @@
+import type { ReactNode } from 'react'
+import {
+  Box,
+  Chip,
+  TableBody,
+  TableCell,
+  TableRow,
+  Typography,
+} from '@mui/material'
+import { AlertOctagon, AlertTriangle, CheckCircle2, Trophy, XCircle, Zap } from 'lucide-react'
+import {
+  HARD_CRITERIA,
+  RISK_LEVEL_ORDER,
+  getProp,
+  getSig,
+  LABEL_SX,
+  DATA_SX,
+  scoreBar,
+} from './compareUtils'
+import { CompareCell, MissingDataCell } from './index'
+import { RESULT_TYPE_META, DS_COLORS } from '../../lib/ds'
+import { matchScoreHex } from '../../lib/utils'
+import { calcFitOutInvestment } from '../../lib/fitOutUtils'
+import { FITOUT_AMORTIZATION_YEARS } from '../../lib/constants'
+import type { UnifiedMatchResult } from '../../domain/unifiedResult'
+
+// ── Local helper ──────────────────────────────────────────────────────────────
+
+function row(label: string, cells: ReactNode[]) {
+  return (
+    <TableRow hover key={label}>
+      <TableCell sx={LABEL_SX}>{label}</TableCell>
+      {cells.map((cell, i) => (
+        <TableCell key={i} sx={DATA_SX}>{cell}</TableCell>
+      ))}
+    </TableRow>
+  )
+}
+
+// ── Props ─────────────────────────────────────────────────────────────────────
+
+interface CompareTableBodyProps {
+  compareItems: UnifiedMatchResult[]
+  bestScoreIdx: number
+  worstConfIdx: number
+  worstDQIdx: number
+  missingCriticalCounts: number[]
+  maxMissingCritical: number
+}
+
+// ── Component ─────────────────────────────────────────────────────────────────
+
+export function CompareTableBody({
+  compareItems,
+  bestScoreIdx,
+  worstConfIdx,
+  worstDQIdx,
+  missingCriticalCounts,
+  maxMissingCritical,
+}: CompareTableBodyProps) {
+  return (
+    <TableBody>
+
+      {/* 1. Result Type */}
+      {row('1. Result-Typ', compareItems.map(item => {
+        const m = RESULT_TYPE_META[item.resultType] ?? { label: item.resultType, color: '#64748b' }
+        return <Chip label={m.label} size="small" sx={{ bgcolor: m.color, color: 'white', fontWeight: 600, fontSize: 11 }} />
+      }))}
+
+      {/* 2. Source / Provenance */}
+      {row('2. Quelle / Provenienz', compareItems.map(item => {
+        const prop = getProp(item)
+        const sig  = getSig(item)
+        const label = prop?.sourceLabel ?? sig?.source?.type ?? null
+        return label
+          ? <Typography variant="body2">{label}</Typography>
+          : <MissingDataCell reason="Quellenangabe fehlt — Datenverlässlichkeit unklar" />
+      }))}
+
+      {/* 3. Match Score */}
+      {row('3. Match Score', compareItems.map((item, idx) => (
+        <CompareCell
+          highlight={idx === bestScoreIdx ? 'best' : 'none'}
+          icon={idx === bestScoreIdx ? <Trophy size={14} color="#1a7a4a" /> : undefined}
+          iconTooltip="Höchster Match Score"
+        >
+          <Box sx={{ display: 'flex', alignItems: 'baseline', gap: 0.5 }}>
+            <Typography variant="h5" sx={{ fontWeight: 800, color: matchScoreHex(item.matchScore), lineHeight: 1 }}>
+              {item.matchScore}
+            </Typography>
+            <Typography variant="caption" color="text.secondary">/100</Typography>
+          </Box>
+        </CompareCell>
+      )))}
+
+      {/* 4. Confidence Score */}
+      {row('4. Konfidenz', compareItems.map((item, idx) => (
+        <CompareCell
+          highlight={idx === worstConfIdx && item.match.confidenceLevel < 0.6 ? 'worst' : 'none'}
+          icon={idx === worstConfIdx && item.match.confidenceLevel < 0.6 ? <AlertTriangle size={14} color="#d97706" /> : undefined}
+          iconTooltip="Niedrigste Konfidenz"
+        >
+          {scoreBar(item.match.confidenceLevel)}
+        </CompareCell>
+      )))}
+
+      {/* 5. Data Quality Score */}
+      {row('5. Datenqualität', compareItems.map((item, idx) => {
+        const prop = getProp(item)
+        const dq = prop?.dataQuality.score ?? null
+        if (dq === null) return <MissingDataCell reason="Keine Datenqualitätsinformation verfügbar" />
+        return (
+          <CompareCell
+            highlight={idx === worstDQIdx && dq < 0.6 ? 'worst' : 'none'}
+            icon={idx === worstDQIdx && dq < 0.6 ? <AlertTriangle size={14} color="#d97706" /> : undefined}
+            iconTooltip="Niedrigste Datenqualität"
+          >
+            {scoreBar(dq)}
+          </CompareCell>
+        )
+      }))}
+
+      {/* 6. Asset Type */}
+      {row('6. Nutzungstyp', compareItems.map(item => {
+        const prop = getProp(item)
+        const label = prop?.assetType ?? null
+        return label
+          ? <Chip label={label} size="small" variant="outlined" />
+          : <MissingDataCell />
+      }))}
+
+      {/* 7. Location */}
+      {row('7. Standort', compareItems.map(item => {
+        const prop = getProp(item)
+        const sig  = getSig(item)
+        const city = prop?.location?.city ?? sig?.locationHint ?? null
+        const district = prop?.location?.district
+        return city
+          ? <Typography variant="body2">{city}{district ? `, ${district}` : ''}</Typography>
+          : <MissingDataCell />
+      }))}
+
+      {/* 8. Area */}
+      {row('8. Fläche', compareItems.map(item => {
+        const prop = getProp(item)
+        const sig  = getSig(item)
+        const area = prop?.areaSqm ?? sig?.areaSqmEstimate ?? null
+        return area !== null
+          ? <Typography variant="body2">{area.toLocaleString('de-CH')} m²{sig ? ' (Schätzung)' : ''}</Typography>
+          : <MissingDataCell />
+      }))}
+
+      {/* 9. Rent / Budget Fit — full cost breakdown incl. amortised fit-out */}
+      {row('9. Kosten / Budget', compareItems.map(item => {
+        const prop = getProp(item)
+        if (!prop) return <MissingDataCell reason="Mietpreis nur für bestätigte Objekte verfügbar" />
+
+        const FIT_OUT_LABELS: Record<string, string> = {
+          SHELL: 'Rohbau', BASIC: 'Grundausbau', FULL: 'Vollausbau', PREMIUM: 'Premium-Ausbau',
+        }
+        const READY_TO_MOVE_IN = new Set(['FULL', 'PREMIUM'])
+
+        const monthlyRent = prop.totalRentMonthly
+          ?? Math.round(prop.rentPricePerSqm * prop.areaSqm / 12)
+        // ancillaryCosts stored as CHF/m²/Monat
+        const monthlyNebenkosten = prop.ancillaryCosts != null
+          ? Math.round(prop.ancillaryCosts * prop.areaSqm)
+          : null
+        const fitOut = prop.hardFacts?.fitOut
+        const fitOutLabel = fitOut ? (FIT_OUT_LABELS[fitOut] ?? fitOut) : null
+        const mabPerSqm = prop.hardFacts?.mieterausbaubeitragPerSqm ?? 0
+
+        // Amortised fit-out monthly cost (mid-range estimate)
+        let fitOutMonthly = 0
+        let fitOutMonthlyLabel: string | null = null
+        if (fitOut && !READY_TO_MOVE_IN.has(fitOut)) {
+          const inv = calcFitOutInvestment(fitOut, prop.areaSqm, mabPerSqm, 0)
+          if (inv && !inv.isFullyCovered) {
+            const months = FITOUT_AMORTIZATION_YEARS * 12
+            const midMin = Math.round(inv.netTotal.min / months)
+            const midMax = Math.round(inv.netTotal.max / months)
+            fitOutMonthly = Math.round((midMin + midMax) / 2)
+            fitOutMonthlyLabel = midMin === midMax
+              ? `${midMin.toLocaleString('de-CH')}`
+              : `${midMin.toLocaleString('de-CH')}–${midMax.toLocaleString('de-CH')}`
+          }
+        }
+
+        const totalMonthly = monthlyRent
+          + (monthlyNebenkosten ?? 0)
+          + fitOutMonthly
+
+        return (
+          <Box sx={{ display: 'flex', flexDirection: 'column', gap: 0.4 }}>
+            <Typography variant="body2" sx={{ fontWeight: 700 }}>
+              CHF {prop.rentPricePerSqm}/m²/Jahr
+            </Typography>
+            <Typography variant="caption" color="text.secondary">
+              {monthlyRent.toLocaleString('de-CH')} CHF/Monat (Miete)
+            </Typography>
+            {monthlyNebenkosten != null && (
+              <Typography variant="caption" color="text.secondary">
+                + {monthlyNebenkosten.toLocaleString('de-CH')} CHF/Monat (NK)
+              </Typography>
+            )}
+            {fitOutMonthlyLabel && (
+              <Typography variant="caption" color="text.secondary">
+                + {fitOutMonthlyLabel} CHF/Monat (Ausbau ÷ {FITOUT_AMORTIZATION_YEARS} J.)
+              </Typography>
+            )}
+            <Typography variant="body2" sx={{ fontWeight: 700, color: '#152642', borderTop: '1px solid #e2e8f0', pt: 0.5, mt: 0.25 }}>
+              = {totalMonthly.toLocaleString('de-CH')} CHF/Monat
+            </Typography>
+            {fitOutLabel && (
+              <Typography variant="caption" sx={{ color: '#64748b', mt: 0.25 }}>
+                Ausbau: {fitOutLabel}{READY_TO_MOVE_IN.has(fitOut ?? '') ? ' (bezugsfertig)' : ''}
+              </Typography>
+            )}
+          </Box>
+        )
+      }))}
+
+      {/* 10. Availability / Time Horizon */}
+      {row('10. Verfügbarkeit', compareItems.map(item => {
+        const prop = getProp(item)
+        const sig  = getSig(item)
+        if (prop) return <Typography variant="body2">{prop.availabilityDate}</Typography>
+        if (sig) return (
+          <CompareCell highlight="future" icon={<Zap size={14} color={DS_COLORS.futureCard.controlled.accent} />} iconTooltip="Probabilistisches Signal — keine bestätigte Verfügbarkeit">
+            <Typography variant="body2">~{sig.timeHorizonMonths} Monate</Typography>
+            <Typography variant="caption" sx={{ color: DS_COLORS.futureCard.controlled.accent }}>
+              {Math.round(sig.probability * 100)}% Wahrscheinlichkeit
+            </Typography>
+          </CompareCell>
+        )
+        return <MissingDataCell />
+      }))}
+
+      {/* 11. Hard Criteria Fit */}
+      {row('11. Hardkriterien', compareItems.map(item => {
+        const hardMatches = item.match.positiveFactors.filter(f => HARD_CRITERIA.has(f.criterion))
+        const total = 4
+        const count = hardMatches.length
+        const color = count >= 3 ? '#1a7a4a' : count >= 2 ? '#d97706' : '#c0392b'
+        return (
+          <Box>
+            <Typography variant="body2" sx={{ fontWeight: 700, color }}>
+              {count}/{total} erfüllt
+            </Typography>
+            <Box sx={{ display: 'flex', flexWrap: 'wrap', gap: 0.5, mt: 0.5 }}>
+              {hardMatches.map(f => (
+                <Chip key={f.criterion} label={f.criterion} size="small"
+                  icon={<CheckCircle2 size={10} />}
+                  sx={{ fontSize: 10, bgcolor: '#f0fdf4', color: '#166534', '& .MuiChip-icon': { color: '#1a7a4a' } }} />
+              ))}
+            </Box>
+          </Box>
+        )
+      }))}
+
+      {/* 12. Top Soft Factors */}
+      {row('12. Soft Factors', compareItems.map(item => {
+        const softFactors = item.match.positiveFactors
+          .filter(f => !HARD_CRITERIA.has(f.criterion))
+          .slice(0, 3)
+        if (softFactors.length === 0) return <MissingDataCell />
+        return (
+          <Box sx={{ display: 'flex', flexWrap: 'wrap', gap: 0.5 }}>
+            {softFactors.map(f => (
+              <Chip key={f.criterion} label={f.criterion} size="small"
+                sx={{ fontSize: 10, bgcolor: '#eff6ff', color: '#1e40af' }} />
+            ))}
+          </Box>
+        )
+      }))}
+
+      {/* 13. Main Strengths */}
+      {row('13. Stärken', compareItems.map(item => {
+        const top = item.match.positiveFactors.slice(0, 2)
+        if (top.length === 0) return <MissingDataCell />
+        return (
+          <Box sx={{ display: 'flex', flexDirection: 'column', gap: 0.5 }}>
+            {top.map((f, i) => (
+              <Box key={i} sx={{ display: 'flex', alignItems: 'flex-start', gap: 0.5 }}>
+                <CheckCircle2 size={13} color="#1a7a4a" style={{ flexShrink: 0, marginTop: 2 }} />
+                <Typography variant="caption" sx={{ lineHeight: 1.4 }}>{f.explanation}</Typography>
+              </Box>
+            ))}
+          </Box>
+        )
+      }))}
+
+      {/* 14. Main Tradeoffs */}
+      {row('14. Abwägungen', compareItems.map(item => {
+        const tradeoffs = item.match.tradeoffs?.slice(0, 2) ?? []
+        if (tradeoffs.length === 0) return (
+          <Typography variant="body2" color="text.secondary">Keine signifikanten Abwägungen</Typography>
+        )
+        return (
+          <Box sx={{ display: 'flex', flexDirection: 'column', gap: 0.5 }}>
+            {tradeoffs.map((t, i) => (
+              <Box key={i} sx={{ display: 'flex', alignItems: 'flex-start', gap: 0.5 }}>
+                <AlertTriangle size={13} color="#d97706" style={{ flexShrink: 0, marginTop: 2 }} />
+                <Typography variant="caption" sx={{ lineHeight: 1.4 }}>{t.criterion}: {t.concern}</Typography>
+              </Box>
+            ))}
+          </Box>
+        )
+      }))}
+
+      {/* 15. Main Risks */}
+      {row('15. Risiken', compareItems.map(item => {
+        const risks = [...(item.match.risks ?? [])].sort(
+          (a, b) => (RISK_LEVEL_ORDER[a.level] ?? 4) - (RISK_LEVEL_ORDER[b.level] ?? 4)
+        ).slice(0, 2)
+        if (risks.length === 0) return (
+          <Typography variant="body2" color="text.secondary">Keine identifizierten Risiken</Typography>
+        )
+        return (
+          <Box sx={{ display: 'flex', flexDirection: 'column', gap: 0.5 }}>
+            {risks.map((r, i) => (
+              <Box key={i} sx={{ display: 'flex', alignItems: 'flex-start', gap: 0.5 }}>
+                <XCircle size={13} color={r.level === 'CRITICAL' || r.level === 'HIGH' ? '#c0392b' : '#d97706'} style={{ flexShrink: 0, marginTop: 2 }} />
+                <Typography variant="caption" sx={{ lineHeight: 1.4 }}>{r.description}</Typography>
+              </Box>
+            ))}
+          </Box>
+        )
+      }))}
+
+      {/* 16. Missing Data */}
+      {row('16. Fehlende Daten', compareItems.map((item, idx) => {
+        const total    = item.match.missingData?.length ?? 0
+        const critical = missingCriticalCounts[idx]
+        if (total === 0) return (
+          <Box sx={{ display: 'flex', alignItems: 'center', gap: 0.5 }}>
+            <CheckCircle2 size={14} color="#1a7a4a" />
+            <Typography variant="body2" sx={{ color: '#1a7a4a' }}>Vollständig</Typography>
+          </Box>
+        )
+        return (
+          <CompareCell
+            highlight={critical > 0 && critical === maxMissingCritical ? 'critical' : critical > 0 ? 'worst' : 'none'}
+            icon={critical > 0 ? <AlertOctagon size={14} color="#c0392b" /> : <AlertTriangle size={14} color="#d97706" />}
+            iconTooltip={critical > 0 ? 'Kritische Pflichtfelder fehlen' : 'Optionale Felder fehlen'}
+          >
+            <Typography variant="body2" sx={{ fontWeight: 600 }}>{total} fehlend</Typography>
+            {critical > 0 && (
+              <Typography variant="caption" color="error">{critical} kritisch</Typography>
+            )}
+          </CompareCell>
+        )
+      }))}
+
+      {/* 17. Future Availability Context */}
+      {row('17. Zukunftskontext', compareItems.map(item => {
+        const sig = getSig(item)
+        if (!sig) return (
+          <Typography variant="body2" color="text.secondary" sx={{ fontStyle: 'italic' }}>Nicht anwendbar</Typography>
+        )
+        return (
+          <CompareCell highlight="future" icon={<Zap size={14} color={DS_COLORS.futureCard.controlled.accent} />} iconTooltip="Probabilistisches Zukunftssignal">
+            <Box sx={{ display: 'flex', flexDirection: 'column', gap: 0.25 }}>
+              <Typography variant="caption" sx={{ fontWeight: 600, color: DS_COLORS.futureCard.controlled.accent }}>
+                {Math.round(sig.probability * 100)}% Wahrscheinlichkeit
+              </Typography>
+              <Typography variant="caption" color="text.secondary">
+                Sensitivität: {sig.sensitivityLevel}
+              </Typography>
+              <Typography variant="caption" color="text.secondary" sx={{ fontStyle: 'italic' }}>
+                {sig.disclaimer}
+              </Typography>
+            </Box>
+          </CompareCell>
+        )
+      }))}
+
+      {/* 18. Recommended Next Action */}
+      {row('18. Nächste Aktion', compareItems.map(item => {
+        const action = item.match.nextBestActions?.[0]
+        if (!action) return <MissingDataCell />
+        return (
+          <Box>
+            <Typography variant="body2" sx={{ fontWeight: 600 }}>{action.label}</Typography>
+            {action.description && (
+              <Typography variant="caption" color="text.secondary">{action.description}</Typography>
+            )}
+          </Box>
+        )
+      }))}
+
+    </TableBody>
+  )
+}

src/components/compare/compareUtils.tsx

@@ -2,11 +2,11 @@ import type { ReactNode } from 'react'
 import { Box, LinearProgress, Typography } from '@mui/material'
 import type { WeightingKey } from '../../domain/needBuilder'
 import type { UnifiedMatchResult, VerifiedPortfolioResult, ExternalMarketResult, FutureAvailabilityResult } from '../../domain/unifiedResult'
+import { dataQualityHex } from '../../lib/utils'
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
 export const HARD_CRITERIA = new Set(['area', 'location', 'budget', 'timing'])
-export const SCORE_COLOR = (s: number) => s >= 78 ? '#1a7a4a' : s >= 52 ? '#d97706' : '#c0392b'
 
 export function getProp(item: UnifiedMatchResult) {
   return item.resultType !== 'FUTURE_AVAILABILITY'
@@ -20,13 +20,6 @@ export function getSig(item: UnifiedMatchResult) {
     : null
 }
 
-export const TYPE_META: Record<string, { label: string; color: string }> = {
-  VERIFIED_PORTFOLIO:  { label: 'Plattform',    color: '#1e3a5f' },
-  EXTERNAL_MARKET:     { label: 'Plattform',    color: '#1e3a5f' },
-  MAISON_WORK:         { label: 'Maison Work',  color: '#0369a1' },
-  FUTURE_AVAILABILITY: { label: 'Zukunftssignal', color: '#7c3aed' },
-}
-
 export const RISK_LEVEL_ORDER: Record<string, number> = { CRITICAL: 0, HIGH: 1, MEDIUM: 2, LOW: 3 }
 
 export const CRITERION_ALIASES: Record<WeightingKey, string[]> = {
@@ -78,7 +71,7 @@ export const DATA_SX = {
 // ── Score bar helper ──────────────────────────────────────────────────────────
 
 export function scoreBar(value: number, label?: string): ReactNode {
-  const color = value >= 0.8 ? '#1a7a4a' : value >= 0.6 ? '#d97706' : '#c0392b'
+  const color = dataQualityHex(value)
   return (
     <Box sx={{ display: 'flex', alignItems: 'center', gap: 1 }}>
       <Box sx={{ width: 70 }}>

src/components/compare/index.ts

@@ -3,3 +3,4 @@ export { CompareColumnHeader } from './CompareColumnHeader'
 export { CompareCell, MissingDataCell } from './CompareCell'
 export { AICompareSummary } from './AICompareSummary'
 export { CompareCriteriaCard } from './CompareCriteriaCard'
+export { CompareTableBody } from './CompareTableBody'

src/components/data-quality/DataQualityPanel.tsx

@@ -81,7 +81,7 @@ export function DataQualityPanel({ property }: DataQualityPanelProps) {
           Datenaktualisierung anfragen
         </Button>
         {q.missingCriticalFields.length > 0 && (
-          <Button variant="contained" size="small" sx={{ textTransform: 'none', bgcolor: '#1e3a5f' }}>
+          <Button variant="contained" size="small" sx={{ textTransform: 'none', bgcolor: '#152642' }}>
             Fehlende Felder ergänzen
           </Button>
         )}

src/components/data-quality/DataQualityProgress.tsx

@@ -76,7 +76,7 @@ export function DataQualityProgress({ property, compact = false }: DataQualityPr
               sx={{
                 height: 4,
                 borderRadius: 2,
-                bgcolor: '#e2e8f0',
+                bgcolor: '#e8e7e4',
                 '& .MuiLinearProgress-bar': { bgcolor: d.color },
               }}
             />
@@ -110,7 +110,7 @@ export function DataQualityProgress({ property, compact = false }: DataQualityPr
               sx={{
                 height: 5,
                 borderRadius: 3,
-                bgcolor: '#e2e8f0',
+                bgcolor: '#e8e7e4',
                 '& .MuiLinearProgress-bar': { bgcolor: d.color },
               }}
             />

src/components/data-quality/ProvenancePanel.tsx

@@ -79,7 +79,7 @@ export function ProvenancePanel({ property: p }: ProvenancePanelProps) {
           sx={{
             height: 5,
             borderRadius: 3,
-            bgcolor: '#e2e8f0',
+            bgcolor: '#e8e7e4',
             '& .MuiLinearProgress-bar': { bgcolor: color },
           }}
         />

src/components/demand/AISearchActionBar.tsx

@@ -0,0 +1,63 @@
+import { Alert, Box, Button, CircularProgress, Divider } from '@mui/material'
+import { ArrowRight, Bookmark, Search } from 'lucide-react'
+
+interface Props {
+  canProceed: boolean
+  isSearching: boolean
+  isSavingProfile: boolean
+  onSearch: () => void
+  onSaveProfile: () => void
+}
+
+export function AISearchActionBar({ canProceed, isSearching, isSavingProfile, onSearch, onSaveProfile }: Props) {
+  const isProcessing = isSearching || isSavingProfile
+  return (
+    <>
+      <Box sx={{ display: 'flex', gap: 2, alignItems: 'center' }}>
+        <Button
+          variant="contained"
+          size="large"
+          disabled={!canProceed || isProcessing}
+          onClick={onSearch}
+          endIcon={isSearching ? <CircularProgress size={18} color="inherit" /> : <Search size={18} />}
+          sx={{
+            flex: 1,
+            py: 1.5,
+            bgcolor: '#152642',
+            '&:hover': { bgcolor: '#162d4a' },
+            fontSize: 15,
+            fontWeight: 600,
+            textTransform: 'none',
+          }}
+        >
+          {isSearching ? 'Sucht…' : 'Jetzt suchen'}
+        </Button>
+
+        <Divider orientation="vertical" flexItem sx={{ mx: 0.5 }} />
+
+        <Button
+          variant="outlined"
+          size="large"
+          disabled={!canProceed || isProcessing}
+          onClick={onSaveProfile}
+          startIcon={<Bookmark size={16} />}
+          endIcon={isSavingProfile ? <CircularProgress size={18} color="inherit" /> : <ArrowRight size={18} />}
+          sx={{
+            py: 1.5,
+            fontSize: 15,
+            fontWeight: 500,
+            textTransform: 'none',
+            whiteSpace: 'nowrap',
+          }}
+        >
+          {isSavingProfile ? 'Analysiert…' : 'Als Suchprofil speichern'}
+        </Button>
+      </Box>
+
+      <Alert severity="info" sx={{ mt: -1 }}>
+        <strong>Jetzt suchen</strong> liefert sofortige Ergebnisse.{' '}
+        <strong>Als Suchprofil speichern</strong> legt einen dauerhaften Bedarf an, der automatisch mit neuen Angeboten abgeglichen wird — auch in Zukunft.
+      </Alert>
+    </>
+  )
+}

src/components/demand/AISearchSavePreview.tsx

@@ -0,0 +1,100 @@
+import { Alert, Box, Button, CircularProgress, FormControlLabel, Switch, Typography } from '@mui/material'
+import { Save } from 'lucide-react'
+import { NeedCardPreview } from './NeedCardPreview'
+import type { ParseNeedResult, ParsedNeedCriteria, WeightingKey } from '../../domain/needBuilder'
+
+interface Props {
+  criteria: ParsedNeedCriteria
+  weights: Record<WeightingKey, number>
+  parseResult: ParseNeedResult
+  needTitle: string
+  overallConfidence: number
+  isSaving: boolean
+  isAnonymous: boolean
+  onNeedTitleChange: (t: string) => void
+  onAnonymousChange: (v: boolean) => void
+  onBack: () => void
+  onSave: () => void
+}
+
+export function AISearchSavePreview({
+  criteria,
+  weights,
+  parseResult,
+  needTitle,
+  overallConfidence,
+  isSaving,
+  isAnonymous,
+  onNeedTitleChange,
+  onAnonymousChange,
+  onBack,
+  onSave,
+}: Props) {
+  return (
+    <Box sx={{ maxWidth: 1200, mx: 'auto' }}>
+      <Alert severity="success" sx={{ mb: 3 }}>
+        Dieses Suchprofil wird als aktiver Bedarf gespeichert und erscheint automatisch im Match Center der Verwaltung.
+      </Alert>
+      <NeedCardPreview
+        criteria={criteria}
+        weights={weights}
+        confidenceByField={parseResult.confidenceByField}
+        missingFields={parseResult.missingFields}
+        needTitle={needTitle}
+        onNeedTitleChange={onNeedTitleChange}
+      />
+
+      {/* Anonymity option */}
+      <Box sx={{
+        maxWidth: 720, mx: 'auto', mt: 2,
+        p: 1.5, borderRadius: 1.5, border: '1px solid',
+        borderColor: isAnonymous ? '#7c3aed' : '#e8e7e4',
+        bgcolor: isAnonymous ? '#f5f3ff' : '#f8fafc',
+        transition: 'all 0.15s',
+      }}>
+        <FormControlLabel
+          control={
+            <Switch
+              size="small"
+              checked={isAnonymous}
+              onChange={e => onAnonymousChange(e.target.checked)}
+              sx={{
+                '& .MuiSwitch-switchBase.Mui-checked': { color: '#7c3aed' },
+                '& .MuiSwitch-switchBase.Mui-checked + .MuiSwitch-track': { bgcolor: '#7c3aed' },
+              }}
+            />
+          }
+          label={
+            <Box>
+              <Typography variant="body2" sx={{ fontWeight: 700, color: isAnonymous ? '#6d28d9' : 'text.primary' }}>
+                Anonymes Suchprofil
+              </Typography>
+              <Typography variant="caption" sx={{ color: isAnonymous ? '#7c3aed' : 'text.secondary' }}>
+                Firmenname wird nicht an Vermieter übermittelt — Verwalter sehen nur Branche und Flächenbedarf
+              </Typography>
+            </Box>
+          }
+        />
+      </Box>
+
+      <Box sx={{ maxWidth: 720, mx: 'auto', display: 'flex', justifyContent: 'space-between', mt: 2 }}>
+        <Button variant="outlined" onClick={onBack} disabled={isSaving}>
+          ← Zurück
+        </Button>
+        <Button
+          variant="contained"
+          onClick={onSave}
+          disabled={isSaving}
+          endIcon={isSaving ? <CircularProgress size={16} color="inherit" /> : <Save size={16} />}
+          sx={{ bgcolor: '#152642', '&:hover': { bgcolor: '#162d4a' }, textTransform: 'none' }}
+        >
+          {isSaving
+            ? 'Wird gespeichert…'
+            : overallConfidence < 0.6
+              ? 'Als Entwurf speichern'
+              : 'Suchprofil speichern & Matching starten'}
+        </Button>
+      </Box>
+    </Box>
+  )
+}

src/components/demand/AnfragenInquiryItem.tsx

@@ -1,71 +1,86 @@
 import { Box, Chip, Typography } from '@mui/material'
 import { Kanban } from 'lucide-react'
+import { INQUIRY_STATUS_META, DS_COLORS, DS_TEXT, DS_BG, DS_BORDER } from '../../lib/ds'
 import type { Inquiry } from '../../domain/inquiry'
 
-const STATUS_CONFIG: Record<string, { label: string; color: string; bgColor: string }> = {
-  new:         { label: 'Neu',          color: '#dc2626', bgColor: '#fef2f2' },
-  in_progress: { label: 'Aktiv',        color: '#d97706', bgColor: '#fffbeb' },
-  answered:    { label: 'Beantwortet',  color: '#1a7a4a', bgColor: '#f0fdf4' },
-  archived:    { label: 'Archiviert',   color: '#64748b', bgColor: '#f8fafc' },
-}
-
 interface AnfragenInquiryItemProps {
   inq: Inquiry
   isSelected: boolean
   hasPipeline: boolean
+  perspective?: 'demand' | 'supply'
   onSelect: (id: string) => void
 }
 
-export function AnfragenInquiryItem({ inq, isSelected, hasPipeline, onSelect }: AnfragenInquiryItemProps) {
-  const cfg = STATUS_CONFIG[inq.status ?? 'new']
+export function AnfragenInquiryItem({ inq, isSelected, hasPipeline, perspective = 'supply', onSelect }: AnfragenInquiryItemProps) {
+  const cfg = INQUIRY_STATUS_META[inq.status ?? 'new']
   const displayDate = new Date(inq.updatedAt).toLocaleDateString('de-CH', { day: '2-digit', month: '2-digit' })
   const lastMsg = inq.thread[inq.thread.length - 1]
+  const unreadColor = cfg?.fg ?? DS_TEXT.danger
+
+  const primaryTitle = perspective === 'demand'
+    ? (inq.propertyAddress ?? inq.subject)
+    : inq.tenantName
+
+  const secondaryLine = perspective === 'demand'
+    ? (inq.propertyManagerCompany ?? inq.propertyManagerName ?? '')
+    : (inq.tenantCompany ?? '')
+
+  const lastMsgPrefix = (() => {
+    if (!lastMsg) return ''
+    if (perspective === 'demand') {
+      return lastMsg.senderType === 'tenant'
+        ? 'Sie: '
+        : `${inq.propertyManagerName ?? 'Verwalter'}: `
+    }
+    return lastMsg.senderType === 'tenant' ? 'Sie: ' : `${lastMsg.senderName}: `
+  })()
 
   return (
     <Box onClick={() => onSelect(inq.id)} sx={{
       px: 2, py: 1.5,
-      borderBottom: '1px solid #f1f5f9',
+      borderBottom: `1px solid ${DS_BORDER.muted}`,
       cursor: 'pointer',
-      bgcolor: isSelected ? '#eff6ff' : !inq.isRead ? 'rgba(220,38,38,0.03)' : 'transparent',
-      borderLeft: isSelected ? '3px solid #1e3a5f' : '3px solid transparent',
-      '&:hover': { bgcolor: isSelected ? '#eff6ff' : '#f8fafc' },
+      bgcolor: isSelected ? DS_COLORS.futureCard.signal.headerBg : !inq.isRead ? 'rgba(220,38,38,0.03)' : 'transparent',
+      borderLeft: isSelected ? '3px solid' : '3px solid transparent',
+      borderLeftColor: isSelected ? 'primary.main' : 'transparent',
+      '&:hover': { bgcolor: isSelected ? DS_COLORS.futureCard.signal.headerBg : DS_BG.page },
       transition: 'background-color 0.1s ease',
     }}>
       <Box sx={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', mb: 0.375 }}>
         <Box sx={{ display: 'flex', alignItems: 'center', gap: 0.75, minWidth: 0 }}>
-          {!inq.isRead && <Box sx={{ width: 7, height: 7, borderRadius: '50%', bgcolor: '#dc2626', flexShrink: 0 }} />}
+          {!inq.isRead && <Box sx={{ width: 7, height: 7, borderRadius: '50%', bgcolor: unreadColor, flexShrink: 0 }} />}
           <Typography variant="body2" sx={{ fontWeight: !inq.isRead ? 700 : 500, fontSize: '0.8125rem' }} noWrap>
-            {inq.tenantName}
+            {primaryTitle}
           </Typography>
         </Box>
         <Box sx={{ display: 'flex', alignItems: 'center', gap: 0.5, flexShrink: 0 }}>
           {inq.unreadCount > 0 && (
-            <Box sx={{ width: 18, height: 18, borderRadius: '50%', bgcolor: '#dc2626', display: 'flex', alignItems: 'center', justifyContent: 'center' }}>
+            <Box sx={{ width: 18, height: 18, borderRadius: '50%', bgcolor: unreadColor, display: 'flex', alignItems: 'center', justifyContent: 'center' }}>
               <Typography sx={{ color: 'white', fontSize: '0.6rem', fontWeight: 700 }}>{inq.unreadCount}</Typography>
             </Box>
           )}
           <Typography variant="caption" color="text.secondary" sx={{ fontSize: '0.7rem' }}>{displayDate}</Typography>
         </Box>
       </Box>
-      {inq.tenantCompany && (
+      {secondaryLine && (
         <Typography variant="caption" color="text.secondary" sx={{ display: 'block', fontSize: '0.7rem', mb: 0.25 }} noWrap>
-          {inq.tenantCompany}
+          {secondaryLine}
         </Typography>
       )}
-      <Typography variant="caption" sx={{ color: '#475569', display: 'block', mb: 0.5, fontWeight: !inq.isRead ? 600 : 400, fontSize: '0.75rem' }} noWrap>
+      <Typography variant="caption" sx={{ color: DS_TEXT.secondary, display: 'block', mb: 0.5, fontWeight: !inq.isRead ? 600 : 400, fontSize: '0.75rem' }} noWrap>
         {inq.subject}
       </Typography>
       {lastMsg && (
         <Typography variant="caption" color="text.secondary" sx={{ display: 'block', mb: 0.5, fontSize: '0.7rem' }} noWrap>
-          {lastMsg.senderType === 'tenant' ? 'Sie: ' : `${lastMsg.senderName}: `}
+          {lastMsgPrefix}
           {lastMsg.body.split('\n')[0]}
         </Typography>
       )}
       <Box sx={{ display: 'flex', alignItems: 'center', gap: 1 }}>
         <Chip label={cfg?.label ?? inq.status} size="small"
-          sx={{ height: 16, fontSize: '0.6rem', bgcolor: cfg?.bgColor, color: cfg?.color, fontWeight: 600 }} />
+          sx={{ height: 16, fontSize: '0.6rem', bgcolor: cfg?.bg, color: cfg?.fg, fontWeight: 600 }} />
         {inq.matchScore && (
-          <Typography variant="caption" sx={{ color: inq.matchScore >= 80 ? '#1a7a4a' : '#d97706', fontWeight: 700, fontSize: '0.7rem' }}>
+          <Typography variant="caption" sx={{ color: inq.matchScore >= 80 ? DS_TEXT.success : DS_TEXT.warning, fontWeight: 700, fontSize: '0.7rem' }}>
             {inq.matchScore}%
           </Typography>
         )}
@@ -74,7 +89,12 @@ export function AnfragenInquiryItem({ inq, isSelected, hasPipeline, onSelect }:
             icon={<Kanban size={9} />}
             label="Pipeline"
             size="small"
-            sx={{ height: 16, fontSize: '0.6rem', bgcolor: '#eff6ff', color: '#1e3a5f', fontWeight: 600, '& .MuiChip-icon': { color: '#1e3a5f' } }}
+            sx={{
+              height: 16, fontSize: '0.6rem', fontWeight: 600,
+              bgcolor: DS_COLORS.futureCard.signal.headerBg,
+              color: 'primary.main',
+              '& .MuiChip-icon': { color: 'primary.main' },
+            }}
           />
         )}
       </Box>

src/components/demand/AnfragenMessageBubble.tsx

@@ -1,8 +1,9 @@
 import { Box, Typography } from '@mui/material'
 import { Bot, Building2, FileText } from 'lucide-react'
+import { DS_COLORS, DS_TEXT, DS_BG, DS_BORDER } from '../../lib/ds'
 import type { InquiryMessage } from '../../domain/inquiry'
 
-export function AnfragenMessageBubble({ msg }: { msg: InquiryMessage }) {
+export function AnfragenMessageBubble({ msg, currentUserName }: { msg: InquiryMessage; currentUserName?: string }) {
   const isOwnMessage = msg.senderType === 'tenant'
   const isAI = msg.senderType === 'ai'
   const time = new Date(msg.createdAt).toLocaleTimeString('de-CH', { hour: '2-digit', minute: '2-digit' })
@@ -11,10 +12,10 @@ export function AnfragenMessageBubble({ msg }: { msg: InquiryMessage }) {
   return (
     <Box sx={{ display: 'flex', flexDirection: 'column', alignItems: isOwnMessage ? 'flex-end' : 'flex-start', mb: 0.5 }}>
       <Box sx={{ display: 'flex', alignItems: 'center', gap: 0.5, mb: 0.375 }}>
-        {!isOwnMessage && isAI && <Bot size={11} color="#7c3aed" />}
-        {!isOwnMessage && msg.senderType === 'supply_user' && <Building2 size={11} color="#64748b" />}
+        {!isOwnMessage && isAI && <Bot size={11} color={DS_TEXT.signal} />}
+        {!isOwnMessage && msg.senderType === 'supply_user' && <Building2 size={11} color={DS_TEXT.muted} />}
         <Typography variant="caption" color="text.secondary" sx={{ fontSize: '0.7rem' }}>
-          {msg.senderName} · {date} {time}
+          {isOwnMessage && currentUserName ? currentUserName : msg.senderName} · {date} {time}
         </Typography>
       </Box>
       <Box
@@ -22,15 +23,15 @@ export function AnfragenMessageBubble({ msg }: { msg: InquiryMessage }) {
           maxWidth: { xs: '88%', md: '72%' },
           px: 2, py: 1.25,
           borderRadius: isOwnMessage ? '18px 18px 4px 18px' : '18px 18px 18px 4px',
-          bgcolor: isOwnMessage ? '#1e3a5f' : isAI ? '#f5f3ff' : 'white',
-          border: isOwnMessage ? 'none' : isAI ? '1px solid #ddd6fe' : '1px solid #e2e8f0',
+          bgcolor: isOwnMessage ? 'primary.main' : isAI ? DS_COLORS.futureCard.controlled.headerBg : 'white',
+          border: isOwnMessage ? 'none' : isAI ? `1px solid ${DS_COLORS.futureCard.controlled.border}` : `1px solid ${DS_BORDER.default}`,
           boxShadow: isOwnMessage ? '0 2px 6px rgba(30,58,95,0.2)' : '0 1px 2px rgba(0,0,0,0.06)',
         }}
       >
         <Typography
           variant="body2"
           sx={{
-            color: isOwnMessage ? 'white' : isAI ? '#5b21b6' : '#1e293b',
+            color: isOwnMessage ? 'white' : isAI ? DS_COLORS.futureCard.controlled.badgeText : DS_TEXT.primary,
             whiteSpace: 'pre-wrap', lineHeight: 1.65, fontSize: '0.875rem',
           }}
         >
@@ -44,17 +45,17 @@ export function AnfragenMessageBubble({ msg }: { msg: InquiryMessage }) {
                 sx={{
                   display: 'flex', alignItems: 'center', gap: 1,
                   px: 1.5, py: 0.75,
-                  bgcolor: isOwnMessage ? 'rgba(255,255,255,0.12)' : '#f1f5f9',
+                  bgcolor: isOwnMessage ? 'rgba(255,255,255,0.12)' : DS_BG.subtle,
                   borderRadius: 1.5, cursor: 'pointer',
-                  '&:hover': { bgcolor: isOwnMessage ? 'rgba(255,255,255,0.2)' : '#e2e8f0' },
+                  '&:hover': { bgcolor: isOwnMessage ? 'rgba(255,255,255,0.2)' : DS_BG.muted },
                 }}
               >
-                <FileText size={13} color={isOwnMessage ? 'rgba(255,255,255,0.75)' : '#64748b'} />
-                <Typography variant="caption" sx={{ color: isOwnMessage ? 'rgba(255,255,255,0.9)' : '#475569', flex: 1 }} noWrap>
+                <FileText size={13} color={isOwnMessage ? 'rgba(255,255,255,0.75)' : DS_TEXT.muted} />
+                <Typography variant="caption" sx={{ color: isOwnMessage ? 'rgba(255,255,255,0.9)' : DS_TEXT.secondary, flex: 1 }} noWrap>
                   {att.fileName}
                 </Typography>
                 {att.fileSize && (
-                  <Typography variant="caption" sx={{ color: isOwnMessage ? 'rgba(255,255,255,0.5)' : '#94a3b8', flexShrink: 0 }}>
+                  <Typography variant="caption" sx={{ color: isOwnMessage ? 'rgba(255,255,255,0.5)' : DS_TEXT.disabled, flexShrink: 0 }}>
                     {att.fileSize < 1024 * 1024
                       ? `${Math.round(att.fileSize / 1024)} KB`
                       : `${(att.fileSize / 1024 / 1024).toFixed(1)} MB`}

src/components/demand/ConfidenceFieldBadge.tsx

@@ -1,22 +1,17 @@
 import { Chip } from '@mui/material'
+import { confidenceHex } from '../../lib/utils'
 
 interface Props {
   confidence: number
   size?: 'small' | 'medium'
 }
 
-function confidenceColor(c: number): string {
-  if (c >= 0.8) return '#1a7a4a'
-  if (c >= 0.6) return '#d97706'
-  return '#c0392b'
-}
-
 export function ConfidenceFieldBadge({ confidence, size = 'small' }: Props) {
   return (
     <Chip
       label={`${Math.round(confidence * 100)}%`}
       size={size}
-      sx={{ bgcolor: confidenceColor(confidence), color: 'white', fontWeight: 700, fontSize: 11 }}
+      sx={{ bgcolor: confidenceHex(confidence), color: 'white', fontWeight: 700, fontSize: 11 }}
     />
   )
 }

src/components/demand/CriteriaReviewPanel.tsx

@@ -10,7 +10,7 @@ interface Props {
 
 const ASSET_LABELS: Record<string, string> = {
   OFFICE: 'Büro', LOGISTICS: 'Logistik / Lager', RETAIL: 'Retail',
-  PRODUCTION: 'Produktion', GASTRO: 'Gastro / F&B', LIGHT_INDUSTRIAL: 'Light Industrial',
+  PRODUCTION: 'Produktion', GASTRO: 'Gastro / F&B', LIGHT_INDUSTRIAL: 'Gewerbe',
   MIXED: 'Gemischt', UNKNOWN: 'Unbekannt',
 }
 
@@ -38,7 +38,7 @@ function displayAreaRange(v: ParsedNeedCriteria['areaRange']): string {
   return v ? `${v.min}–${v.max} m²` : ''
 }
 function displayBudget(v: ParsedNeedCriteria['budgetRange']): string {
-  return v ? `CHF ${v.maxPerSqm}/m²` : ''
+  return v ? `CHF ${v.maxPerSqm}/m²/Jahr` : ''
 }
 function displayTiming(v: ParsedNeedCriteria['timing']): string {
   if (!v) return ''

src/components/demand/FollowUpPanel.tsx

@@ -66,7 +66,7 @@ export function FollowUpPanel({ questions, answers, onAnswer, onContinue, onRepa
           disabled={requiredUnanswered.length > 0}
           onClick={onContinue}
           endIcon={<ArrowRight size={16} />}
-          sx={{ bgcolor: '#1e3a5f', '&:hover': { bgcolor: '#162d4a' } }}
+          sx={{ bgcolor: '#152642', '&:hover': { bgcolor: '#162d4a' } }}
         >
           Weiter zur Gewichtung
         </Button>

src/components/demand/NeedBuilderErrorState.tsx

@@ -22,7 +22,7 @@ export function NeedBuilderErrorState({ message, onRetry }: Props) {
         variant="contained"
         startIcon={<RotateCcw size={16} />}
         onClick={onRetry}
-        sx={{ bgcolor: '#1e3a5f', '&:hover': { bgcolor: '#162d4a' } }}
+        sx={{ bgcolor: '#152642', '&:hover': { bgcolor: '#162d4a' } }}
       >
         Erneut versuchen
       </Button>

src/components/demand/NeedCardPreview.tsx

@@ -15,7 +15,7 @@ interface Props {
 
 const ASSET_LABELS: Record<string, string> = {
   OFFICE: 'Büro', LOGISTICS: 'Logistik / Lager', RETAIL: 'Retail',
-  PRODUCTION: 'Produktion', GASTRO: 'Gastro / F&B', LIGHT_INDUSTRIAL: 'Light Industrial',
+  PRODUCTION: 'Produktion', GASTRO: 'Gastro / F&B', LIGHT_INDUSTRIAL: 'Gewerbe',
 }
 
 const CRITICAL_FIELDS = ['assetType', 'areaRange', 'preferredLocations', 'budgetRange', 'timing']
@@ -66,7 +66,7 @@ export function NeedCardPreview({ criteria: c, weights, confidenceByField, missi
         {/* Header */}
         <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, mb: 2 }}>
           {c.assetType && (
-            <Chip label={ASSET_LABELS[c.assetType] ?? c.assetType} size="small" sx={{ bgcolor: '#1e3a5f', color: 'white' }} />
+            <Chip label={ASSET_LABELS[c.assetType] ?? c.assetType} size="small" sx={{ bgcolor: '#152642', color: 'white' }} />
           )}
           <Chip label={isLowConfidence ? 'ENTWURF (needs_review)' : 'ENTWURF'} size="small" variant="outlined" />
         </Box>
@@ -95,7 +95,7 @@ export function NeedCardPreview({ criteria: c, weights, confidenceByField, missi
               <Wallet size={16} color="#64748b" style={{ flexShrink: 0, marginTop: 2 }} />
               <Box>
                 <Typography variant="caption" color="text.secondary">Budget</Typography>
-                <Typography variant="body2">max. CHF {c.budgetRange.maxPerSqm}/m²</Typography>
+                <Typography variant="body2">max. CHF {c.budgetRange.maxPerSqm}/m²/Jahr</Typography>
               </Box>
             </Box>
           )}
@@ -143,7 +143,7 @@ export function NeedCardPreview({ criteria: c, weights, confidenceByField, missi
             variant="determinate"
             value={overallConfidence * 100}
             sx={{
-              height: 6, borderRadius: 3, bgcolor: '#e2e8f0',
+              height: 6, borderRadius: 3, bgcolor: '#e8e7e4',
               '& .MuiLinearProgress-bar': {
                 bgcolor: overallConfidence >= 0.7 ? '#1a7a4a' : overallConfidence >= 0.5 ? '#d97706' : '#c0392b',
               },
@@ -171,7 +171,7 @@ export function NeedCardPreview({ criteria: c, weights, confidenceByField, missi
                 <LinearProgress
                   variant="determinate"
                   value={((weights[k] ?? 0) / maxWeight) * 100}
-                  sx={{ flex: 1, height: 6, borderRadius: 3, bgcolor: '#e2e8f0', '& .MuiLinearProgress-bar': { bgcolor: '#1e3a5f' } }}
+                  sx={{ flex: 1, height: 6, borderRadius: 3, bgcolor: '#e8e7e4', '& .MuiLinearProgress-bar': { bgcolor: '#152642' } }}
                 />
                 <Typography variant="caption" sx={{ width: 32, textAlign: 'right' }}>{pct}%</Typography>
               </Box>

src/components/demand/NeedExtendedRequirements.tsx

@@ -0,0 +1,119 @@
+import { Accordion, AccordionDetails, AccordionSummary, Box, Checkbox, FormControlLabel, MenuItem, Switch, TextField, Typography } from '@mui/material'
+import { ChevronDown } from 'lucide-react'
+import type { ParsedNeedCriteria } from '../../domain/needBuilder'
+
+interface Props {
+  criteria: ParsedNeedCriteria
+  onChange: (c: ParsedNeedCriteria) => void
+}
+
+export function NeedExtendedRequirements({ criteria: c, onChange: set }: Props) {
+  return (
+    <Accordion disableGutters elevation={0} sx={{ border: '1px solid #e2e8f0', borderRadius: 1, mt: 1, '&:before': { display: 'none' } }}>
+      <AccordionSummary expandIcon={<ChevronDown size={16} />} sx={{ minHeight: 36, px: 1.5, '& .MuiAccordionSummary-content': { my: 0.5 } }}>
+        <Typography variant="caption" sx={{ fontWeight: 600, color: '#64748b' }}>Erweiterte Anforderungen</Typography>
+      </AccordionSummary>
+      <AccordionDetails sx={{ px: 1.5, pt: 0, pb: 1.5 }}>
+        <Box sx={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 0.5, mb: 1.5 }}>
+          <FormControlLabel
+            control={<Checkbox size="small" checked={c.requireGroundFloor ?? false} onChange={e => set({ ...c, requireGroundFloor: e.target.checked || undefined })} />}
+            label={<Typography variant="caption">Erdgeschoss erforderlich</Typography>}
+          />
+          <FormControlLabel
+            control={<Checkbox size="small" checked={c.requireAirConditioning ?? false} onChange={e => set({ ...c, requireAirConditioning: e.target.checked || undefined })} />}
+            label={<Typography variant="caption">Klimaanlage erforderlich</Typography>}
+          />
+          <FormControlLabel
+            control={<Checkbox size="small" checked={c.requireLoadingDock ?? false} onChange={e => set({ ...c, requireLoadingDock: e.target.checked || undefined })} />}
+            label={<Typography variant="caption">Laderampe erforderlich</Typography>}
+          />
+          <FormControlLabel
+            control={<Checkbox size="small" checked={c.requireBarrierFree ?? false} onChange={e => set({ ...c, requireBarrierFree: e.target.checked || undefined })} />}
+            label={<Typography variant="caption">Barrierefrei erforderlich</Typography>}
+          />
+        </Box>
+        <Box sx={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 1.5 }}>
+          <Box>
+            <Typography variant="caption" color="text.secondary" sx={{ display: 'block', mb: 0.5 }}>Mindest-Parkplätze</Typography>
+            <TextField
+              size="small" type="number" fullWidth placeholder="0"
+              value={c.requiredParkingMin ?? ''}
+              onChange={e => set({ ...c, requiredParkingMin: parseInt(e.target.value) || undefined })}
+              slotProps={{ htmlInput: { min: 0, max: 100 } }}
+            />
+          </Box>
+          <Box>
+            <Typography variant="caption" color="text.secondary" sx={{ display: 'block', mb: 0.5 }}>Mindest-Ausbaustandard</Typography>
+            <TextField
+              select size="small" fullWidth
+              value={c.requiredFitOut ?? ''}
+              onChange={e => set({ ...c, requiredFitOut: (e.target.value as 'BASIC' | 'FULL' | 'PREMIUM') || undefined })}
+            >
+              <MenuItem value="">Kein Mindeststandard</MenuItem>
+              <MenuItem value="BASIC">Basisausbau</MenuItem>
+              <MenuItem value="FULL">Vollausbau</MenuItem>
+              <MenuItem value="PREMIUM">Premiumausbau</MenuItem>
+            </TextField>
+          </Box>
+          <Box>
+            <Typography variant="caption" color="text.secondary" sx={{ display: 'block', mb: 0.5 }}>Mindest-Deckenhöhe (m)</Typography>
+            <TextField
+              size="small" type="number" fullWidth placeholder="z.B. 6"
+              value={c.minCeilingHeightM ?? ''}
+              onChange={e => set({ ...c, minCeilingHeightM: parseFloat(e.target.value) || undefined })}
+              slotProps={{ htmlInput: { min: 2, max: 20, step: 0.5 } }}
+            />
+          </Box>
+          <Box>
+            <Typography variant="caption" color="text.secondary" sx={{ display: 'block', mb: 0.5 }}>Mindest-Vertragslaufzeit (Monate)</Typography>
+            <TextField
+              size="small" type="number" fullWidth placeholder="z.B. 36"
+              value={c.minContractDurationMonths ?? ''}
+              onChange={e => set({ ...c, minContractDurationMonths: parseInt(e.target.value) || undefined })}
+              slotProps={{ htmlInput: { min: 0, max: 360, step: 12 } }}
+            />
+          </Box>
+          <Box>
+            <Typography variant="caption" color="text.secondary" sx={{ display: 'block', mb: 0.5 }}>Eigenes Ausbaubudget (max. CHF/m²)</Typography>
+            <TextField
+              size="small" type="number" fullWidth placeholder="z.B. 200"
+              value={c.fitOutBudgetMaxPerSqm ?? ''}
+              onChange={e => set({ ...c, fitOutBudgetMaxPerSqm: parseInt(e.target.value) || undefined })}
+              slotProps={{ htmlInput: { min: 0, max: 5000, step: 50 } }}
+              helperText="Ihr Beitrag — exkl. MAB des Vermieters"
+            />
+          </Box>
+        </Box>
+
+        {/* Divisibility */}
+        <Box sx={{ mt: 1.5, pt: 1.5, borderTop: '1px solid #f1f5f9' }}>
+          <FormControlLabel
+            control={
+              <Switch
+                size="small"
+                checked={c.requiresDivisibility ?? false}
+                onChange={e => set({ ...c, requiresDivisibility: e.target.checked || undefined })}
+              />
+            }
+            label={<Typography variant="caption" sx={{ fontWeight: 600 }}>Fläche muss teilbar sein</Typography>}
+            sx={{ mb: c.requiresDivisibility ? 1 : 0 }}
+          />
+          {c.requiresDivisibility && (
+            <Box>
+              <Typography variant="caption" color="text.secondary" sx={{ display: 'block', mb: 0.5 }}>Mindesteinheit (m²)</Typography>
+              <TextField
+                size="small" type="number"
+                placeholder="z.B. 150"
+                value={c.minDivisibleUnit ?? ''}
+                onChange={e => set({ ...c, minDivisibleUnit: parseInt(e.target.value) || undefined })}
+                sx={{ width: 160 }}
+                slotProps={{ htmlInput: { min: 10, max: 5000, step: 10 } }}
+              />
+            </Box>
+          )}
+        </Box>
+
+      </AccordionDetails>
+    </Accordion>
+  )
+}

src/components/demand/NeedInput.tsx

@@ -1,8 +1,8 @@
 import { useState } from 'react'
-import { Accordion, AccordionDetails, AccordionSummary, Box, Card, Checkbox, Chip, FormControlLabel, MenuItem, Stack, TextField, Typography } from '@mui/material'
-import { ChevronDown } from 'lucide-react'
+import { Box, Card, Chip, Slider, Stack, TextField, Typography } from '@mui/material'
 import type { ParsedNeedCriteria } from '../../domain/needBuilder'
 import { AssetType } from '../../domain/enums'
+import { NeedExtendedRequirements } from './NeedExtendedRequirements'
 
 interface Props {
   criteria: ParsedNeedCriteria
@@ -14,7 +14,7 @@ const ASSET_OPTIONS = [
   { label: 'Retail', value: AssetType.RETAIL },
   { label: 'Logistik', value: AssetType.LOGISTICS },
   { label: 'Produktion', value: AssetType.PRODUCTION },
-  { label: 'Light Industrial', value: AssetType.LIGHT_INDUSTRIAL },
+  { label: 'Gewerbe', value: AssetType.LIGHT_INDUSTRIAL },
   { label: 'Gemischt', value: AssetType.MIXED },
 ]
 
@@ -34,6 +34,8 @@ const BUDGET_PRESETS = [
 
 const LOCATION_PRESETS = ['Zürich', 'Zürich-West', 'Zürich-Nord', 'Bern', 'Basel', 'Luzern']
 
+const RADIUS_MARKS = [5, 10, 20, 30, 50, 100].map(v => ({ value: v, label: v === 5 || v === 100 ? `${v} km` : `${v}` }))
+
 function FieldLabel({ children }: { children: React.ReactNode }) {
   return (
     <Typography variant="caption" color="text.secondary" sx={{ fontWeight: 600, display: 'block', mb: 0.75 }}>
@@ -79,7 +81,7 @@ export function NeedInput({ criteria: c, onCriteriaChange: set }: Props) {
             clickable
             onClick={() => set({ ...c, assetType: c.assetType === opt.value ? undefined : opt.value })}
             sx={c.assetType === opt.value
-              ? { bgcolor: '#1e3a5f', color: 'white', '& .MuiChip-label': { color: 'white' } }
+              ? { bgcolor: '#152642', color: 'white', '& .MuiChip-label': { color: 'white' } }
               : {}}
           />
         ))}
@@ -137,7 +139,7 @@ export function NeedInput({ criteria: c, onCriteriaChange: set }: Props) {
               })
             }}
             sx={c.preferredLocations?.includes(loc)
-              ? { fontSize: '0.68rem', height: 22, bgcolor: '#1e3a5f', color: 'white' }
+              ? { fontSize: '0.68rem', height: 22, bgcolor: '#152642', color: 'white' }
               : { fontSize: '0.68rem', height: 22, color: '#64748b', borderColor: '#cbd5e1' }
             }
           />
@@ -161,7 +163,27 @@ export function NeedInput({ criteria: c, onCriteriaChange: set }: Props) {
           ))}
         </Stack>
       )}
-      <Box sx={{ mb: (c.preferredLocations?.filter(l => !LOCATION_PRESETS.includes(l)).length ?? 0) > 0 ? 0 : 2.5 }} />
+      {(c.preferredLocations?.filter(l => !LOCATION_PRESETS.includes(l)).length ?? 0) === 0 && <Box sx={{ mb: 1.5 }} />}
+
+      {/* Radius */}
+      <Box sx={{ mb: 2.5, px: 0.5 }}>
+        <Box sx={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', mb: 0.5 }}>
+          <Typography variant="caption" color="text.secondary" sx={{ fontWeight: 600 }}>Suchradius</Typography>
+          <Typography variant="caption" sx={{ fontWeight: 700, color: '#152642' }}>
+            {c.searchRadius ?? 30} km
+          </Typography>
+        </Box>
+        <Slider
+          value={c.searchRadius ?? 30}
+          min={1}
+          max={100}
+          marks={RADIUS_MARKS}
+          step={1}
+          onChange={(_, v) => set({ ...c, searchRadius: v as number })}
+          size="small"
+          sx={{ color: '#152642', '& .MuiSlider-markLabel': { fontSize: '0.62rem' } }}
+        />
+      </Box>
 
       {/* Budget */}
       <FieldLabel>Budget (max CHF/m²/Jahr)</FieldLabel>
@@ -175,7 +197,7 @@ export function NeedInput({ criteria: c, onCriteriaChange: set }: Props) {
             clickable
             onClick={() => set({ ...c, budgetRange: { maxPerSqm: p.value, currency: 'CHF' } })}
             sx={c.budgetRange?.maxPerSqm === p.value
-              ? { fontSize: '0.68rem', height: 22, bgcolor: '#1e3a5f', color: 'white' }
+              ? { fontSize: '0.68rem', height: 22, bgcolor: '#152642', color: 'white' }
               : { fontSize: '0.68rem', height: 22, color: '#64748b', borderColor: '#cbd5e1' }
             }
           />
@@ -220,77 +242,7 @@ export function NeedInput({ criteria: c, onCriteriaChange: set }: Props) {
         </Stack>
       )}
 
-      {/* Extended requirements */}
-      <Accordion disableGutters elevation={0} sx={{ border: '1px solid #e2e8f0', borderRadius: 1, mt: 1, '&:before': { display: 'none' } }}>
-        <AccordionSummary expandIcon={<ChevronDown size={16} />} sx={{ minHeight: 36, px: 1.5, '& .MuiAccordionSummary-content': { my: 0.5 } }}>
-          <Typography variant="caption" sx={{ fontWeight: 600, color: '#64748b' }}>Erweiterte Anforderungen</Typography>
-        </AccordionSummary>
-        <AccordionDetails sx={{ px: 1.5, pt: 0, pb: 1.5 }}>
-          {/* Boolean requirement checkboxes — 2×2 grid */}
-          <Box sx={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 0.5, mb: 1.5 }}>
-            <FormControlLabel
-              control={<Checkbox size="small" checked={c.requireGroundFloor ?? false} onChange={e => set({ ...c, requireGroundFloor: e.target.checked || undefined })} />}
-              label={<Typography variant="caption">Erdgeschoss erforderlich</Typography>}
-            />
-            <FormControlLabel
-              control={<Checkbox size="small" checked={c.requireAirConditioning ?? false} onChange={e => set({ ...c, requireAirConditioning: e.target.checked || undefined })} />}
-              label={<Typography variant="caption">Klimaanlage erforderlich</Typography>}
-            />
-            <FormControlLabel
-              control={<Checkbox size="small" checked={c.requireLoadingDock ?? false} onChange={e => set({ ...c, requireLoadingDock: e.target.checked || undefined })} />}
-              label={<Typography variant="caption">Laderampe erforderlich</Typography>}
-            />
-            <FormControlLabel
-              control={<Checkbox size="small" checked={c.requireBarrierFree ?? false} onChange={e => set({ ...c, requireBarrierFree: e.target.checked || undefined })} />}
-              label={<Typography variant="caption">Barrierefrei erforderlich</Typography>}
-            />
-          </Box>
-
-          {/* Numeric / select fields — 2×2 grid */}
-          <Box sx={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 1.5 }}>
-            <Box>
-              <Typography variant="caption" color="text.secondary" sx={{ display: 'block', mb: 0.5 }}>Mindest-Parkplätze</Typography>
-              <TextField
-                size="small" type="number" fullWidth placeholder="0"
-                value={c.requiredParkingMin ?? ''}
-                onChange={e => set({ ...c, requiredParkingMin: parseInt(e.target.value) || undefined })}
-                slotProps={{ htmlInput: { min: 0, max: 100 } }}
-              />
-            </Box>
-            <Box>
-              <Typography variant="caption" color="text.secondary" sx={{ display: 'block', mb: 0.5 }}>Mindest-Ausbaustandard</Typography>
-              <TextField
-                select size="small" fullWidth
-                value={c.requiredFitOut ?? ''}
-                onChange={e => set({ ...c, requiredFitOut: (e.target.value as 'BASIC' | 'FULL' | 'PREMIUM') || undefined })}
-              >
-                <MenuItem value="">Kein Mindeststandard</MenuItem>
-                <MenuItem value="BASIC">Basisausbau</MenuItem>
-                <MenuItem value="FULL">Vollausbau</MenuItem>
-                <MenuItem value="PREMIUM">Premiumausbau</MenuItem>
-              </TextField>
-            </Box>
-            <Box>
-              <Typography variant="caption" color="text.secondary" sx={{ display: 'block', mb: 0.5 }}>Mindest-Deckenhöhe (m)</Typography>
-              <TextField
-                size="small" type="number" fullWidth placeholder="z.B. 6"
-                value={c.minCeilingHeightM ?? ''}
-                onChange={e => set({ ...c, minCeilingHeightM: parseFloat(e.target.value) || undefined })}
-                slotProps={{ htmlInput: { min: 2, max: 20, step: 0.5 } }}
-              />
-            </Box>
-            <Box>
-              <Typography variant="caption" color="text.secondary" sx={{ display: 'block', mb: 0.5 }}>Mindest-Vertragslaufzeit (Monate)</Typography>
-              <TextField
-                size="small" type="number" fullWidth placeholder="z.B. 36"
-                value={c.minContractDurationMonths ?? ''}
-                onChange={e => set({ ...c, minContractDurationMonths: parseInt(e.target.value) || undefined })}
-                slotProps={{ htmlInput: { min: 0, max: 360, step: 12 } }}
-              />
-            </Box>
-          </Box>
-        </AccordionDetails>
-      </Accordion>
+<NeedExtendedRequirements criteria={c} onChange={set} />
     </Card>
   )
 }

src/components/demand/VoiceNeedInput.tsx

@@ -77,7 +77,7 @@ export function VoiceNeedInput({ text, onTextChange, onAiSubmit, isAnalyzing, is
       sx={{
         p: 3,
         border: '1px solid',
-        borderColor: isRecording ? '#dc2626' : '#e2e8f0',
+        borderColor: isRecording ? '#dc2626' : '#e8e7e4',
         transition: 'border-color 0.2s',
         bgcolor: isRecording ? '#fff5f5' : 'white',
       }}
@@ -101,11 +101,11 @@ export function VoiceNeedInput({ text, onTextChange, onAiSubmit, isAnalyzing, is
           />
         ) : isAnalyzing ? (
           <Box sx={{ display: 'flex', alignItems: 'center', gap: 1 }}>
-            <CircularProgress size={14} sx={{ color: '#1e3a5f' }} />
-            <Typography variant="caption" sx={{ color: '#1e3a5f', fontWeight: 600 }}>Analysiert…</Typography>
+            <CircularProgress size={14} sx={{ color: '#152642' }} />
+            <Typography variant="caption" sx={{ color: '#152642', fontWeight: 600 }}>Analysiert…</Typography>
           </Box>
         ) : isAutoGen && text ? (
-          <Typography variant="caption" sx={{ color: '#1e3a5f', fontSize: 11 }}>⚡ auto-synchronisiert</Typography>
+          <Typography variant="caption" sx={{ color: '#152642', fontSize: 11 }}>⚡ auto-synchronisiert</Typography>
         ) : null}
       </Box>
 
@@ -154,7 +154,7 @@ export function VoiceNeedInput({ text, onTextChange, onAiSubmit, isAnalyzing, is
               size="small"
               disabled={isAnalyzing || !isSpeechSupported}
               title={isSpeechSupported ? 'Spracheingabe starten' : 'Spracheingabe nicht verfügbar'}
-              sx={{ bgcolor: '#f1f5f9', color: '#475569', '&:hover': { bgcolor: '#e2e8f0' }, '&:disabled': { opacity: 0.35 } }}
+              sx={{ bgcolor: '#f1f5f9', color: '#475569', '&:hover': { bgcolor: '#e8e7e4' }, '&:disabled': { opacity: 0.35 } }}
             >
               <Mic size={16} />
             </IconButton>

src/components/demand/WeightingEditor.tsx

@@ -3,7 +3,7 @@ import { Box, Button, Card, Divider, Slider, Typography } from '@mui/material'
 import { RotateCcw } from 'lucide-react'
 import { WEIGHTING_KEYS, WEIGHTING_LABELS } from '../../domain/needBuilder'
 import type { WeightingKey } from '../../domain/needBuilder'
-import { weightingService } from '../../services/weightingService'
+import { useDefaultWeights } from '../../hooks/useWeighting'
 
 const HARD_KEYS: WeightingKey[] = ['area', 'location', 'budget', 'timing']
 const SOFT_KEYS: WeightingKey[] = [
@@ -74,6 +74,7 @@ function SliderGroup({
 
 export function WeightingEditor({ weights, onChange, assetType }: Props) {
   const [raw, setRaw] = useState<Record<WeightingKey, number>>(() => toRaw(weights))
+  const defaultWeights = useDefaultWeights(assetType)
 
   function handleSlider(key: WeightingKey, value: number) {
     const updated = { ...raw, [key]: value }
@@ -82,9 +83,8 @@ export function WeightingEditor({ weights, onChange, assetType }: Props) {
   }
 
   function handleReset() {
-    const defaults = weightingService.getDefaultWeights(assetType)
-    setRaw(toRaw(defaults))
-    onChange(defaults)
+    setRaw(toRaw(defaultWeights))
+    onChange(defaultWeights)
   }
 
   return (
@@ -109,7 +109,7 @@ export function WeightingEditor({ weights, onChange, assetType }: Props) {
       </Box>
 
       <Card sx={{ p: 3 }}>
-        <SliderGroup label="Harte Kriterien" keys={HARD_KEYS} raw={raw} onSlider={handleSlider} color="#1e3a5f" />
+        <SliderGroup label="Harte Kriterien" keys={HARD_KEYS} raw={raw} onSlider={handleSlider} color="#152642" />
         <Divider sx={{ my: 2.5 }} />
         <SliderGroup label="Weiche Kriterien" keys={SOFT_KEYS} raw={raw} onSlider={handleSlider} color="#7c3aed" />
       </Card>

src/components/forms/PriorityChipGroup.tsx

@@ -39,7 +39,7 @@ export function PriorityChipGroup({ label, options, value, onChange, exclusive =
       <Box sx={{ display: 'flex', flexWrap: 'wrap', gap: 0.5 }}>
         {options.map(opt => {
           const selected = value.includes(opt.value)
-          const accent = opt.color ?? '#1e3a5f'
+          const accent = opt.color ?? '#152642'
           return (
             <Chip
               key={opt.value}

src/components/future-signals/FutureSignalDetailPanel.tsx

@@ -6,9 +6,9 @@ import { SensitivityBadge } from './SensitivityBadge'
 import { SignalReviewStatusBadge } from './SignalReviewStatusBadge'
 import { FutureSignalDisclaimer } from './FutureSignalDisclaimer'
 import { useUpdateSignalReviewStatus } from '../../hooks/useFutureSignals'
+import { useCreateReviewTask } from '../../hooks/useReviewQueue'
 import { useShortlistStore } from '../../stores/shortlistStore'
 import { useToastStore } from '../../stores/toastStore'
-import { reviewService } from '../../services/reviewService'
 import { ReviewStatus } from '../../domain/enums'
 import type { FutureSignal } from '../../domain/futureSignal'
 
@@ -51,6 +51,7 @@ interface Props {
 
 export function FutureSignalDetailPanel({ signal, onClose }: Props) {
   const updateStatus = useUpdateSignalReviewStatus()
+  const createReviewTask = useCreateReviewTask()
   const { openAddDialog } = useShortlistStore()
   const showToast = useToastStore((s) => s.showToast)
   const [reviewTaskSent, setReviewTaskSent] = useState(false)
@@ -75,14 +76,13 @@ export function FutureSignalDetailPanel({ signal, onClose }: Props) {
     }
   }
 
-  async function handleSendReview() {
-    try {
-      await reviewService.createReviewTask(signal.id)
-      setReviewTaskSent(true)
-      showToast('Prüfungsaufgabe erstellt.')
-    } catch {
-      showToast('Prüfungsaufgabe konnte nicht erstellt werden.', 'error')
-    }
+  function handleSendReview() {
+    createReviewTask.mutate(signal.id, {
+      onSuccess: () => {
+        setReviewTaskSent(true)
+        showToast('Prüfungsaufgabe erstellt.')
+      },
+    })
   }
 
   function handleShortlist() {

src/components/future-signals/FutureSignalFilterBar.tsx

@@ -57,7 +57,7 @@ export function FutureSignalFilterBar({ filters, onChange, totalCount, filteredC
             onClick={() => set({ signalType: filters.signalType === t ? '' : t })}
             sx={{
               fontWeight: filters.signalType === t ? 700 : 400,
-              bgcolor: filters.signalType === t ? '#1e3a5f' : undefined,
+              bgcolor: filters.signalType === t ? '#152642' : undefined,
               color: filters.signalType === t ? 'white' : undefined,
             }}
           />
@@ -131,7 +131,7 @@ export function FutureSignalFilterBar({ filters, onChange, totalCount, filteredC
             label={`${activeCount} Filter aktiv`}
             size="small"
             onDelete={() => onChange(DEFAULT_SIGNAL_FILTERS)}
-            sx={{ bgcolor: '#eff6ff', color: '#1e3a5f' }}
+            sx={{ bgcolor: '#eff6ff', color: '#152642' }}
           />
         )}
         <Typography variant="caption" color="text.secondary">

src/components/layout/AppShell.tsx

@@ -17,8 +17,10 @@ import { WorkspaceType } from '../../domain/enums'
 // ---------------------------------------------------------------------------
 
 export function AppShell() {
-  const { activeWorkspace, sidebarCollapsed, setActiveWorkspace, toggleSidebar } =
-    useLayoutStore()
+  const activeWorkspace = useLayoutStore(s => s.activeWorkspace)
+  const sidebarCollapsed = useLayoutStore(s => s.sidebarCollapsed)
+  const setActiveWorkspace = useLayoutStore(s => s.setActiveWorkspace)
+  const toggleSidebar = useLayoutStore(s => s.toggleSidebar)
   const { currentUser } = useSessionStore()
   const navigate = useNavigate()
   const location = useLocation()

src/components/layout/AppShellSidebar.tsx

@@ -13,7 +13,8 @@ export const SIDEBAR_BG = '#0f1923'
 export const DIVIDER_COLOR = 'rgba(255,255,255,0.08)'
 export const TEXT_MUTED = '#94a3b8'
 export const TEXT_WHITE = '#ffffff'
-export const NAV_ACTIVE_BG = 'rgba(255,255,255,0.12)'
+export const NAV_ACTIVE_BG = 'transparent'
+export const NAV_ACTIVE_ACCENT = '#b8975a'
 export const NAV_HOVER_BG = 'rgba(255,255,255,0.06)'
 
 // ---------------------------------------------------------------------------
@@ -188,16 +189,16 @@ export function Sidebar({
                     display: 'flex',
                     alignItems: 'center',
                     gap: 1.25,
-                    px: collapsed ? 0 : 1.5,
+                    pl: collapsed ? 0 : isActive ? 1.25 : 1.5,
+                    pr: collapsed ? 0 : 1.5,
                     py: 0.75,
                     mx: 0.5,
                     borderRadius: 1,
                     justifyContent: collapsed ? 'center' : 'flex-start',
-                    backgroundColor: isActive ? NAV_ACTIVE_BG : 'transparent',
-                    '&:hover': {
-                      backgroundColor: isActive ? NAV_ACTIVE_BG : NAV_HOVER_BG,
-                    },
-                    transition: 'background-color 0.15s ease',
+                    borderLeft: collapsed ? 'none' : `3px solid ${isActive ? NAV_ACTIVE_ACCENT : 'transparent'}`,
+                    backgroundColor: 'transparent',
+                    '&:hover': { backgroundColor: NAV_HOVER_BG },
+                    transition: 'border-color 0.15s ease',
                     cursor: 'pointer',
                   }}
                 >
@@ -208,8 +209,9 @@ export function Sidebar({
                         variant="body2"
                         sx={{
                           color: isActive ? TEXT_WHITE : TEXT_MUTED,
-                          fontWeight: isActive ? 500 : 400,
-                          fontSize: '0.8125rem',
+                          fontWeight: isActive ? 600 : 400,
+                          fontSize: '0.875rem',
+                          letterSpacing: '-0.01em',
                           whiteSpace: 'nowrap',
                         }}
                       >
@@ -263,7 +265,7 @@ export function Sidebar({
                 width: 32,
                 height: 32,
                 fontSize: '0.75rem',
-                bgcolor: '#1e3a5f',
+                bgcolor: '#b8975a',
                 flexShrink: 0,
               }}
             >

src/components/layout/AppShellTopBar.tsx

@@ -31,10 +31,10 @@ export function TopBar({ activeWorkspace, pathname, onMenuClick, isMobile }: Top
     <Box
       component="header"
       sx={{
-        height: 56,
+        height: 64,
         flexShrink: 0,
         backgroundColor: '#ffffff',
-        borderBottom: '1px solid #e2e8f0',
+        borderBottom: '1px solid #e8e7e4',
         display: 'flex',
         alignItems: 'center',
         justifyContent: 'space-between',
@@ -51,12 +51,13 @@ export function TopBar({ activeWorkspace, pathname, onMenuClick, isMobile }: Top
         <Chip
           label={config.label}
           size="small"
+          variant="outlined"
           sx={{
-            backgroundColor: config.chipColor,
-            color: '#ffffff',
+            color: '#152642',
             fontWeight: 600,
             fontSize: '0.7rem',
             height: 22,
+            border: '1px solid #e8e7e4',
           }}
         />
         <Typography

src/components/layout/CompareTray.tsx

@@ -1,28 +1,20 @@
-import { useEffect } from 'react'
 import { useNavigate, useLocation } from 'react-router'
 import { Box, Button, IconButton, Typography } from '@mui/material'
 import { X } from 'lucide-react'
 import { useCompareStore } from '../../stores/compareStore'
-import { useLayoutStore } from '../../stores/layoutStore'
 
 const TYPE_DOT: Record<string, string> = {
-  VERIFIED_PORTFOLIO:  '#1e3a5f',
-  EXTERNAL_MARKET:     '#d97706',
+  VERIFIED_PORTFOLIO:  '#152642',
   MAISON_WORK:         '#0369a1',
   FUTURE_AVAILABILITY: '#7c3aed',
 }
 
 export function CompareTray() {
   const { compareItems, removeFromCompare, clearCompare } = useCompareStore()
-  const { setCompareTrayVisible } = useLayoutStore()
   const navigate = useNavigate()
   const location = useLocation()
   const isDemand = location.pathname.startsWith('/demand')
 
-  useEffect(() => {
-    setCompareTrayVisible(compareItems.length > 0 && isDemand)
-  }, [compareItems.length, setCompareTrayVisible, isDemand])
-
   if (!isDemand) return null
 
   const getTitle = (item: (typeof compareItems)[number]) => {
@@ -100,7 +92,7 @@ export function CompareTray() {
         variant="contained"
         size="small"
         onClick={() => navigate('/demand/compare')}
-        sx={{ bgcolor: '#1e3a5f', textTransform: 'none', flexShrink: 0, '&:hover': { bgcolor: '#162d4a' } }}
+        sx={{ bgcolor: '#152642', textTransform: 'none', flexShrink: 0, '&:hover': { bgcolor: '#162d4a' } }}
       >
         Vergleich starten
       </Button>

src/components/layout/OrganizationContextBadge.tsx

@@ -13,7 +13,7 @@ export function OrganizationContextBadge() {
       variant="outlined"
       icon={<Building2 size={12} color="#64748b" />}
       label={currentUser.organizationName}
-      sx={{ fontSize: '0.7rem', height: 22, color: '#64748b', borderColor: '#e2e8f0' }}
+      sx={{ fontSize: '0.7rem', height: 22, color: '#64748b', borderColor: '#e8e7e4' }}
     />
   )
 }

src/components/layout/PageHeader.tsx

@@ -28,7 +28,7 @@ export function PageHeader({
   sx,
 }: PageHeaderProps) {
   return (
-    <Box sx={{ px: 3, py: 2.5, borderBottom: '1px solid #e2e8f0', ...sx }}>
+    <Box sx={{ px: 3, py: 2.5, borderBottom: '1px solid #e8e7e4', bgcolor: 'white', ...sx }}>
       {breadcrumbs && breadcrumbs.length > 0 && (
         <Breadcrumbs separator="/" sx={{ mb: 1 }}>
           {breadcrumbs.map((crumb) =>
@@ -52,7 +52,7 @@ export function PageHeader({
       <Box sx={{ display: 'flex', justifyContent: 'space-between', alignItems: 'flex-start' }}>
         <Box>
           <Box sx={{ display: 'flex', alignItems: 'center', gap: 1 }}>
-            <Typography variant="h6" sx={{ fontWeight: 600, lineHeight: 1.3 }}>
+            <Typography sx={{ fontWeight: 700, fontSize: '1.125rem', lineHeight: 1.3, color: '#0f172a' }}>
               {title}
             </Typography>
             {badge}

src/components/layout/RightContextPanel.tsx

@@ -18,7 +18,9 @@ const PANEL_PLACEHOLDERS: Record<RightPanelContentType, string> = {
 }
 
 export function RightContextPanel() {
-  const { isRightPanelOpen, rightPanelContentType, closeRightPanel } = useLayoutStore()
+  const isRightPanelOpen = useLayoutStore(s => s.isRightPanelOpen)
+  const rightPanelContentType = useLayoutStore(s => s.rightPanelContentType)
+  const closeRightPanel = useLayoutStore(s => s.closeRightPanel)
 
   const title = rightPanelContentType ? PANEL_TITLES[rightPanelContentType] : ''
   const placeholder = rightPanelContentType ? PANEL_PLACEHOLDERS[rightPanelContentType] : ''

src/components/layout/UserMenu.tsx

@@ -45,7 +45,7 @@ export function UserMenu() {
   return (
     <>
       <IconButton onClick={handleOpen} size="small" sx={{ p: 0 }}>
-        <Avatar sx={{ width: 32, height: 32, fontSize: '0.75rem', bgcolor: '#1e3a5f' }}>
+        <Avatar sx={{ width: 32, height: 32, fontSize: '0.75rem', bgcolor: '#152642' }}>
           {initials}
         </Avatar>
       </IconButton>

src/components/layout/appShellConfig.ts

@@ -3,7 +3,6 @@ import type { LucideIcon } from 'lucide-react'
 import {
   LayoutDashboard,
   Building2,
-  Target,
   CheckSquare,
   Search,
   List,
@@ -13,7 +12,7 @@ import {
   MessageSquare,
   Kanban,
   BellRing,
-  Plus,
+  Settings,
 } from 'lucide-react'
 
 // ---------------------------------------------------------------------------
@@ -45,17 +44,15 @@ export const WORKSPACE_CONFIG: Record<WorkspaceType, WorkspaceConfig> = {
     abbreviation: 'VW',
     icon: Building2,
     firstPath: '/supply/dashboard',
-    chipColor: '#1e3a5f',
+    chipColor: '#152642',
     navItems: [
       { path: '/supply/dashboard', label: 'Übersicht', icon: LayoutDashboard },
       { path: '/supply/properties', label: 'Meine Objekte', icon: Building2 },
       { path: '/supply/reminder-manager', label: 'Reminder Manager', icon: BellRing },
-      { path: '/supply/market-leads', label: 'Markt-Leads', icon: Target },
       { path: '/supply/anfragen', label: 'Anfragencenter', icon: MessageSquare },
       { path: '/supply/data-quality', label: 'Datenpflege', icon: CheckSquare },
-      { path: '/supply/market-intelligence', label: 'Markt Intelligence', icon: Radar },
-      { path: '/supply/my-listings', label: 'Meine Inserate', icon: ClipboardList },
-      { path: '/supply/new-listing', label: 'Neues Inserat', icon: Plus },
+      { path: '/supply/market-intelligence', label: 'Marktchancen', icon: Radar },
+      { path: '/supply/my-listings', label: 'Inserate', icon: ClipboardList },
     ],
   },
   [WorkspaceType.DEMAND]: {
@@ -72,6 +69,17 @@ export const WORKSPACE_CONFIG: Record<WorkspaceType, WorkspaceConfig> = {
       { path: '/demand/anfragen', label: 'Anfragen', icon: MessageSquare },
     ],
   },
+  [WorkspaceType.OPERATIONS]: {
+    label: 'Operations',
+    abbreviation: 'OP',
+    icon: Settings,
+    firstPath: '/ops/review-queue',
+    chipColor: '#6b21a8',
+    navItems: [
+      { path: '/ops/review-queue', label: 'Review Queue', icon: CheckSquare },
+      { path: '/ops/audit', label: 'Audit Log', icon: ClipboardList },
+    ],
+  },
 }
 
 // Ordered list for rendering workspace tabs

src/components/match-card/FutureAvailabilityCard.tsx

@@ -1,90 +1,25 @@
+import { memo } from 'react'
 import { Box, Button, Divider, Typography } from '@mui/material'
-import {
-  AlertCircle,
-  BarChart2,
-  Briefcase,
-  CheckCircle2,
-  FileCheck,
-  FileText,
-  Newspaper,
-  ShieldCheck,
-  User,
-} from 'lucide-react'
+import { AlertCircle, CheckCircle2, ShieldCheck } from 'lucide-react'
 import { useNavigate } from 'react-router'
 import { getScoreTier, SCORE_THEME } from '../shared/scoreTheme'
+import { floorLabel, SOURCE_META, ASSET_TYPE_LABELS, getOpportunityHeadline } from './futureAvailabilityCardHelpers'
+import { SignalQualityDots } from './SignalQualityDots'
+import { DS_COLORS, DS_TEXT, DS_SURFACE, DS_BORDER } from '../../lib/ds'
 import type { MatchCardViewModel } from './MatchCardViewModel'
 
-function floorLabel(level: number): string {
-  if (level === 0) return 'EG'
-  if (level < 0) return `UG ${Math.abs(level)}`
-  return `${level}.OG`
-}
-
-const SOURCE_META: Record<string, { label: string; icon: React.ReactNode }> = {
-  JOB_POSTING:        { label: 'Stelleninserate',    icon: <Briefcase size={11} /> },
-  PRESS:              { label: 'Pressebericht',       icon: <Newspaper size={11} /> },
-  CONSTRUCTION_PERMIT:{ label: 'Baubewilligung',      icon: <FileCheck size={11} /> },
-  COMPANY_REPORT:     { label: 'Geschäftsbericht',    icon: <FileText size={11} /> },
-  MARKET_DATA:        { label: 'Marktdaten',          icon: <BarChart2 size={11} /> },
-  MANUAL:             { label: 'Analyst',             icon: <User size={11} /> },
-  LEASE_CONTRACT:     { label: 'Vertrag verifiziert', icon: <ShieldCheck size={11} /> },
-}
-
-const ASSET_TYPE_LABELS: Record<string, string> = {
-  OFFICE: 'Bürofläche',
-  LOGISTICS: 'Lagerfläche',
-  RETAIL: 'Retailfläche',
-  PRODUCTION: 'Produktionsfläche',
-  MIXED: 'Gewerbefläche',
-}
-
-// Signal type → opportunity headline (with asset type)
-function getOpportunityHeadline(signalType: string | undefined, assetTypeLabel: string): string {
-  switch (signalType) {
-    case 'LEASE_EXPIRY': return `${assetTypeLabel} wird verfügbar`
-    case 'POSSIBLE_MOVE_OUT': return `Mögliche ${assetTypeLabel} erkannt`
-    case 'EXPANSION': return `Unternehmen sucht ${assetTypeLabel}`
-    case 'CONSTRUCTION_PROJECT': return `Neubau: ${assetTypeLabel} in Planung`
-    case 'RESTRUCTURING': return `Mögliche Flächenfreigabe erkannt`
-    case 'SPACE_CONSOLIDATION': return `Mögliche Teilfläche erkannt`
-    case 'PROJECT_DEVELOPMENT': return `Neue Fläche in Projektentwicklung`
-    default: return `Potenzielle ${assetTypeLabel} erkannt`
-  }
-}
-
-// Signal quality dots display
-function SignalQualityDots({ quality }: { quality: 'HIGH' | 'MEDIUM' | 'LOW' | undefined }) {
-  const config = {
-    HIGH:   { dots: [1, 1, 1, 1], color: '#1a7a4a', label: 'Hohe Signalqualität' },
-    MEDIUM: { dots: [1, 1, 1, 0], color: '#d97706', label: 'Mittlere Signalqualität' },
-    LOW:    { dots: [1, 1, 0, 0], color: '#c0392b', label: 'Niedrige Signalqualität' },
-  }
-  const c = quality ? config[quality] : config.LOW
-  return (
-    <Box sx={{ display: 'flex', alignItems: 'center', gap: 0.5 }}>
-      {c.dots.map((filled, i) => (
-        <Box key={i} sx={{ width: 7, height: 7, borderRadius: '50%', bgcolor: filled ? c.color : '#e2e8f0' }} />
-      ))}
-      <Typography sx={{ fontSize: '0.68rem', color: c.color, fontWeight: 600, ml: 0.25 }}>
-        {c.label}
-      </Typography>
-    </Box>
-  )
-}
-
 // ── Future Availability Card ──────────────────────────────────────────────────
 
-export function FutureAvailabilityCard({ vm }: { vm: MatchCardViewModel }) {
+export const FutureAvailabilityCard = memo(function FutureAvailabilityCard({ vm }: { vm: MatchCardViewModel }) {
   const isControlled = vm.signalIsControlled ?? false
   const navigate = useNavigate()
 
-  // PRE-MARKET VERIFIED: soft purple / institutional premium
-  // MARKET SIGNAL: slate blue / analytical
-  const accentColor   = isControlled ? '#7c3aed' : '#1d4ed8'
-  const headerBg      = isControlled ? '#faf5ff' : '#eff6ff'
-  const borderColor   = isControlled ? '#e9d5ff' : '#bfdbfe'
-  const badgeBg       = isControlled ? '#ede9fe' : '#dbeafe'
-  const badgeColor    = isControlled ? '#5b21b6' : '#1e40af'
+  const cardColors = isControlled ? DS_COLORS.futureCard.controlled : DS_COLORS.futureCard.signal
+  const accentColor   = cardColors.accent
+  const headerBg      = cardColors.headerBg
+  const borderColor   = cardColors.border
+  const badgeBg       = cardColors.badgeBg
+  const badgeColor    = cardColors.badgeText
 
   const assetLabel = vm.assetType ? (ASSET_TYPE_LABELS[vm.assetType] ?? vm.assetType) : 'Fläche'
   const headline   = getOpportunityHeadline(vm.signalType, assetLabel)
@@ -97,7 +32,6 @@ export function FutureAvailabilityCard({ vm }: { vm: MatchCardViewModel }) {
       borderRadius: 2,
       overflow: 'hidden',
       border: `1px solid ${borderColor}`,
-      borderLeft: `3px solid ${accentColor}`,
       background: 'white',
       display: 'flex', flexDirection: 'column',
       boxShadow: '0 1px 8px rgba(0,0,0,0.06)',
@@ -110,7 +44,7 @@ export function FutureAvailabilityCard({ vm }: { vm: MatchCardViewModel }) {
 
         {/* Asset type · location + badge */}
         <Box sx={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', mb: 0.5 }}>
-          <Typography sx={{ fontSize: '0.63rem', fontWeight: 700, color: '#64748b', textTransform: 'uppercase', letterSpacing: 0.8 }}>
+          <Typography sx={{ fontSize: '0.63rem', fontWeight: 700, color: DS_TEXT.muted, textTransform: 'uppercase', letterSpacing: 0.8 }}>
             {assetLabel.toUpperCase()}  ·  {vm.locationLabel?.split(',')[0]?.toUpperCase() ?? ''}
           </Typography>
           <Box sx={{ display: 'flex', alignItems: 'center', gap: 0.4, bgcolor: badgeBg, color: badgeColor, px: 0.875, py: 0.25, borderRadius: 1, flexShrink: 0 }}>
@@ -122,19 +56,19 @@ export function FutureAvailabilityCard({ vm }: { vm: MatchCardViewModel }) {
         </Box>
 
         {/* Opportunity headline */}
-        <Typography variant="subtitle1" sx={{ fontWeight: 700, lineHeight: 1.3, color: '#1e293b', mb: 0.75 }}>
+        <Typography variant="subtitle1" sx={{ fontWeight: 700, lineHeight: 1.3, color: DS_TEXT.primary, mb: 0.75 }}>
           {headline}
         </Typography>
 
         {/* Key facts */}
         <Box sx={{ display: 'flex', alignItems: 'center', gap: 1.5, flexWrap: 'wrap', mb: 0.875 }}>
           {vm.signalAreaSqmEstimate ? (
-            <Typography sx={{ fontSize: '0.75rem', fontWeight: 700, color: '#1e293b' }}>
+            <Typography sx={{ fontSize: '0.75rem', fontWeight: 700, color: DS_TEXT.primary }}>
               {isControlled ? '' : '~'}{vm.signalAreaSqmEstimate.toLocaleString('de-CH')} m²
             </Typography>
           ) : null}
           {vm.availabilityLabel && (
-            <Typography sx={{ fontSize: '0.72rem', color: '#475569' }}>
+            <Typography sx={{ fontSize: '0.72rem', color: DS_TEXT.secondary }}>
               {vm.availabilityLabel}
             </Typography>
           )}
@@ -142,20 +76,20 @@ export function FutureAvailabilityCard({ vm }: { vm: MatchCardViewModel }) {
 
         {/* Source attribution */}
         {isControlled ? (
-          <Box sx={{ display: 'flex', alignItems: 'center', gap: 0.5, bgcolor: '#f0fdf4', border: '1px solid #bbf7d0', borderRadius: 1, px: 0.875, py: 0.3, width: 'fit-content' }}>
-            <ShieldCheck size={10} color="#1a7a4a" />
-            <Typography sx={{ fontSize: '0.65rem', fontWeight: 700, color: '#1a7a4a' }}>Direkte Verwaltungsquelle</Typography>
+          <Box sx={{ display: 'flex', alignItems: 'center', gap: 0.5, bgcolor: DS_SURFACE.success.bg, border: `1px solid ${DS_SURFACE.success.border}`, borderRadius: 1, px: 0.875, py: 0.3, width: 'fit-content' }}>
+            <ShieldCheck size={10} color={DS_TEXT.success} />
+            <Typography sx={{ fontSize: '0.65rem', fontWeight: 700, color: DS_TEXT.success }}>Direkte Verwaltungsquelle</Typography>
           </Box>
         ) : sourceMeta ? (
           <Box sx={{ display: 'flex', alignItems: 'center', gap: 0.5, width: 'fit-content' }}>
-            <Box sx={{ color: '#64748b', display: 'flex' }}>{sourceMeta.icon}</Box>
-            <Typography sx={{ fontSize: '0.65rem', color: '#64748b', fontWeight: 500 }}>{sourceMeta.label}</Typography>
+            <Box sx={{ color: DS_TEXT.muted, display: 'flex' }}>{sourceMeta.icon}</Box>
+            <Typography sx={{ fontSize: '0.65rem', color: DS_TEXT.muted, fontWeight: 500 }}>{sourceMeta.label}</Typography>
           </Box>
         ) : null}
       </Box>
 
       {/* ── Score + signal quality strip ────────────────────────────────────── */}
-      <Box sx={{ px: 2, py: 1, display: 'flex', alignItems: 'center', gap: 1.5, borderBottom: '1px solid #f1f5f9', bgcolor: 'white' }}>
+      <Box sx={{ px: 2, py: 1, display: 'flex', alignItems: 'center', gap: 1.5, borderBottom: `1px solid ${DS_BORDER.muted}`, bgcolor: 'white' }}>
         <Box sx={{
           background: theme.gradient, borderRadius: '8px',
           px: 1.25, py: 0.4, border: `1px solid ${theme.border}`,
@@ -167,8 +101,8 @@ export function FutureAvailabilityCard({ vm }: { vm: MatchCardViewModel }) {
         </Box>
         <SignalQualityDots quality={vm.signalQuality} />
         {!isControlled && vm.signalProbability !== undefined && (
-          <Box sx={{ ml: 'auto', bgcolor: '#f8fafc', border: '1px solid #e2e8f0', borderRadius: 1, px: 0.75, py: 0.2 }}>
-            <Typography sx={{ fontSize: '0.63rem', color: '#64748b', fontWeight: 600 }}>
+          <Box sx={{ ml: 'auto', bgcolor: DS_SURFACE.neutral.bg, border: `1px solid ${DS_BORDER.default}`, borderRadius: 1, px: 0.75, py: 0.2 }}>
+            <Typography sx={{ fontSize: '0.63rem', color: DS_TEXT.muted, fontWeight: 600 }}>
               {Math.round(vm.signalProbability * 100)}% Signalw.
             </Typography>
           </Box>
@@ -182,10 +116,10 @@ export function FutureAvailabilityCard({ vm }: { vm: MatchCardViewModel }) {
         {!isControlled && (
           <Box sx={{
             display: 'flex', alignItems: 'flex-start', gap: 0.6, mb: 1.25,
-            bgcolor: '#fefce8', border: '1px solid #fde68a', borderRadius: 1, px: 1, py: 0.625,
+            bgcolor: DS_SURFACE.warning.bg, border: `1px solid ${DS_SURFACE.warning.border}`, borderRadius: 1, px: 1, py: 0.625,
           }}>
-            <AlertCircle size={11} color="#92400e" style={{ marginTop: 2, flexShrink: 0 }} />
-            <Typography sx={{ fontSize: '0.67rem', color: '#78350f', lineHeight: 1.45 }}>
+            <AlertCircle size={11} color={DS_COLORS.heat.VERY_HOT.text} style={{ marginTop: 2, flexShrink: 0 }} />
+            <Typography sx={{ fontSize: '0.67rem', color: DS_COLORS.heat.VERY_HOT.text, lineHeight: 1.45 }}>
               Probabilistischer Marktindikator — kein bestätigtes Objekt. Dient als strategischer Frühindikator.
             </Typography>
           </Box>
@@ -196,8 +130,8 @@ export function FutureAvailabilityCard({ vm }: { vm: MatchCardViewModel }) {
           <Box sx={{ display: 'flex', flexDirection: 'column', gap: 0.4, mb: 1.25 }}>
             {(vm.signalConfirmedFacts ?? []).slice(0, 3).map((fact, i) => (
               <Box key={i} sx={{ display: 'flex', alignItems: 'center', gap: 0.6 }}>
-                <CheckCircle2 size={12} color="#1a7a4a" style={{ flexShrink: 0 }} />
-                <Typography sx={{ fontSize: '0.72rem', color: '#1a7a4a', fontWeight: 500 }}>{fact}</Typography>
+                <CheckCircle2 size={12} color={DS_TEXT.success} style={{ flexShrink: 0 }} />
+                <Typography sx={{ fontSize: '0.72rem', color: DS_TEXT.success, fontWeight: 500 }}>{fact}</Typography>
               </Box>
             ))}
           </Box>
@@ -205,19 +139,19 @@ export function FutureAvailabilityCard({ vm }: { vm: MatchCardViewModel }) {
 
         {/* PRE-MARKET VERIFIED: specific unit info */}
         {isControlled && vm.preMarketUnit && (
-          <Box sx={{ bgcolor: '#f0fdf4', border: '1px solid #bbf7d0', borderRadius: 1, px: 1.25, py: 0.875, mb: 1.25 }}>
-            <Typography sx={{ fontSize: '0.63rem', fontWeight: 700, color: '#1a7a4a', textTransform: 'uppercase', letterSpacing: 0.5, mb: 0.4 }}>
+          <Box sx={{ bgcolor: DS_SURFACE.success.bg, border: `1px solid ${DS_SURFACE.success.border}`, borderRadius: 1, px: 1.25, py: 0.875, mb: 1.25 }}>
+            <Typography sx={{ fontSize: '0.63rem', fontWeight: 700, color: DS_TEXT.success, textTransform: 'uppercase', letterSpacing: 0.5, mb: 0.4 }}>
               Freigegebene Einheit
             </Typography>
             <Box sx={{ display: 'flex', gap: 1.5, flexWrap: 'wrap' }}>
-              <Typography sx={{ fontSize: '0.72rem', color: '#1e293b', fontWeight: 600 }}>
+              <Typography sx={{ fontSize: '0.72rem', color: DS_TEXT.primary, fontWeight: 600 }}>
                 {floorLabel(vm.preMarketUnit.floorLevel)}{vm.preMarketUnit.unitLabel ? ` · ${vm.preMarketUnit.unitLabel}` : ''}
               </Typography>
-              <Typography sx={{ fontSize: '0.72rem', color: '#475569' }}>
+              <Typography sx={{ fontSize: '0.72rem', color: DS_TEXT.secondary }}>
                 {vm.preMarketUnit.areaSqm.toLocaleString('de-CH')} m²
               </Typography>
               {vm.preMarketUnit.schattenmarktRelease?.availableFrom && (
-                <Typography sx={{ fontSize: '0.72rem', color: '#475569' }}>
+                <Typography sx={{ fontSize: '0.72rem', color: DS_TEXT.secondary }}>
                   ab {new Date(vm.preMarketUnit.schattenmarktRelease.availableFrom).toLocaleDateString('de-CH', { month: 'short', year: 'numeric' })}
                 </Typography>
               )}
@@ -228,14 +162,14 @@ export function FutureAvailabilityCard({ vm }: { vm: MatchCardViewModel }) {
         {/* MARKET SIGNAL: market indicators */}
         {!isControlled && (vm.signalMarketIndicators?.length ?? 0) > 0 && (
           <Box sx={{ mb: 1.25 }}>
-            <Typography sx={{ fontSize: '0.63rem', fontWeight: 700, color: '#64748b', textTransform: 'uppercase', letterSpacing: 0.6, mb: 0.5 }}>
+            <Typography sx={{ fontSize: '0.63rem', fontWeight: 700, color: DS_TEXT.muted, textTransform: 'uppercase', letterSpacing: 0.6, mb: 0.5 }}>
               Erkannte Marktindikatoren
             </Typography>
             <Box sx={{ display: 'flex', flexDirection: 'column', gap: 0.35 }}>
               {(vm.signalMarketIndicators ?? []).slice(0, 3).map((ind, i) => (
                 <Box key={i} sx={{ display: 'flex', alignItems: 'flex-start', gap: 0.6 }}>
-                  <Box sx={{ width: 4, height: 4, borderRadius: '50%', bgcolor: '#1d4ed8', mt: '5px', flexShrink: 0 }} />
-                  <Typography sx={{ fontSize: '0.72rem', color: '#475569', lineHeight: 1.3 }}>{ind}</Typography>
+                  <Box sx={{ width: 4, height: 4, borderRadius: '50%', bgcolor: DS_COLORS.futureCard.signal.indicator, mt: '5px', flexShrink: 0 }} />
+                  <Typography sx={{ fontSize: '0.72rem', color: DS_TEXT.secondary, lineHeight: 1.3 }}>{ind}</Typography>
                 </Box>
               ))}
             </Box>
@@ -246,16 +180,16 @@ export function FutureAvailabilityCard({ vm }: { vm: MatchCardViewModel }) {
         {vm.reasons.length > 0 && (
           <>
             <Divider sx={{ mb: 1 }} />
-            <Typography sx={{ fontSize: '0.63rem', fontWeight: 700, color: '#64748b', textTransform: 'uppercase', letterSpacing: 0.6, mb: 0.6 }}>
+            <Typography sx={{ fontSize: '0.63rem', fontWeight: 700, color: DS_TEXT.muted, textTransform: 'uppercase', letterSpacing: 0.6, mb: 0.6 }}>
               Warum relevant für Ihre Suche?
             </Typography>
             <Box sx={{ display: 'flex', flexDirection: 'column', gap: 0.5, mb: 1.25 }}>
               {vm.reasons.slice(0, 3).map((r, i) => (
                 <Box key={i} sx={{ display: 'flex', alignItems: 'flex-start', gap: 0.6 }}>
-                  <CheckCircle2 size={12} color="#1a7a4a" style={{ marginTop: 2, flexShrink: 0 }} />
+                  <CheckCircle2 size={12} color={DS_TEXT.success} style={{ marginTop: 2, flexShrink: 0 }} />
                   <Box>
-                    <Typography sx={{ fontSize: '0.72rem', fontWeight: 600, color: '#1e293b', lineHeight: 1.3 }}>{r.label}</Typography>
-                    <Typography sx={{ fontSize: '0.69rem', color: '#64748b', lineHeight: 1.3 }}>{r.explanation}</Typography>
+                    <Typography sx={{ fontSize: '0.72rem', fontWeight: 600, color: DS_TEXT.primary, lineHeight: 1.3 }}>{r.label}</Typography>
+                    <Typography sx={{ fontSize: '0.69rem', color: DS_TEXT.muted, lineHeight: 1.3 }}>{r.explanation}</Typography>
                   </Box>
                 </Box>
               ))}
@@ -276,7 +210,7 @@ export function FutureAvailabilityCard({ vm }: { vm: MatchCardViewModel }) {
                 textTransform: 'none', fontSize: '0.7rem', py: 0.375, px: 1,
                 ...(a.variant === 'primary' && {
                   bgcolor: accentColor,
-                  '&:hover': { bgcolor: isControlled ? '#6d28d9' : '#1e40af' },
+                  '&:hover': { bgcolor: cardColors.accentHover },
                 }),
               }}
             >
@@ -290,7 +224,9 @@ export function FutureAvailabilityCard({ vm }: { vm: MatchCardViewModel }) {
               onClick={() => navigate(`/demand/property/${vm.propertyId}${vm.unitId ? `?unit=${vm.unitId}` : ''}`)}
               sx={{
                 textTransform: 'none', fontSize: '0.7rem', py: 0.375, px: 1,
-                bgcolor: '#7c3aed', '&:hover': { bgcolor: '#6d28d9' }, ml: 'auto',
+                bgcolor: DS_COLORS.futureCard.controlled.accent,
+                '&:hover': { bgcolor: DS_COLORS.futureCard.controlled.accentHover },
+                ml: 'auto',
               }}
             >
               Zur Einheit →
@@ -300,11 +236,11 @@ export function FutureAvailabilityCard({ vm }: { vm: MatchCardViewModel }) {
 
         {/* Disclaimer footnote */}
         {vm.disclaimer && (
-          <Typography variant="caption" color="text.disabled" sx={{ display: 'block', mt: 1, fontSize: '0.63rem', lineHeight: 1.4, borderTop: '1px solid #f1f5f9', pt: 0.75 }}>
+          <Typography variant="caption" color="text.disabled" sx={{ display: 'block', mt: 1, fontSize: '0.63rem', lineHeight: 1.4, borderTop: `1px solid ${DS_BORDER.muted}`, pt: 0.75 }}>
             {vm.disclaimer}
           </Typography>
         )}
       </Box>
     </Box>
   )
-}
+})

src/components/match-card/IntelligenceMatchCard.tsx

@@ -1,90 +1,105 @@
-import { Box, Button, Chip, Divider, Typography } from '@mui/material'
-import {
-  Building2,
-  CheckCircle2,
-} from 'lucide-react'
+import { Box, Button, Chip, Typography } from '@mui/material'
+import { Building2, CheckCircle2, MapPin } from 'lucide-react'
 import { useSessionStore } from '../../stores/sessionStore'
+import { useInquiryStore } from '../../stores/inquiryStore'
 import { LocationPreview } from '../shared/LocationPreview'
 import { HeatBadge } from '../shared/HeatBadge'
 import { getScoreTier, SCORE_THEME } from '../shared/scoreTheme'
+import { RESULT_TYPE_META, DS_TEXT, DS_BORDER } from '../../lib/ds'
+import { confidenceHex } from '../../lib/utils'
 import type { MatchCardViewModel } from './MatchCardViewModel'
 import { FutureAvailabilityCard } from './FutureAvailabilityCard'
 
-// ── Constants ─────────────────────────────────────────────────────────────────
-
-const RESULT_TYPE_META: Record<string, { label: string; color: string }> = {
-  VERIFIED_PORTFOLIO:  { label: 'Plattform',          color: '#1e3a5f' },
-  EXTERNAL_MARKET:     { label: 'Plattform',          color: '#1e3a5f' },
-  MAISON_WORK:         { label: 'Maison Work',        color: '#0369a1' },
-  FUTURE_AVAILABILITY: { label: 'Future Availability', color: '#7c3aed' },
-}
-
-// ── Main component ────────────────────────────────────────────────────────────
-
 interface Props {
   vm: MatchCardViewModel
   imageUrl?: string
   lat?: number
   lng?: number
   cityLabel?: string
+  overlayTypeLabel?: string
+  overlayLocationLabel?: string
 }
 
-export function IntelligenceMatchCard({ vm, imageUrl, lat, lng, cityLabel }: Props) {
+export function IntelligenceMatchCard({ vm, imageUrl, lat, lng, cityLabel, overlayTypeLabel, overlayLocationLabel }: Props) {
   const tier = getScoreTier(vm.matchScore)
   const theme = SCORE_THEME[tier]
   const { currentUser } = useSessionStore()
+  const openInquiryDialog = useInquiryStore(s => s.openInquiryDialog)
   const isPortfolioOwner = currentUser?.role === 'PROPERTY_MANAGER' || currentUser?.role === 'ORGANIZATION_ADMIN'
-  const rt = RESULT_TYPE_META[vm.resultType] ?? { label: vm.resultType, color: '#64748b' }
+  const rt = RESULT_TYPE_META[vm.resultType] ?? { label: vm.resultType, color: '#9a9a9a' }
   const isFuture = vm.resultType === 'FUTURE_AVAILABILITY'
+  const confPct = Math.round(vm.confidenceScore * 100)
 
-  // Future availability cards use the new design
   if (isFuture) {
     return <FutureAvailabilityCard vm={vm} />
   }
 
+  // secondary chips — max 1 visible (availability only), no overflow chip
+  const secondaryChip = vm.availabilityLabel ?? vm.fitOutLabel ?? null
+
   return (
     <Box sx={{
       borderRadius: 2,
       overflow: 'hidden',
-      boxShadow: `0 2px 16px rgba(0,0,0,0.07), 0 0 0 1px ${theme.cardBorder}`,
-      background: theme.cardBg,
+      border: `1px solid ${DS_BORDER.default}`,
+      bgcolor: '#ffffff',
+      boxShadow: '0 1px 3px rgba(0,0,0,0.06)',
       display: 'flex',
       flexDirection: 'column',
-      transition: 'box-shadow 0.15s, transform 0.1s',
+      position: 'relative',
+      zIndex: 0,
+      transition: 'transform 0.18s ease, box-shadow 0.18s ease, border-color 0.15s',
       '&:hover': {
-        boxShadow: `0 6px 28px rgba(0,0,0,0.12), 0 0 0 1px ${theme.cardBorder}`,
-        transform: 'translateY(-1px)',
+        borderColor: '#b0aead',
+        transform: 'scale(1.025)',
+        boxShadow: '0 10px 32px rgba(0,0,0,0.13)',
+        zIndex: 1,
       },
     }}>
 
       {/* ── Hero zone ── */}
       <Box sx={{ position: 'relative' }}>
-        <LocationPreview imageUrl={imageUrl} lat={lat} lng={lng} cityLabel={cityLabel} height={175} />
+        <LocationPreview imageUrl={imageUrl} lat={lat} lng={lng} cityLabel={cityLabel} height={200} overlayTypeLabel={overlayTypeLabel} overlayLocationLabel={overlayLocationLabel} />
+
+        {/* Score badge — bottom-left editorial */}
         <Box sx={{
-          position: 'absolute', top: 10, left: 10,
-          background: theme.gradient, borderRadius: '10px',
-          px: 1.5, py: 0.5,
-          boxShadow: `0 4px 16px ${theme.glow}`,
+          position: 'absolute', bottom: 10, left: 12,
+          bgcolor: theme.gradient, borderRadius: '8px',
+          px: 1.25, py: 0.375,
           border: `1px solid ${theme.border}`,
-          minWidth: 52, textAlign: 'center',
         }}>
-          <Typography sx={{ fontWeight: 900, fontSize: '1.5rem', color: theme.text, lineHeight: 1 }}>
+          <Typography sx={{
+            fontWeight: 700, fontSize: '1.625rem',
+            color: '#ffffff', lineHeight: 1, letterSpacing: '-0.02em',
+          }}>
             {vm.matchScore}%
           </Typography>
-          {tier !== 'bronze' && (
-            <Typography sx={{ fontSize: '0.575rem', color: theme.text, opacity: 0.8, textTransform: 'uppercase', letterSpacing: 0.8, lineHeight: 1.2 }}>
-              {theme.label}
-            </Typography>
-          )}
         </Box>
-        <Box sx={{ position: 'absolute', top: 10, right: 44, display: 'flex', flexDirection: 'column', gap: 0.5, alignItems: 'flex-end' }}>
+
+        {/* Location pill — Ginesta-style, top-left */}
+        <Box sx={{
+          position: 'absolute', top: 10, left: 10,
+          bgcolor: 'rgba(255,255,255,0.92)',
+          borderRadius: '20px',
+          px: 1, py: 0.35,
+          display: 'flex', alignItems: 'center', gap: 0.4,
+          backdropFilter: 'blur(4px)',
+        }}>
+          <MapPin size={9} color="#64748b" />
+          <Typography sx={{ fontSize: '0.65rem', fontWeight: 500, color: '#374151', lineHeight: 1 }}>
+            {vm.locationLabel}
+          </Typography>
+        </Box>
+
+        {/* Top-right badge strip — result type + owner + heat */}
+        <Box sx={{ position: 'absolute', top: 10, right: 10, display: 'flex', flexDirection: 'column', gap: 0.5, alignItems: 'flex-end' }}>
           <Chip label={rt.label} size="small" sx={{ bgcolor: rt.color, color: 'white', fontWeight: 600, fontSize: 10, height: 20 }} />
           {vm.resultType === 'VERIFIED_PORTFOLIO' && isPortfolioOwner && (
             <Chip
-              icon={<Building2 size={9} color="#1e3a5f" />}
+              icon={<Building2 size={9} color="#152642" />}
               label="Ihr Objekt"
               size="small"
-              sx={{ bgcolor: 'rgba(30,58,95,0.85)', color: 'white', fontWeight: 700, fontSize: 9, height: 18, '& .MuiChip-icon': { ml: 0.5 } }}
+              sx={{ bgcolor: 'rgba(21,38,66,0.85)', color: 'white', fontWeight: 700, fontSize: 9, height: 18, '& .MuiChip-icon': { ml: 0.5 } }}
             />
           )}
           <HeatBadge propertyId={vm.propertyId} size="sm" />
@@ -92,24 +107,24 @@ export function IntelligenceMatchCard({ vm, imageUrl, lat, lng, cityLabel }: Pro
       </Box>
 
       {/* ── Card body ── */}
-      <Box sx={{ p: 2, flex: 1, display: 'flex', flexDirection: 'column', gap: 0 }}>
-        {/* Unit-first title (floor + street) */}
-        <Typography variant="subtitle1" sx={{ fontWeight: 700, lineHeight: 1.3 }} noWrap>
+      <Box sx={{ p: 2.25, flex: 1, display: 'flex', flexDirection: 'column', gap: 0 }}>
+
+        {/* Title */}
+        <Typography variant="subtitle1" sx={{ fontWeight: 700, lineHeight: 1.3, color: DS_TEXT.primary }} noWrap>
           {vm.title}
         </Typography>
-        {/* Building name as subtitle when a unit or floor range is in the title */}
         {vm.propertySubtitle && (
-          <Typography variant="caption" sx={{ display: 'block', mt: 0.125, color: '#475569', fontWeight: 500 }} noWrap>
+          <Typography variant="caption" sx={{ display: 'block', mt: 0.125, color: DS_TEXT.secondary, fontWeight: 500 }} noWrap>
             {vm.propertySubtitle}
           </Typography>
         )}
-        <Typography variant="caption" color="text.secondary" sx={{ display: 'block', mt: 0.25 }}>
+        <Typography variant="caption" sx={{ color: DS_TEXT.muted, display: 'block', mt: 0.25 }}>
           {[vm.locationLabel, vm.availabilityLabel].filter(Boolean).join(' · ')}
         </Typography>
 
-        {/* Unit area + rent when a specific unit is matched */}
+        {/* Unit details */}
         {vm.preMarketUnit && (
-          <Typography variant="caption" sx={{ color: '#64748b', fontSize: '0.68rem', mt: 0.25 }}>
+          <Typography variant="caption" sx={{ color: DS_TEXT.muted, fontSize: '0.68rem', mt: 0.25 }}>
             {vm.preMarketUnit.areaSqm.toLocaleString('de-CH')} m²
             {vm.preMarketUnit.rentPricePerSqm
               ? ` · CHF ${Math.round(vm.preMarketUnit.rentPricePerSqm / 12).toLocaleString('de-CH')}/m²/Mt.`
@@ -117,43 +132,64 @@ export function IntelligenceMatchCard({ vm, imageUrl, lat, lng, cityLabel }: Pro
           </Typography>
         )}
 
-        {/* Regular explainability summary */}
+        {/* Confidence + one secondary chip max */}
+        <Box sx={{ display: 'flex', flexWrap: 'wrap', gap: 0.5, mt: 1, alignItems: 'center' }}>
+          <Chip label={`${confPct}% Konfidenz`} size="small"
+            sx={{ bgcolor: confidenceHex(vm.confidenceScore), color: 'white', fontSize: 10, height: 20 }} />
+          {secondaryChip && (
+            <Chip label={secondaryChip} size="small" variant="outlined"
+              sx={{ fontSize: 10, height: 20, borderColor: DS_BORDER.default, color: DS_TEXT.secondary }} />
+          )}
+        </Box>
+
+        {/* Explainability */}
         {vm.explainabilitySummary && (
-          <>
-            <Divider sx={{ my: 1.25 }} />
-            <Typography variant="body2" sx={{
-              fontWeight: 500, color: '#1e293b', lineHeight: 1.5, flex: 1,
-              overflow: 'hidden', display: '-webkit-box',
-              WebkitLineClamp: 3, WebkitBoxOrient: 'vertical',
-            }}>
-              {vm.explainabilitySummary}
-            </Typography>
-          </>
+          <Typography variant="body2" sx={{
+            fontWeight: 500, color: DS_TEXT.secondary, lineHeight: 1.5, flex: 1, mt: 1,
+            overflow: 'hidden', display: '-webkit-box',
+            WebkitLineClamp: 3, WebkitBoxOrient: 'vertical',
+          }}>
+            {vm.explainabilitySummary}
+          </Typography>
         )}
 
         {vm.reasons.length > 0 && (
-          <>
-            <Divider sx={{ my: 1.25 }} />
-            <Box sx={{ display: 'flex', flexDirection: 'column', gap: 0.625 }}>
-              {vm.reasons.slice(0, 3).map((r, i) => (
-                <Box key={i} sx={{ display: 'flex', alignItems: 'flex-start', gap: 0.75 }}>
-                  <CheckCircle2 size={13} color="#1a7a4a" style={{ marginTop: 2, flexShrink: 0 }} />
-                  <Box>
-                    <Typography sx={{ fontSize: '0.75rem', fontWeight: 600, color: '#1e293b', lineHeight: 1.3 }}>
-                      {r.label}
-                    </Typography>
-                    <Typography sx={{ fontSize: '0.72rem', color: '#64748b', lineHeight: 1.3 }}>
-                      {r.explanation}
-                    </Typography>
-                  </Box>
+          <Box sx={{ display: 'flex', flexDirection: 'column', gap: 0.5, mt: 1 }}>
+            {vm.reasons.slice(0, 2).map((r, i) => (
+              <Box key={i} sx={{ display: 'flex', alignItems: 'flex-start', gap: 0.75 }}>
+                <CheckCircle2 size={13} color="#1d6342" style={{ marginTop: 2, flexShrink: 0 }} />
+                <Box>
+                  <Typography sx={{ fontSize: '0.75rem', fontWeight: 600, color: DS_TEXT.primary, lineHeight: 1.3 }}>
+                    {r.label}
+                  </Typography>
+                  <Typography sx={{ fontSize: '0.72rem', color: DS_TEXT.muted, lineHeight: 1.3 }}>
+                    {r.explanation}
+                  </Typography>
                 </Box>
-              ))}
-            </Box>
-          </>
+              </Box>
+            ))}
+          </Box>
         )}
 
         {/* Actions */}
-        <Box sx={{ display: 'flex', gap: 0.75, mt: 1.5, pt: 1.25, borderTop: '1px solid rgba(0,0,0,0.06)' }}>
+        <Box sx={{ display: 'flex', flexWrap: 'wrap', gap: 0.75, mt: 1.5, pt: 1.25, borderTop: `1px solid ${DS_BORDER.muted}` }}>
+          <Button
+            size="small"
+            variant="contained"
+            onClick={e => {
+              e.stopPropagation()
+              openInquiryDialog({
+                propertyTitle: vm.title,
+                location: vm.locationLabel ?? '',
+                matchScore: vm.matchScore,
+                matchId: vm.id,
+                propertyId: vm.propertyId,
+              })
+            }}
+            sx={{ textTransform: 'none', fontSize: '0.7rem', py: 0.375, px: 1, bgcolor: '#152642', '&:hover': { bgcolor: '#0e1c30' } }}
+          >
+            Anfrage
+          </Button>
           {vm.actions.map(a => (
             <Button
               key={a.id}
@@ -161,13 +197,7 @@ export function IntelligenceMatchCard({ vm, imageUrl, lat, lng, cityLabel }: Pro
               variant={a.variant === 'primary' ? 'contained' : 'outlined'}
               onClick={a.onClick}
               disabled={a.disabled}
-              sx={{
-                textTransform: 'none', fontSize: '0.7rem', py: 0.375, px: 1,
-                ...(a.variant === 'primary' && {
-                  bgcolor: '#1e3a5f',
-                  '&:hover': { bgcolor: '#162d4a' },
-                }),
-              }}
+              sx={{ textTransform: 'none', fontSize: '0.7rem', py: 0.375, px: 1 }}
             >
               {a.label}
             </Button>

src/components/match-card/MatchActionToolbar.tsx

@@ -26,7 +26,7 @@ export function MatchActionToolbar({ actions }: Props) {
           onClick={action.onClick}
           sx={
             action.variant === 'primary'
-              ? { bgcolor: '#1e3a5f', '&:hover': { bgcolor: '#162d4a' } }
+              ? { bgcolor: '#152642', '&:hover': { bgcolor: '#162d4a' } }
               : action.variant === 'danger'
               ? { color: '#c0392b', borderColor: '#c0392b', '&:hover': { borderColor: '#c0392b' } }
               : {}

src/components/match-card/MatchCardCompact.tsx

@@ -1,119 +1,202 @@
-import { Alert, Box, Card, Divider, Typography } from '@mui/material'
-import { MapPin } from 'lucide-react'
-import { MatchCardHeader } from './MatchCardHeader'
-import { MatchReasonList } from './MatchReasonList'
-import { TradeoffList } from './TradeoffList'
-import { MatchDataQualitySummary } from './MatchDataQualitySummary'
-import { MatchActionToolbar } from './MatchActionToolbar'
+import { memo } from 'react'
+import { Alert, Box, Button, Chip, Typography } from '@mui/material'
+import { MapPin, AlertTriangle } from 'lucide-react'
+import { useSessionStore } from '../../stores/sessionStore'
+import { useInquiryStore } from '../../stores/inquiryStore'
+import { HeatBadge } from '../shared/HeatBadge'
+import { getScoreTier, SCORE_THEME } from '../shared/scoreTheme'
+import { RESULT_TYPE_META, DS_TEXT, DS_BORDER } from '../../lib/ds'
+import { confidenceHex } from '../../lib/utils'
 import { MatchCardRestrictedState } from './MatchCardRestrictedState'
-import { ScoreInlineBreakdown } from './ScoreInlineBreakdown'
 import type { MatchCardViewModel } from './MatchCardViewModel'
 
 interface Props {
   vm: MatchCardViewModel
+  imageUrl?: string
 }
 
-export function MatchCardCompact({ vm }: Props) {
+export const MatchCardCompact = memo(function MatchCardCompact({ vm, imageUrl }: Props) {
   if (vm.isRestricted) return <MatchCardRestrictedState />
 
-  const borderColor = vm.isCompareSelected
-    ? '#7c3aed'
-    : vm.isSelected
-    ? '#1e3a5f'
-    : 'transparent'
+  const { currentUser } = useSessionStore()
+  const openInquiryDialog = useInquiryStore(s => s.openInquiryDialog)
+  const isPortfolioOwner = currentUser?.role === 'PROPERTY_MANAGER' || currentUser?.role === 'ORGANIZATION_ADMIN'
+
+  const tier = getScoreTier(vm.matchScore)
+  const scoreBadgeBg = SCORE_THEME[tier].gradient
+  const rt = RESULT_TYPE_META[vm.resultType] ?? { label: vm.resultType, color: '#9a9a9a' }
+  const confPct = Math.round(vm.confidenceScore * 100)
+  const topRisk = vm.risks.find(r => r.level === 'CRITICAL' || r.level === 'HIGH')
+
+  const leftAccent = vm.isCompareSelected ? '#5b3f8a' : vm.isSelected ? '#152642' : 'transparent'
+
+  // Compact metric line — area · rent · availability
+  const metricParts: string[] = []
+  if (vm.areaSqm) metricParts.push(`${vm.areaSqm.toLocaleString('de-CH')} m²`)
+  if (vm.rentPerSqm) metricParts.push(`CHF ${vm.rentPerSqm}/m²/J`)
+  if (vm.availabilityLabel) metricParts.push(vm.availabilityLabel)
+  const metricLine = metricParts.join('  ·  ')
+
+  // Detail action — prefer the "Details →" action if available, fallback to first action
+  const detailAction = vm.actions.find(a => a.actionType === 'OPEN_DETAIL' && a.label.includes('Detail'))
+    ?? vm.actions.find(a => a.actionType === 'OPEN_DETAIL')
 
   return (
-    <Card
-      sx={{
-        p: 2.5,
-        mb: 1.5,
-        border: `2px solid ${borderColor}`,
-        opacity: vm.isStaleData ? 0.75 : 1,
-        transition: 'border-color 0.15s',
-      }}
-    >
-      {/* FUTURE_AVAILABILITY disclaimer — mandatory, non-dismissable */}
-      {vm.disclaimer && (
-        <Alert severity="warning" sx={{ mb: 1.5, py: 0.5 }}>
-          {vm.disclaimer}
-        </Alert>
-      )}
+    <Box sx={{
+      display: 'flex',
+      borderRadius: 2,
+      overflow: 'hidden',
+      border: `1px solid ${DS_BORDER.default}`,
+      borderLeft: `3px solid ${leftAccent}`,
+      bgcolor: '#ffffff',
+      boxShadow: '0 1px 3px rgba(0,0,0,0.06)',
+      opacity: vm.isStaleData ? 0.75 : 1,
+      transition: 'border-color 0.15s, transform 0.18s ease, box-shadow 0.18s ease',
+      position: 'relative',
+      zIndex: 0,
+      '&:hover': {
+        borderColor: '#b0aead',
+        transform: 'scale(1.012)',
+        boxShadow: '0 6px 20px rgba(0,0,0,0.10)',
+        zIndex: 1,
+      },
+    }}>
 
-      {vm.isReviewRequired && (
-        <Alert severity="info" sx={{ mb: 1.5, py: 0.5 }}>
-          Manuelle Überprüfung erforderlich
-        </Alert>
-      )}
-
-      {/* Header: score → type → confidence → availability → risk */}
-      <MatchCardHeader vm={vm} compact />
-
-      {/* Title + location (max 2 lines) */}
-      <Box sx={{ mt: 1.25, mb: 1.25 }}>
-        <Typography variant="subtitle1" sx={{ fontWeight: 600 }} noWrap>
-          {vm.title}
-        </Typography>
-        {vm.propertySubtitle && (
-          <Typography variant="caption" sx={{ display: 'block', color: '#64748b', fontWeight: 500, mt: 0.125 }} noWrap>
-            {vm.propertySubtitle}
-          </Typography>
+      {/* ── Image strip — 180px, Ginesta proportion ── */}
+      <Box sx={{ width: 180, flexShrink: 0, position: 'relative', bgcolor: '#f4f3f0' }}>
+        {imageUrl ? (
+          <img
+            src={imageUrl}
+            alt=""
+            style={{ width: '100%', height: '100%', objectFit: 'cover', display: 'block' }}
+          />
+        ) : (
+          <Box sx={{
+            width: '100%', height: '100%', minHeight: 140,
+            display: 'flex', alignItems: 'center', justifyContent: 'center',
+            bgcolor: '#f4f3f0',
+          }}>
+            <MapPin size={24} color="#c4c4c4" />
+          </Box>
         )}
-        <Box sx={{ display: 'flex', alignItems: 'center', gap: 0.5, mt: 0.25 }}>
-          <MapPin size={13} color="#64748b" />
-          <Typography variant="body2" color="text.secondary">
+
+        {/* Score badge — top left */}
+        <Box sx={{
+          position: 'absolute', top: 8, left: 8,
+          bgcolor: scoreBadgeBg, borderRadius: '6px',
+          px: 0.875, py: 0.25,
+          border: `1px solid ${SCORE_THEME[tier].border}`,
+        }}>
+          <Typography sx={{
+            fontWeight: 700, fontSize: '1.125rem',
+            color: '#ffffff', lineHeight: 1, letterSpacing: '-0.01em',
+          }}>
+            {vm.matchScore}%
+          </Typography>
+        </Box>
+
+        {/* Location pill — Ginesta-style, top right */}
+        <Box sx={{
+          position: 'absolute', top: 8, right: 8,
+          bgcolor: 'rgba(255,255,255,0.92)',
+          borderRadius: '20px',
+          px: 1, py: 0.35,
+          display: 'flex', alignItems: 'center', gap: 0.4,
+          backdropFilter: 'blur(4px)',
+        }}>
+          <MapPin size={9} color="#64748b" />
+          <Typography sx={{ fontSize: '0.65rem', fontWeight: 500, color: '#374151', lineHeight: 1 }}>
             {vm.locationLabel}
           </Typography>
         </Box>
+      </Box>
+
+      {/* ── Content ── */}
+      <Box sx={{ flex: 1, px: 2, py: 2.5, display: 'flex', flexDirection: 'column', minWidth: 0 }}>
+
+        {vm.disclaimer && (
+          <Alert severity="warning" sx={{ mb: 1, py: 0.25, fontSize: '0.72rem' }}>{vm.disclaimer}</Alert>
+        )}
+
+        {/* Chips — result type + heat + confidence */}
+        <Box sx={{ display: 'flex', gap: 0.5, alignItems: 'center', mb: 0.875 }}>
+          <Chip label={rt.label} size="small"
+            sx={{ bgcolor: rt.color, color: 'white', fontWeight: 600, fontSize: 10, height: 20 }} />
+          <HeatBadge propertyId={vm.propertyId} size="sm" />
+          <Chip label={`${confPct}% Konfidenz`} size="small"
+            sx={{ bgcolor: confidenceHex(vm.confidenceScore), color: 'white', fontSize: 10, height: 20 }} />
+          {vm.resultType === 'VERIFIED_PORTFOLIO' && isPortfolioOwner && (
+            <Chip label="Ihr Objekt" size="small"
+              sx={{ bgcolor: 'rgba(21,38,66,0.10)', color: '#152642', fontWeight: 700, fontSize: 9, height: 18 }} />
+          )}
+        </Box>
+
+        {/* Title */}
+        <Typography variant="subtitle2" sx={{ fontWeight: 700, lineHeight: 1.3, color: DS_TEXT.primary }} noWrap>
+          {vm.title}
+        </Typography>
+        {vm.propertySubtitle && (
+          <Typography variant="caption" sx={{ color: DS_TEXT.secondary, fontWeight: 500, display: 'block', mt: 0.1 }} noWrap>
+            {vm.propertySubtitle}
+          </Typography>
+        )}
+
+        {/* Metric line — Ginesta-style */}
+        {metricLine && (
+          <Typography sx={{ fontSize: '0.75rem', color: '#94a3b8', mt: 0.5, letterSpacing: 0.1 }}>
+            {metricLine}
+          </Typography>
+        )}
+
+        {/* Explainability summary — 1 line */}
         {vm.explainabilitySummary && (
-          <Typography
-            variant="body2"
-            color="text.secondary"
-            sx={{
-              mt: 0.5,
-              overflow: 'hidden',
-              display: '-webkit-box',
-              WebkitLineClamp: 2,
-              WebkitBoxOrient: 'vertical',
-            }}
-          >
+          <Typography variant="body2" sx={{
+            color: DS_TEXT.secondary, fontWeight: 500, mt: 0.875, lineHeight: 1.5,
+            overflow: 'hidden', display: '-webkit-box', WebkitLineClamp: 1, WebkitBoxOrient: 'vertical',
+          }}>
             {vm.explainabilitySummary}
           </Typography>
         )}
+
+        {/* Critical risk only */}
+        {topRisk && topRisk.level === 'CRITICAL' && (
+          <Alert icon={<AlertTriangle size={13} />} severity="error"
+            sx={{ mt: 0.75, py: 0.25, fontSize: '0.72rem' }}>
+            {topRisk.description}
+          </Alert>
+        )}
+
+        {/* 2 Buttons — Anfrage + Details */}
+        <Box sx={{ display: 'flex', gap: 0.625, mt: 'auto', pt: 1.25 }}>
+          <Button
+            size="small"
+            variant="contained"
+            onClick={e => {
+              e.stopPropagation()
+              openInquiryDialog({
+                propertyTitle: vm.title,
+                location: vm.locationLabel ?? '',
+                matchScore: vm.matchScore,
+                matchId: vm.id,
+                propertyId: vm.propertyId,
+              })
+            }}
+            sx={{ textTransform: 'none', fontSize: '0.7rem', py: 0.375, px: 1, bgcolor: '#152642', '&:hover': { bgcolor: '#0e1c30' } }}
+          >
+            Anfrage
+          </Button>
+          {detailAction && (
+            <Button
+              size="small"
+              variant="outlined"
+              onClick={detailAction.onClick}
+              sx={{ textTransform: 'none', fontSize: '0.7rem', py: 0.375, px: 1 }}
+            >
+              Details →
+            </Button>
+          )}
+        </Box>
       </Box>
-
-      <Divider sx={{ mb: 1.25 }} />
-
-      {/* Score formula — always visible */}
-      {vm.scoreBreakdown && (
-        <Box sx={{ mb: 1.25 }}>
-          <ScoreInlineBreakdown scoreBreakdown={vm.scoreBreakdown} allFactors={vm.allFactors} compact />
-        </Box>
-      )}
-
-      {/* Top reason only */}
-      {vm.reasons.length > 0 && (
-        <Box sx={{ mb: 1 }}>
-          <MatchReasonList reasons={vm.reasons.slice(0, 1)} />
-        </Box>
-      )}
-
-      {/* Top tradeoff only (compact) */}
-      {vm.tradeoffs.length > 0 && (
-        <Box sx={{ mb: 1 }}>
-          <TradeoffList tradeoffs={vm.tradeoffs.slice(0, 1)} compact />
-        </Box>
-      )}
-
-      {/* Data quality — only critical warning in compact mode */}
-      <MatchDataQualitySummary
-        dataQualityScore={vm.dataQualityScore}
-        missingData={vm.missingData}
-        compact
-      />
-
-      <Box sx={{ mt: 1.25 }}>
-        <MatchActionToolbar actions={vm.actions} compact />
-      </Box>
-    </Card>
+    </Box>
   )
-}
+})

src/components/match-card/MatchCardCompareMini.tsx

@@ -4,8 +4,7 @@ import { MatchScoreDisplay } from './MatchScoreDisplay'
 import type { MatchCardViewModel } from './MatchCardViewModel'
 
 const RESULT_TYPE_META: Record<string, { label: string; color: string }> = {
-  VERIFIED_PORTFOLIO:  { label: 'Verified',    color: '#1e3a5f' },
-  EXTERNAL_MARKET:     { label: 'Direkt',      color: '#d97706' },
+  VERIFIED_PORTFOLIO:  { label: 'Verified',    color: '#152642' },
   MAISON_WORK:         { label: 'Maison Work', color: '#0369a1' },
   FUTURE_AVAILABILITY: { label: 'Signal',      color: '#7c3aed' },
 }

src/components/match-card/MatchCardHeader.tsx

@@ -3,21 +3,10 @@ import { Building2 } from 'lucide-react'
 import { MatchScoreDisplay } from './MatchScoreDisplay'
 import { HeatBadge } from '../shared'
 import { useSessionStore } from '../../stores/sessionStore'
+import { RESULT_TYPE_META } from '../../lib/ds'
+import { confidenceHex } from '../../lib/utils'
 import type { MatchCardViewModel } from './MatchCardViewModel'
 
-const RESULT_TYPE_META: Record<string, { label: string; color: string }> = {
-  VERIFIED_PORTFOLIO:  { label: 'Plattform',      color: '#1e3a5f' },
-  EXTERNAL_MARKET:     { label: 'Plattform',      color: '#1e3a5f' },
-  MAISON_WORK:         { label: 'Maison Work',    color: '#0369a1' },
-  FUTURE_AVAILABILITY: { label: 'Zukunftssignal', color: '#7c3aed' },
-}
-
-function confidenceColor(score: number): string {
-  if (score >= 0.75) return '#1a7a4a'
-  if (score >= 0.55) return '#d97706'
-  return '#c0392b'
-}
-
 interface Props {
   vm: MatchCardViewModel
   compact?: boolean
@@ -49,10 +38,10 @@ export function MatchCardHeader({ vm, compact }: Props) {
         />
         {vm.resultType === 'VERIFIED_PORTFOLIO' && isPortfolioOwner && (
           <Chip
-            icon={<Building2 size={10} color="#1e3a5f" />}
+            icon={<Building2 size={10} color="#152642" />}
             label="Ihr Objekt"
             size="small"
-            sx={{ bgcolor: 'rgba(30,58,95,0.12)', color: '#1e3a5f', fontWeight: 700, fontSize: 11, '& .MuiChip-icon': { ml: 0.5 } }}
+            sx={{ bgcolor: 'rgba(30,58,95,0.12)', color: '#152642', fontWeight: 700, fontSize: 11, '& .MuiChip-icon': { ml: 0.5 } }}
           />
         )}
         {vm.assetType && (
@@ -61,7 +50,7 @@ export function MatchCardHeader({ vm, compact }: Props) {
         <Chip
           label={`${confPct}% Konfidenz`}
           size="small"
-          sx={{ bgcolor: confidenceColor(vm.confidenceScore), color: 'white', fontSize: 11 }}
+          sx={{ bgcolor: confidenceHex(vm.confidenceScore), color: 'white', fontSize: 11 }}
         />
         {vm.availabilityLabel && (
           <Chip label={vm.availabilityLabel} size="small" variant="outlined" sx={{ fontSize: 11 }} />

src/components/match-card/MatchCardViewModel.ts

@@ -1,6 +1,7 @@
 import type { ResultType } from '../../domain/enums'
 import type { TradeOff, Risk, MissingDataItem, ScoreFactor } from '../../domain/match'
 import type { PropertyUnit } from '../../domain/property'
+import type { FitOutInvestment } from '../../lib/fitOutUtils'
 
 export type MatchCardVariant = 'compact' | 'expanded' | 'review' | 'compare-mini'
 
@@ -67,6 +68,15 @@ export interface MatchCardViewModel {
   signalIsControlled?: boolean
   signalAreaSqmEstimate?: number
 
+  // Divisibility (Teilbarkeit)
+  isDivisible?: boolean
+  minDivisibleUnitSqm?: number
+
+  // Fit-out signal
+  fitOutLabel?: string   // e.g. "FULL — bezugsfertig", "BASIC + CHF 200 MAB"
+  fitOutViable?: boolean // true when budget bridges the gap
+  fitOutInvestment?: FitOutInvestment
+
   // Unit-first display (primary)
   propertySubtitle?: string  // building name shown below the unit title
 
@@ -76,6 +86,10 @@ export interface MatchCardViewModel {
   preMarketUnit?: PropertyUnit   // specific unit being released pre-market
   preMarketAllUnits?: PropertyUnit[] // all units of the backing property
 
+  // Key metrics for compact display (Ginesta-style metric line)
+  areaSqm?: number
+  rentPerSqm?: number
+
   // Score transparency
   scoreBreakdown?: {
     hardMatchScore: number