style: prettier formatting for case-study content rewrite

Re-audited both apps (full codebase + docs) and rewrote both case studies to a
professional-SaaS structure: Solution and Feature Showcase are new sections
(schema + FeatureList component), Engineering Highlights/Challenges reframe the
existing architecture/decisions content around real, verified engineering work
(deterministic CV match, multi-provider email abstraction, SSRF-hardened
fetcher, hybrid RRF search, preview-then-confirm cleanup), and Status & roadmap
now separates Implemented from Planned explicitly. InboxIntel copy is careful
to state it's Gmail-only today with multi-provider fully designed but not built.

.gitea/workflows/ci.yml

@@ -30,7 +30,8 @@ jobs:
       - uses: pnpm/action-setup@v4
         with: { version: 9 }
       - uses: actions/setup-node@v4
-        with: { node-version: 22, cache: pnpm }
+        with:
+          { node-version: 22, cache: pnpm, cache-dependency-path: '**/pnpm-lock.yaml' }
       - run: pnpm -C site install --frozen-lockfile
       - run: pnpm -C tests install --frozen-lockfile
       - run: pnpm -C tests exec playwright install --with-deps chromium
@@ -43,7 +44,7 @@ jobs:
       - uses: pnpm/action-setup@v4
         with: { version: 9 }
       - uses: actions/setup-node@v4
-        with: { node-version: 22, cache: pnpm }
+        with: { node-version: 22, cache: pnpm, cache-dependency-path: site/pnpm-lock.yaml }
       - run: pnpm -C site install --frozen-lockfile
       - run: pnpm -C site build
       - run: pnpm dlx @lhci/cli@0.14.x autorun --config=site/lighthouserc.json

PROJECT_STATUS.md

@@ -59,25 +59,26 @@
 6. **Theme-init is an external script** (`/theme-init.js`) so the CSP can use `script-src
    'self'` with no inline hash.
 
-## Pre-launch checklist (owner action)
+## Deployed — live
 
-- [x] ~~`/Linkedin` redirect target~~ — set to `https://www.linkedin.com/in/connor-babbington`.
-- [x] ~~JobTrack seed-data screenshots~~ — real captures integrated (`/assets/projects/jobtrack/`).
-- [x] ~~Real headshot~~ — integrated (`/assets/portrait.webp`, hero + about).
-- [x] ~~ATS-safe CV rework (EN/NO)~~ — done; generator in `tools/cv/`.
-- [ ] **InboxIntel screenshots** — still placeholders (no captures provided; it is "in development").
-- [ ] **Native-Norwegian review** of all NO content, incl. the NO CV (launch gate).
-- [ ] **Legacy WordPress URL inventory** → confirm the 301/410 map in `nginx.conf`.
-- [ ] Configure CI secrets (`REGISTRY_USER`, `REGISTRY_TOKEN`) + the relay `.env` on the server.
-- [ ] Confirm the Traefik entrypoint / cert-resolver names in `deploy/.env.example` match the host.
+- **Live on the `mediaserver` host at `http://<host>:1337`.** Stack: `deploy-site-1`
+  (nginx static, publishes 1337) + `deploy-relay-1` (contact relay, internal). Verified: all
+  routes + `/no/`, case studies, CV PDFs, images, `/Linkedin` 301, `/api/contact` proxy.
+- **Auto-deploy:** a 1-minute cron on the host (`deploy/autodeploy.sh`) pulls `main` and
+  `docker compose up -d --build` on change. Sole deploy path — the Gitea Actions `deploy.yml`
+  job was removed (its runner's job containers have no Docker socket, and mounting one in would
+  give any CI job root-equivalent host access).
+- Repo cloned at `/home/pi/resumesite` (remote carries the deploy token — rotate/scrub if desired).
 
-## Infrastructure (verified live, July 2026)
+## Owner action remaining
 
-Deploy target is the `mediaserver` host (Ubuntu 24.04): ~30 Docker services behind **Traefik**
-(Cloudflare-fronted, TLS, HTTP/3), with **Authentik** SSO, **CrowdSec**, **Pi-hole**, and
-self-hosted **Gitea + Actions runner** (the CI/CD target for this site). The homelab case study
-and `deploy/` now reflect this (Traefik labels, `traefik_proxy` network). WordPress still runs
-but is being decommissioned as this site replaces it — not documented as future architecture.
+- [ ] **Point Cloudflare / your TLS proxy at host:1337** to serve it on `cesnimda.co.uk`
+      (retire the WordPress apex router as part of the cutover).
+- [ ] **Relay SMTP** — add creds to `/home/pi/resumesite/deploy/.env` (`SMTP_HOST/USER/PASSWORD`)
+      so the contact form sends; until then it degrades to the visible e-mail (POST returns 502).
+- [ ] **Native-Norwegian review** of all NO content, incl. the NO CV.
+- [ ] **InboxIntel screenshots** — mockups are in; swap for live captures if/when available.
+- [ ] **Legacy WordPress URL inventory** → confirm the 410 map in `nginx.conf`.
 
 ## Resolved
 

deploy/.env.example

@@ -14,7 +14,6 @@ RELAY_WINDOW_SECONDS=600
 # --- Site build ---
 PUBLIC_SITE_URL=https://cesnimda.co.uk
 
-# --- Infra (Traefik host reverse proxy) ---
-PROXY_NETWORK=traefik_proxy       # existing external Traefik docker network
-SITE_HOST=cesnimda.co.uk          # Host rule for the Traefik routers
-TRAEFIK_ENTRYPOINT=websecure-external  # Traefik entrypoint name on the host
+# --- Infra ---
+SITE_PORT=1337           # host port the public-facing site is published on
+                         # (put Cloudflare / your TLS proxy in front of it)

deploy/autodeploy.sh

@@ -0,0 +1,15 @@
+#!/bin/sh
+# Poll-based auto-deploy: pull main and rebuild the stack when it changes.
+# ponytail: 1-minute cron poll, not a webhook — swap for the Gitea runner
+# (.gitea/workflows/deploy.yml) once the runner's job image has the Docker CLI + socket.
+set -e
+REPO=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)   # repo root, wherever this lives
+exec 9>/tmp/resumesite-deploy.lock
+flock -n 9 || exit 0            # a build is already running
+cd "$REPO"
+git fetch -q origin main
+[ "$(git rev-parse HEAD)" = "$(git rev-parse origin/main)" ] && exit 0
+git reset -q --hard origin/main
+ENVFILE=""
+[ -f deploy/.env ] && ENVFILE="--env-file deploy/.env"
+docker compose $ENVFILE -f deploy/docker-compose.yml up -d --build --remove-orphans

deploy/docker-compose.yml

@@ -1,8 +1,6 @@
-# Production stack (DOCKER_SPEC §2). Publishes no host ports — Traefik (the host's
-# existing reverse proxy) discovers these containers on the shared traefik_proxy
-# network via the labels below and routes cesnimda.co.uk to the site, and
-# cesnimda.co.uk/api/contact to the relay. Entrypoint / cert-resolver names match
-# the host Traefik convention; override via the .env values if they differ.
+# Production stack. The public-facing site is published on host port 1337 (put your
+# TLS terminator / Cloudflare in front of it). nginx inside the site container proxies
+# /api/contact to the relay over the internal network, so only one port is exposed.
 
 services:
   site:
@@ -16,14 +14,11 @@ services:
       - /tmp
       - /var/cache/nginx
       - /var/run
-    networks: [proxy]
-    labels:
-      - traefik.enable=true
-      - traefik.docker.network=${PROXY_NETWORK:-traefik_proxy}
-      - traefik.http.routers.resumesite.rule=Host(`${SITE_HOST:-cesnimda.co.uk}`)
-      - traefik.http.routers.resumesite.entrypoints=${TRAEFIK_ENTRYPOINT:-websecure-external}
-      - traefik.http.routers.resumesite.tls=true
-      - traefik.http.services.resumesite.loadbalancer.server.port=8080
+    ports:
+      - '${SITE_PORT:-1337}:1337'
+    depends_on:
+      - relay
+    networks: [web]
     logging:
       driver: json-file
       options: { max-size: '10m', max-file: '3' }
@@ -36,29 +31,20 @@ services:
     restart: unless-stopped
     read_only: true
     environment:
-      - Smtp__Host=${SMTP_HOST}
+      - Smtp__Host=${SMTP_HOST:-}
       - Smtp__Port=${SMTP_PORT:-587}
-      - Smtp__User=${SMTP_USER}
-      - Smtp__Password=${SMTP_PASSWORD}
+      - Smtp__User=${SMTP_USER:-}
+      - Smtp__Password=${SMTP_PASSWORD:-}
       - Relay__FromAddress=${RELAY_FROM:-}
-      - Relay__ToAddress=${RELAY_TO}
+      - Relay__ToAddress=${RELAY_TO:-connor.babbington@cesnimda.co.uk}
       - Relay__AllowedOrigin=${RELAY_ALLOWED_ORIGIN:-https://cesnimda.co.uk}
       - Relay__RateLimitPerWindow=${RELAY_RATE_LIMIT:-5}
       - Relay__WindowSeconds=${RELAY_WINDOW_SECONDS:-600}
-    networks: [proxy]
-    labels:
-      - traefik.enable=true
-      - traefik.docker.network=${PROXY_NETWORK:-traefik_proxy}
-      # More specific rule than the site router, so /api/contact wins.
-      - traefik.http.routers.resumerelay.rule=Host(`${SITE_HOST:-cesnimda.co.uk}`) && PathPrefix(`/api/contact`)
-      - traefik.http.routers.resumerelay.entrypoints=${TRAEFIK_ENTRYPOINT:-websecure-external}
-      - traefik.http.routers.resumerelay.tls=true
-      - traefik.http.services.resumerelay.loadbalancer.server.port=8081
+    networks: [web]
     logging:
       driver: json-file
       options: { max-size: '10m', max-file: '3' }
 
 networks:
-  proxy:
-    external: true
-    name: ${PROXY_NETWORK:-traefik_proxy}
+  web:
+    driver: bridge

site/Dockerfile

@@ -14,5 +14,5 @@ RUN pnpm build
 FROM nginxinc/nginx-unprivileged:1.27-alpine AS final
 COPY --chown=nginx:nginx nginx.conf /etc/nginx/conf.d/default.conf
 COPY --from=build --chown=nginx:nginx /app/dist /usr/share/nginx/html
-EXPOSE 8080
+EXPOSE 1337
 # runs as uid 101 (nginx) by default in this image

site/astro.config.mjs

@@ -26,6 +26,10 @@ export default defineConfig({
   compressHTML: true,
   vite: {
     plugins: [tailwindcss()],
+    // Never inline JS: the deployed CSP is `script-src 'self'`, which blocks inline
+    // <script> modules. Keep hoisted scripts as external /_astro/*.js so CSP allows them.
+    // (Images etc. fall back to the default inline threshold.)
+    build: { assetsInlineLimit: (file) => (file.endsWith('.js') ? false : undefined) },
     resolve: {
       alias: {
         '@': r('./src'),

site/nginx.conf

@@ -3,7 +3,7 @@
 # trailing slashes, the preserved /Linkedin redirect, and legacy-WP 410s.
 
 server {
-    listen 8080;
+    listen 1337;
     server_name _;
     root /usr/share/nginx/html;
     index index.html;
@@ -32,6 +32,14 @@ server {
         return 301 https://www.linkedin.com/in/connor-babbington;
     }
 
+    # --- Contact relay (same-origin; single public port) ---
+    location = /api/contact {
+        proxy_pass http://relay:8081;
+        proxy_set_header Host $host;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+
     # --- Legacy WordPress URLs -> 410 Gone (crawler cleanup) ---
     location ~* ^/(wp-admin|wp-login|wp-content|wp-includes|wp-json|xmlrpc\.php|feed|comments/feed) {
         return 410;
@@ -59,11 +67,10 @@ server {
         add_header Cache-Control "public, must-revalidate" always;
     }
 
-    # --- Canonical trailing slash for extensionless paths (SEO) ---
-    rewrite ^([^.]*[^/])$ $1/ permanent;
-
-    # --- HTML documents: revalidate so deploys are instant (inherits headers above) ---
+    # --- HTML documents: canonical trailing slash + revalidate. Kept inside the
+    #     catch-all so exact routes (e.g. /api/contact) are never slash-redirected. ---
     location / {
+        rewrite ^([^.]*[^/])$ $1/ permanent;
         try_files $uri $uri/ =404;
     }
 

site/src/components/case-study/FeatureList.astro

@@ -0,0 +1,28 @@
+---
+interface Feature {
+  title: string;
+  value: string;
+  technical: string;
+}
+interface Props {
+  features: Feature[];
+}
+const { features } = Astro.props;
+---
+
+<ol class="flex flex-col gap-5">
+  {
+    features.map((f, i) => (
+      <li class="border-line bg-surface-1 rounded-md border p-5">
+        <p class="flex gap-3">
+          <span class="text-body text-accent font-mono font-semibold">
+            {String(i + 1).padStart(2, '0')}
+          </span>
+          <span class="text-ink font-semibold">{f.title}</span>
+        </p>
+        <p class="text-body text-ink-muted mt-2 pl-8">{f.value}</p>
+        <p class="text-small text-ink-faint border-line mt-2 ml-8 border-l pl-3">{f.technical}</p>
+      </li>
+    ))
+  }
+</ol>

site/src/components/case-study/MiniToc.astro

@@ -10,7 +10,7 @@ const { locale, sections } = Astro.props;
 const d = useDict(locale);
 ---
 
-<nav class="sticky top-24 hidden xl:block" aria-label={d.project.onThisPage}>
+<nav class="sticky top-24 hidden self-start xl:block" aria-label={d.project.onThisPage}>
   <p class="mono-label mb-3">{d.project.onThisPage}</p>
   <ul class="border-line flex flex-col gap-2 border-l">
     {

site/src/components/case-study/SectionRenderer.astro

@@ -2,6 +2,7 @@
 import type { Locale } from '@i18n/locales';
 import ArchDiagram from '@components/case-study/ArchDiagram.astro';
 import DecisionList from '@components/case-study/DecisionList.astro';
+import FeatureList from '@components/case-study/FeatureList.astro';
 import Gallery from '@components/case-study/Gallery.astro';
 
 interface Block {
@@ -15,6 +16,7 @@ interface Section {
   anchorId: string;
   blocks?: Block[];
   decisions?: { n: number; choice: string; alternative: string; rationale: string }[];
+  features?: { title: string; value: string; technical: string }[];
 }
 interface Media {
   src: string;
@@ -91,6 +93,14 @@ const galleryMedia = media.slice(1); // media[0] is the hero shown above the art
     )
   }
 
+  {
+    section.kind === 'features' && section.features && (
+      <div class="mt-6">
+        <FeatureList features={section.features} />
+      </div>
+    )
+  }
+
   {
     section.kind === 'screenshots' &&
       (galleryMedia.length > 0 ? (

site/src/components/core/Footer.astro

@@ -58,11 +58,6 @@ const nav: { id: PageId; label: string }[] = [
             >LinkedIn ↗</a
           >
         </li>
-        <li>
-          <a class="hover:text-ink transition-colors" href={p.links.gitea} rel="me noopener"
-            >git.cesnimda.uk ↗</a
-          >
-        </li>
         <li>
           <a class="hover:text-ink transition-colors" href={pathFor('cv', locale)}
             >{d.cv.download}</a

site/src/components/core/Header.astro

@@ -26,7 +26,7 @@ const isCurrent = (id: PageId) =>
 
 <header
   id="site-header"
-  class="bg-surface-0/80 sticky top-0 z-40 border-b border-transparent backdrop-blur-md"
+  class="bg-surface-0/80 sticky top-0.5 z-40 mt-0.5 mb-0.5 border-b border-transparent backdrop-blur-md"
 >
   <div
     class="mx-auto flex h-[--header-h] max-w-[--content-max] items-center justify-between px-5 transition-[height] duration-[--dur-standard] ease-[--ease-out] sm:px-6"

site/src/components/core/MobileNav.astro

@@ -95,6 +95,5 @@ const navItems: { id: PageId; label: string }[] = [
   <div class="text-mono-meta text-ink-muted mt-auto flex flex-col gap-2 pt-8 font-mono">
     <a href={`mailto:${p.links.email}`}>{p.links.email}</a>
     <a href={p.links.linkedin} rel="me noopener">LinkedIn ↗</a>
-    <a href={p.links.gitea} rel="me noopener">git.cesnimda.uk ↗</a>
   </div>
 </div>

site/src/components/pages/ContactPage.astro

@@ -122,13 +122,6 @@ const fieldClass =
             class="text-body text-ink hover:text-accent">LinkedIn ↗</a
           >
         </li>
-        <li>
-          <a
-            href={profile.links.gitea}
-            rel="me noopener"
-            class="text-body text-ink hover:text-accent">git.cesnimda.uk ↗</a
-          >
-        </li>
         <li>
           <a href={profile.links.phoneHref} class="text-body text-ink hover:text-accent"
             >{profile.links.phone}</a

site/src/components/ui/ThemeToggle.astro

@@ -10,7 +10,7 @@ const d = useDict(locale);
 ---
 
 <button
-  id="theme-toggle"
+  data-theme-toggle
   type="button"
   class="border-line text-ink-muted hover:text-ink inline-flex h-9 w-9 items-center justify-center rounded-full border transition-colors duration-[--dur-quick]"
   aria-label={d.theme.toLight}

site/src/components/ui/TraceMotif.astro

@@ -11,7 +11,7 @@ const { statusLine, class: cls } = Astro.props;
 ---
 
 <div class:list={['flex items-center gap-3', cls]}>
-  <svg width="200" height="24" viewBox="0 0 200 24" fill="none" aria-hidden="true">
+  <svg width="200" height="28" viewBox="0 0 200 28" fill="none" aria-hidden="true">
     <path
       class="trace-line"
       d="M2 12 H150 l10 10 H194"

site/src/data/meta.ts

@@ -30,36 +30,36 @@ export const meta: Meta = {
     en: {
       title: 'JobTrack — case study · Connor Babbington',
       description:
-        'A full-stack job-application workspace: React, ASP.NET Core, SQLite, a local Ollama AI service and Docker. Architecture, decisions and security.',
+        'AI-assisted job-search workspace: Next.js, ASP.NET Core, a Kanban pipeline, deterministic CV match and multi-provider recruiter threads.',
     },
     no: {
       title: 'JobTrack — prosjektgjennomgang · Connor Babbington',
       description:
-        'Et fullstack arbeidsrom for jobbsøking: React, ASP.NET Core, SQLite, lokal Ollama-AI og Docker. Arkitektur, valg og sikkerhet.',
+        'AI-assistert arbeidsrom for jobbsøking: Next.js, ASP.NET Core, Kanban-pipeline, deterministisk CV-match og korrespondanse fra flere kanaler.',
     },
   },
   inboxintel: {
     en: {
       title: 'InboxIntel — case study · Connor Babbington',
       description:
-        'Gmail analytics and safe bulk cleanup, built as Clean Architecture in .NET 8 with encrypted OAuth tokens and preview-before-delete.',
+        'A self-hosted inbox tool: hybrid semantic + full-text search (pgvector + Ollama), AI summaries and inbox-health analytics, built as Clean Architecture.',
     },
     no: {
       title: 'InboxIntel — prosjektgjennomgang · Connor Babbington',
       description:
-        'Gmail-analyse og trygg masseopprydding, bygget som Clean Architecture i .NET 8 med krypterte OAuth-tokens og forhåndsvisning før sletting.',
+        'Et egendriftet innboksverktøy: hybrid semantisk + fulltekst-søk (pgvector + Ollama), AI-sammendrag og innboks-helse, bygget som Clean Architecture.',
     },
   },
   homelab: {
     en: {
       title: 'Self-hosted infrastructure lab — Connor Babbington',
       description:
-        'A home lab running Ubuntu, Docker, nginx, Gitea and monitoring — hands-on deployment and operations, and the deploy target for this site.',
+        'A ~30-service home lab: Ubuntu, Docker, Traefik, Authentik SSO, CrowdSec and self-hosted Gitea CI — hands-on ops, and the deploy target for this site.',
     },
     no: {
       title: 'Egendriftet hjemmelab — Connor Babbington',
       description:
-        'En hjemmelab med Ubuntu, Docker, nginx, Gitea og overvåking — praktisk drift og utrulling, og utrullingsmålet for denne siden.',
+        'En hjemmelab med ~30 tjenester: Ubuntu, Docker, Traefik, Authentik SSO, CrowdSec og egendriftet Gitea-CI — praktisk drift, og utrullingsmålet for denne siden.',
     },
   },
   experience: {

site/src/data/profile.ts

@@ -15,8 +15,8 @@ export const profile: Profile = {
     gitea: 'https://git.cesnimda.uk/cesnimda',
   },
   cv: {
-    en: { path: '/cv/connor-babbington-cv-en.pdf', sizeKb: 8, updated: '2026-07' },
-    no: { path: '/cv/connor-babbington-cv-no.pdf', sizeKb: 8, updated: '2026-07' },
+    en: { path: '/cv/connor-babbington-cv-en.pdf', sizeKb: 290, updated: '2026-07' },
+    no: { path: '/cv/connor-babbington-cv-no.pdf', sizeKb: 296, updated: '2026-07' },
   },
   photo: {
     src: '/assets/portrait.webp',
@@ -71,7 +71,7 @@ export const profile: Profile = {
       aboutHeading: 'About',
       aboutParagraphs: [
         'I’m a systems developer with a backend-leaning full-stack background: business systems, troubleshooting and production support. I like turning stakeholder requirements into practical, reliable software, and I care about the parts users never see — tests, deployments and keeping things running.',
-        'Alongside professional work I build and self-host my own projects — a job-application tracker, a Gmail analytics tool, and a home infrastructure lab. It keeps my skills current and hands-on, and it’s where I get to make the architecture decisions end to end.',
+        'Alongside professional work I build and self-host my own projects — a job-application tracker, a self-hosted inbox cleanup tool, and a home infrastructure lab. It keeps my skills current and hands-on, and it’s where I get to make the architecture decisions end to end.',
         'I’m based in Tønsberg, Norway, with a valid residence permit. English is my native language and my Norwegian is at B1 and actively improving. Outside work I’m into PC and board games, cooking, and generally learning new things.',
       ],
       interestsLine: 'PC & board games · cooking · always learning something new',
@@ -88,7 +88,7 @@ export const profile: Profile = {
       aboutHeading: 'Om meg',
       aboutParagraphs: [
         'Jeg er systemutvikler med bakgrunn i fullstack med tyngde på backend: fagsystemer, feilsøking og driftsstøtte. Jeg liker å gjøre om behov fra brukere og interessenter til praktisk og pålitelig programvare, og jeg bryr meg om det brukerne aldri ser — tester, utrulling og stabil drift.',
-        'Ved siden av jobb bygger og drifter jeg egne prosjekter — en jobbsøknads-tracker, et verktøy for Gmail-analyse og en hjemmelab for infrastruktur. Det holder ferdighetene mine oppdaterte, og der tar jeg alle arkitekturvalgene selv, fra ende til ende.',
+        'Ved siden av jobb bygger og drifter jeg egne prosjekter — en jobbsøknads-tracker, et verktøy for innboks-opprydding og en hjemmelab for infrastruktur. Det holder ferdighetene mine oppdaterte, og der tar jeg alle arkitekturvalgene selv, fra ende til ende.',
         'Jeg er bosatt i Tønsberg og har gyldig oppholdstillatelse. Engelsk er morsmålet mitt, og norsken min er på B1 og i aktiv utvikling. På fritiden liker jeg PC- og brettspill, matlaging og å lære nye ting.',
       ],
       interestsLine: 'PC- og brettspill · matlaging · lærer alltid noe nytt',

site/src/data/projects/homelab.ts

@@ -66,7 +66,7 @@ export const homelab: Project = {
         h: 60,
         kind: 'internal',
         label: 'Gitea + runner',
-        sub: { en: 'git.cesnimda.uk · CI/CD', no: 'git.cesnimda.uk · CI/CD' },
+        sub: { en: 'self-hosted git · CI/CD', no: 'egendriftet git · CI/CD' },
       },
       {
         id: 'apps',

site/src/data/projects/inboxintel.ts

@@ -1,6 +1,6 @@
 import type { Project } from '@lib/schema';
 
-/* InboxIntel case study. Source: F:\Documents\InboxIntel\InboxIntel (README + docs). */
+/* InboxIntel case study. Source: F:\Documents\InboxIntel\InboxIntel (full codebase + docs audit, 2026-07-12). */
 export const inboxintel: Project = {
   id: 'inboxintel',
   name: 'InboxIntel',
@@ -8,11 +8,11 @@ export const inboxintel: Project = {
   status: 'in-development',
   template: 'case-study',
   stack: [
-    { name: '.NET 8', context: { en: 'ASP.NET Core', no: 'ASP.NET Core' } },
-    { name: 'PostgreSQL', context: { en: 'EF Core + Npgsql', no: 'EF Core + Npgsql' } },
-    { name: 'React 18', context: { en: 'Vite · Chart.js', no: 'Vite · Chart.js' } },
-    { name: 'Gmail API', context: { en: 'OAuth2 · Polly', no: 'OAuth2 · Polly' } },
-    { name: 'Serilog' },
+    { name: '.NET 10', context: { en: 'ASP.NET Core', no: 'ASP.NET Core' } },
+    { name: 'React', context: { en: 'Vite · TypeScript', no: 'Vite · TypeScript' } },
+    { name: 'PostgreSQL', context: { en: 'EF Core · pgvector', no: 'EF Core · pgvector' } },
+    { name: 'Ollama', context: { en: 'embeddings · summaries', no: 'embeddings · sammendrag' } },
+    { name: 'Clean Architecture' },
     { name: 'Docker' },
   ],
   links: [],
@@ -20,8 +20,8 @@ export const inboxintel: Project = {
     viewBox: '0 0 1120 300',
     title: { en: 'InboxIntel architecture', no: 'InboxIntel-arkitektur' },
     desc: {
-      en: 'A React SPA calls an ASP.NET Core API layered as Clean Architecture (Api → Infrastructure → Application → Domain). A hosted background worker syncs the external Gmail API into PostgreSQL with Polly retry/backoff.',
-      no: 'En React-app kaller et ASP.NET Core-API bygget som Clean Architecture (Api → Infrastructure → Application → Domain). En bakgrunnstjeneste synkroniserer det eksterne Gmail-API-et inn i PostgreSQL med Polly retry/backoff.',
+      en: 'A React SPA calls an ASP.NET Core API layered as Clean Architecture. A hosted background worker syncs the Gmail API into PostgreSQL with pgvector, and a local Ollama model produces the embeddings and summaries that power hybrid search.',
+      no: 'En React-app kaller et ASP.NET Core-API bygget som Clean Architecture. En bakgrunnstjeneste synkroniserer Gmail-API-et inn i PostgreSQL med pgvector, og en lokal Ollama-modell lager embeddings og sammendrag som driver hybrid søk.',
     },
     nodes: [
       {
@@ -32,7 +32,7 @@ export const inboxintel: Project = {
         h: 72,
         kind: 'internal',
         label: 'React SPA',
-        sub: { en: 'Vite · Chart.js', no: 'Vite · Chart.js' },
+        sub: { en: 'split-view · search', no: 'delt visning · søk' },
       },
       {
         id: 'api',
@@ -44,6 +44,16 @@ export const inboxintel: Project = {
         label: 'ASP.NET Core API',
         sub: { en: 'Clean Architecture', no: 'Clean Architecture' },
       },
+      {
+        id: 'ollama',
+        x: 290,
+        y: 232,
+        w: 200,
+        h: 56,
+        kind: 'internal',
+        label: 'Ollama',
+        sub: { en: 'embeddings · summaries', no: 'embeddings · sammendrag' },
+      },
       {
         id: 'pg',
         x: 580,
@@ -52,7 +62,7 @@ export const inboxintel: Project = {
         h: 64,
         kind: 'internal',
         label: 'PostgreSQL',
-        sub: { en: 'EF Core · Npgsql', no: 'EF Core · Npgsql' },
+        sub: { en: 'EF Core · pgvector', no: 'EF Core · pgvector' },
       },
       {
         id: 'worker',
@@ -77,6 +87,7 @@ export const inboxintel: Project = {
     ],
     edges: [
       { d: 'M210 152 H290', kind: 'flow', label: '/api', labelX: 240, labelY: 144 },
+      { d: 'M390 188 V232', kind: 'flow', label: 'AI', labelX: 408, labelY: 216 },
       { d: 'M490 134 L580 92', kind: 'flow' },
       { d: 'M490 170 L580 192', kind: 'flow' },
       { d: 'M670 160 V112', kind: 'flow' },
@@ -85,42 +96,55 @@ export const inboxintel: Project = {
   },
   media: [
     {
-      src: 'placeholder:inboxintel-dashboard',
+      src: '/assets/projects/inboxintel/inbox.webp',
       width: 1600,
       height: 1000,
       alt: {
-        en: 'InboxIntel draggable analytics dashboard with charts',
-        no: 'InboxIntel dashbord med flyttbare analyse-widgets',
+        en: 'InboxIntel split view: a persistent message list beside a resizable reading pane with an AI summary',
+        no: 'InboxIntel delt visning: en fast meldingsliste ved siden av en justerbar leserute med AI-sammendrag',
       },
       caption: {
-        en: 'Draggable analytics dashboard (react-grid-layout)',
-        no: 'Dashbord med flyttbare widgets (react-grid-layout)',
+        en: 'Split view — read and triage without ever opening a new tab',
+        no: 'Delt visning — les og sorter uten å åpne en ny fane',
       },
     },
     {
-      src: 'placeholder:inboxintel-cleanup',
+      src: '/assets/projects/inboxintel/dashboard.webp',
       width: 1600,
       height: 1000,
       alt: {
-        en: 'Bulk cleanup preview screen requiring explicit confirmation',
-        no: 'Forhåndsvisning av masseopprydding som krever bekreftelse',
+        en: 'InboxIntel analytics dashboard: inbox-health grade, emails by category, 90-day volume and top senders',
+        no: 'InboxIntel dashbord: innboks-helse, e-post per kategori, 90-dagers volum og toppavsendere',
       },
       caption: {
-        en: 'Cleanup preview — nothing is deleted without a confirmed flag',
-        no: 'Oppryddings-forhåndsvisning — ingenting slettes uten bekreftelse',
+        en: 'Analytics — an inbox-health grade, categories, volume trend and top senders',
+        no: 'Analyse — innboks-helse, kategorier, volumtrend og toppavsendere',
+      },
+    },
+    {
+      src: '/assets/projects/inboxintel/search.webp',
+      width: 1600,
+      height: 1000,
+      alt: {
+        en: 'InboxIntel search: hybrid semantic and full-text results with why-matched highlights and relevance scores',
+        no: 'InboxIntel søk: hybrid semantisk og fulltekst med treff-forklaring og relevans-score',
+      },
+      caption: {
+        en: 'Search — hybrid semantic + full-text, with why-matched highlights and relevance',
+        no: 'Søk — hybrid semantisk + fulltekst, med treff-forklaring og relevans',
       },
     },
   ],
   content: {
     en: {
       valueProp:
-        'Gmail analytics and safe bulk cleanup, built as a disciplined Clean Architecture.',
+        'A self-hosted inbox intelligence and cleanup tool — hybrid search, AI summaries and inbox-health analytics over your mail.',
       cardTeaser:
-        'Gmail analytics and safe bulk cleanup — Clean Architecture, encrypted OAuth tokens, preview-before-delete by design.',
+        'Self-hosted inbox intelligence — hybrid semantic + full-text search, AI summaries and inbox-health analytics, with safe cleanup by design.',
       tldr: {
-        what: 'Gmail analytics, cleanup and unsubscribe management with a background sync worker.',
-        why: 'To practise Clean Architecture properly and make destructive operations safe by design.',
-        stack: '.NET 8 · PostgreSQL · React 18 · Gmail API · Serilog · Polly · Docker.',
+        what: 'Inbox intelligence: split-view reading, hybrid semantic search, AI summaries, inbox-health analytics and safe cleanup.',
+        why: 'To practise Clean Architecture properly, and make search useful and destructive operations safe by design.',
+        stack: '.NET 10 · PostgreSQL + pgvector · React · Ollama · Docker · Clean Architecture.',
         role: 'Sole architect and developer, front to back.',
       },
       sections: [
@@ -131,55 +155,108 @@ export const inboxintel: Project = {
           blocks: [
             {
               type: 'p',
-              text: 'A busy inbox needs analytics and cleanup, but bulk operations on real mail are dangerous — one wrong filter can delete things you can’t get back. I built InboxIntel to explore two things at once: a clean, testable backend architecture, and destructive operations that are safe by construction.',
+              text: "A busy inbox is hard to search and dangerous to clean up — keyword search misses what you meant, and one wrong bulk filter deletes things you can't get back. I built InboxIntel to make an inbox actually searchable (by meaning, not just words), understandable at a glance, and safe to tidy — self-hosted, with a clean, testable backend built to production discipline rather than side-project shortcuts.",
+            },
+          ],
+        },
+        {
+          kind: 'solution',
+          heading: 'Solution',
+          anchorId: 'solution',
+          blocks: [
+            {
+              type: 'p',
+              text: 'InboxIntel connects to your mailbox via OAuth, syncs it into a local PostgreSQL database, and layers three things on top: a split-view reading pane for fast triage, hybrid search that finds mail by meaning as well as keywords, and an analytics dashboard that shows inbox health at a glance. Every destructive action — bulk trash, unsubscribe — previews before it executes.',
+            },
+            {
+              type: 'ul',
+              items: [
+                'Reading: a persistent list beside a resizable pane with an AI summary — triage without opening a new tab.',
+                'Search: hybrid semantic (pgvector) + full-text, with a fuzzy fallback for typos and a relevance score.',
+                'Analytics: an inbox-health grade, emails by category, a 90-day volume trend and top senders.',
+                'Cleanup: preview-then-confirm on every destructive action; the AI is advisory only.',
+              ],
+            },
+            {
+              type: 'p',
+              text: 'Today it connects to Gmail only. A full multi-provider architecture — a provider abstraction, unified email model, and an Outlook/IMAP rollout plan — is designed in detail (a dozen internal design documents covering auth, data model, admin platform and migration path); building it out is the next major milestone rather than a shipped feature.',
+            },
+          ],
+        },
+        {
+          kind: 'features',
+          heading: 'Feature showcase',
+          anchorId: 'features',
+          features: [
+            {
+              title: 'Hybrid search that understands meaning, not just words',
+              value:
+                'Find "that gym receipt" even if you never typed the word "gym" in the email — search stops being a literal keyword match.',
+              technical:
+                'Reciprocal Rank Fusion combines Postgres full-text search (tsvector/GIN, websearch_to_tsquery) with pgvector cosine-similarity search over local Ollama embeddings, fusing the top 50 results from each. A pg_trgm fuzzy fallback with a hand-tuned 0.3 similarity threshold (the default 0.6 misses real typos like "recieved") catches what neither ranked list does. Any AI-path failure — Ollama down, embeddings not yet backfilled — degrades silently to lexical-only search.',
+            },
+            {
+              title: 'Cleanup you can trust',
+              value:
+                'Preview exactly what a bulk-delete or unsubscribe action will do before anything happens — no accidental data loss from an over-broad filter.',
+              technical:
+                'Every destructive action requires a server-side Preview call before Execute, with an explicit Confirmed flag checked twice — once by FluentValidation, once inside the service itself as defence in depth. Unsubscribe targets are validated by an SSRF egress guard against private/metadata IP ranges before any outbound request is made, and mailto: links are surfaced to the user rather than auto-sent.',
+            },
+            {
+              title: 'Inbox health at a glance',
+              value:
+                'A draggable dashboard shows volume trends, top senders and category breakdowns without digging through folders manually.',
+              technical:
+                'A react-grid-layout dashboard with per-user persisted widget positions, backed by dedicated analytics endpoints (health grade, category heatmap, 90-day volume, top senders, attachment stats) computed server-side rather than client-aggregated.',
             },
           ],
         },
         {
           kind: 'architecture',
-          heading: 'Architecture',
+          heading: 'Engineering highlights',
           anchorId: 'architecture',
           blocks: [
             {
               type: 'p',
-              text: 'A four-project Clean Architecture solution behind a React SPA. The dependency rule points inward: Api → Infrastructure → Application → Domain. Controllers hold no business logic — they delegate to Application-layer service interfaces resolved through DI. A hosted background worker syncs Gmail into PostgreSQL with Polly retry and backoff.',
+              text: 'The backend is Clean Architecture with the dependency rule enforced end to end: Api → Infrastructure → Application → Domain, controllers hold no business logic, and the Domain project has zero external dependencies bar the one type needed for full-text search. AI is fully swappable at the DI boundary — Null, Ollama and OpenAI implementations of the same IAiProvider interface — so the rest of the app never branches on whether AI is enabled.',
             },
             {
               type: 'ul',
               items: [
-                'Domain: entities and enums, no external dependencies.',
-                'Application: service interfaces, DTOs, validators, the Gmail query parser.',
-                'Infrastructure: EF Core, the Gmail client, the sync worker, AI and export.',
-                'Api: ASP.NET Core controllers, auth, DI and Serilog — thin by design.',
+                "Sync engine: checkpoints its page token and message count after every page, so a killed sync resumes rather than restarting; incremental syncs use Gmail's historyId watermark instead of re-scanning; all calls run through Polly retry/backoff.",
+                "Pagination: keyset (cursor) pagination on large result sets — O(page size) instead of OFFSET's O(page × page size) — alongside plain offset pagination for the general browse path.",
+                'AI is advisory only by contract: every AiService method carries the explicit guarantee that it never archives, deletes, labels or unsubscribes on its own.',
+                'Security is self-audited on a paper trail: a dated, severity-coded internal audit (plaintext-storage risk, missing rate limits, unencrypted keys) with each finding resolved via its own tracked PR and new tests, not just prose claims.',
               ],
             },
           ],
         },
         {
           kind: 'decisions',
-          heading: 'Key decisions & trade-offs',
+          heading: 'Challenges',
           anchorId: 'decisions',
           decisions: [
             {
               n: 1,
-              choice: 'Full Clean Architecture across four projects.',
-              alternative: 'A single project would have shipped faster.',
+              choice:
+                'Fuse lexical and semantic search with Reciprocal Rank Fusion, degrading silently on failure.',
+              alternative: 'Run semantic search as a separate mode the user has to switch to.',
               rationale:
-                'I wanted the dependency rule to be enforced by the project structure, not by discipline alone. It costs more ceremony up front and pays back in testability and clear boundaries.',
+                "Keyword search alone misses paraphrased or vaguely-remembered mail; semantic search alone drops exact-match precision. RRF blends the top 50 of each into one ranked list automatically, and if Ollama is down or an email hasn't been embedded yet, the query still returns lexical results instead of erroring. Outcome: one search box that works whether or not the AI layer is healthy.",
             },
             {
               n: 2,
               choice: 'Encrypt OAuth refresh tokens at rest and never log them.',
-              alternative: 'Store them as plain columns.',
+              alternative: 'Store them as plain columns — simpler, faster to ship.',
               rationale:
-                'Refresh tokens are long-lived keys to someone’s mailbox. They’re encrypted with the ASP.NET Core Data Protection API (AES), with keys persisted to a mounted volume — the single most important security decision in the app.',
+                "Refresh tokens are long-lived keys to someone's mailbox. They're encrypted with the ASP.NET Core Data Protection API (AES), with keys persisted to a mounted volume — flagged in the internal audit as the single most important security decision in the app, and verified clean on re-review.",
             },
             {
               n: 3,
-              choice: 'Every destructive action is preview-then-confirm.',
-              alternative: 'Delete immediately on request.',
+              choice: 'Require a mandatory preview before any destructive action, enforced twice.',
+              alternative: 'Trust client-side confirmation and execute on request.',
               rationale:
-                'All cleanup and unsubscribe actions require a server-side preview and an explicit Confirmed flag. The AI layer is advisory only and can never trigger a deletion.',
+                'An audit finding showed rate limiting and validation gaps around bulk actions early on. The fix — preview-then-confirm checked at both the validator and the service layer, plus an SSRF guard on every outbound unsubscribe request — closed the finding and shipped with regression tests proving the 400 on invalid input.',
             },
           ],
         },
@@ -191,10 +268,10 @@ export const inboxintel: Project = {
             {
               type: 'ul',
               items: [
-                'Gmail scopes are read/modify only — no send scope is ever requested.',
-                'Polly provides retry and backoff against Gmail API rate limits and transient failures.',
-                'FluentValidation on inputs; Serilog structured logging that never records tokens.',
-                'Unit tests cover the query parser and unsubscribe extraction; integration tests boot the API host and assert authorization is enforced.',
+                'Google-OAuth gated; Gmail scopes are read/modify only — no send scope is ever requested.',
+                "Embeddings and summaries are generated locally (Ollama) by default; an optional cloud fallback exists but mail never leaves the box unless that's explicitly enabled.",
+                'Polly retry/backoff against Gmail rate limits; Serilog structured logging that never records tokens; OpenTelemetry instrumentation wired for production observability.',
+                'Clean Architecture keeps the layers testable; 39+ unit and integration tests, including live-database tests for the full-text/fuzzy/pgvector paths.',
               ],
             },
           ],
@@ -206,25 +283,50 @@ export const inboxintel: Project = {
         },
         {
           kind: 'next',
-          heading: 'Status & what’s next',
+          heading: 'Status & roadmap',
           anchorId: 'next',
           blocks: [
             {
               type: 'p',
-              text: 'InboxIntel is in active development: the architecture is complete and the layers compile and are wired end to end, with a few integration points (Gmail parsing edge cases, AI prompt tuning) left as clearly-marked extension points. Next up is hardening those edges and expanding the integration-test suite.',
+              text: 'Implemented today:',
+            },
+            {
+              type: 'ul',
+              items: [
+                'Gmail OAuth sync into PostgreSQL, with resumable, checkpointed background sync',
+                'Hybrid semantic + full-text + fuzzy search with keyset pagination',
+                'Draggable analytics dashboard: inbox health, categories, volume, top senders',
+                'Safe bulk cleanup and unsubscribe (preview-then-confirm, SSRF-guarded)',
+                'Optional local AI (Ollama) or cloud fallback for classification, summaries and natural-language search',
+                'A self-audited, remediated security posture with tracked findings and fixes',
+              ],
+            },
+            {
+              type: 'p',
+              text: 'Designed but not yet built — the next major milestones:',
+            },
+            {
+              type: 'ul',
+              items: [
+                'Multi-provider support (Outlook, generic IMAP) — architecture and migration plan already written',
+                'Rules engine for automated cleanup, sender policy (block/whitelist/screener) and an activity log with undo',
+                'A privacy monitor (breach-check against known leak databases)',
+                'Tuned AI prompts and richer HTML-body/attachment parsing beyond the common cases',
+              ],
             },
           ],
         },
       ],
     },
     no: {
-      valueProp: 'Gmail-analyse og trygg masseopprydding, bygget som en ryddig Clean Architecture.',
+      valueProp:
+        'Et egendriftet verktøy for innboks-intelligens og opprydding — hybrid søk, AI-sammendrag og innboks-helse over e-posten din.',
       cardTeaser:
-        'Gmail-analyse og trygg masseopprydding — Clean Architecture, krypterte OAuth-tokens, forhåndsvisning før sletting.',
+        'Egendriftet innboks-intelligens — hybrid semantisk + fulltekst-søk, AI-sammendrag og innboks-helse, med trygg opprydding fra bunnen.',
       tldr: {
-        what: 'Gmail-analyse, opprydding og avmeldingshåndtering med en bakgrunns-synk.',
-        why: 'For å øve på Clean Architecture skikkelig og gjøre destruktive operasjoner trygge fra bunnen.',
-        stack: '.NET 8 · PostgreSQL · React 18 · Gmail API · Serilog · Polly · Docker.',
+        what: 'Innboks-intelligens: delt visning, hybrid semantisk søk, AI-sammendrag, innboks-helse og trygg opprydding.',
+        why: 'For å øve på Clean Architecture skikkelig, gjøre søk nyttig og destruktive operasjoner trygge fra bunnen.',
+        stack: '.NET 10 · PostgreSQL + pgvector · React · Ollama · Docker · Clean Architecture.',
         role: 'Eneste arkitekt og utvikler, fra ende til ende.',
       },
       sections: [
@@ -235,55 +337,109 @@ export const inboxintel: Project = {
           blocks: [
             {
               type: 'p',
-              text: 'En travel innboks trenger analyse og opprydding, men masseoperasjoner på ekte e-post er farlige — ett feil filter kan slette ting du ikke får tilbake. Jeg bygde InboxIntel for å utforske to ting samtidig: en ryddig, testbar backend-arkitektur, og destruktive operasjoner som er trygge fra bunnen.',
+              text: 'En travel innboks er vanskelig å søke i og farlig å rydde i — nøkkelordsøk bommer på det du mente, og ett feil massefilter sletter ting du ikke får tilbake. Jeg bygde InboxIntel for å gjøre en innboks faktisk søkbar (på mening, ikke bare ord), forståelig med ett blikk, og trygg å rydde i — egendriftet, med en ryddig og testbar backend bygget til produksjonsstandard, ikke fritidsprosjekt-snarveier.',
+            },
+          ],
+        },
+        {
+          kind: 'solution',
+          heading: 'Løsning',
+          anchorId: 'losning',
+          blocks: [
+            {
+              type: 'p',
+              text: 'InboxIntel kobler seg til postkassen din via OAuth, synkroniserer den inn i en lokal PostgreSQL-database, og legger tre ting på toppen: en delt lesevisning for rask sortering, hybrid søk som finner e-post på mening i tillegg til nøkkelord, og et analysedashbord som viser innboks-helse med ett blikk. Hver destruktive handling — massesletting, avmelding — forhåndsvises før den utføres.',
+            },
+            {
+              type: 'ul',
+              items: [
+                'Lesing: en fast liste ved siden av en justerbar rute med AI-sammendrag — sorter uten å åpne en ny fane.',
+                'Søk: hybrid semantisk (pgvector) + fulltekst, med fuzzy-fallback for skrivefeil og relevans-score.',
+                'Analyse: en innboks-helsekarakter, e-post per kategori, 90-dagers volumtrend og toppavsendere.',
+                'Opprydding: forhåndsvis-så-bekreft på hver destruktive handling; AI-en er kun rådgivende.',
+              ],
+            },
+            {
+              type: 'p',
+              text: 'I dag kobles den kun til Gmail. En full arkitektur for flere leverandører — en leverandørabstraksjon, en samlet e-postmodell og en utrullingsplan for Outlook/IMAP — er designet i detalj (et dusin interne designdokumenter om autentisering, datamodell, admin-plattform og migreringsvei); å bygge det ut er neste store milepæl, ikke en levert funksjon.',
+            },
+          ],
+        },
+        {
+          kind: 'features',
+          heading: 'Utvalgte funksjoner',
+          anchorId: 'funksjoner',
+          features: [
+            {
+              title: 'Hybrid søk som forstår mening, ikke bare ord',
+              value:
+                'Finn «den kvittering fra treningssenteret» selv om du aldri skrev ordet «trening» i e-posten — søk slutter å være et bokstavelig nøkkelordtreff.',
+              technical:
+                'Reciprocal Rank Fusion kombinerer Postgres fulltekstsøk (tsvector/GIN, websearch_to_tsquery) med pgvector kosinuslikhet over lokale Ollama-embeddings, og fusjonerer de 50 beste resultatene fra hver. En pg_trgm fuzzy-fallback med en håndjustert similaritetsterskel på 0,3 (standarden 0,6 bommer på ekte skrivefeil som «mottat»→«mottatt») fanger opp det ingen av de rangerte listene gjør. Enhver feil i AI-stien — Ollama nede, embeddings ikke bakfylt ennå — degraderer stille til kun leksikalsk søk.',
+            },
+            {
+              title: 'Opprydding du kan stole på',
+              value:
+                'Forhåndsvis nøyaktig hva en massesletting eller avmelding vil gjøre før noe skjer — ingen utilsiktet datatap fra et for bredt filter.',
+              technical:
+                'Hver destruktive handling krever et server-side Preview-kall før Execute, med et eksplisitt Confirmed-flagg sjekket to ganger — én gang av FluentValidation, én gang inne i selve tjenesten som ekstra sikkerhetslag. Avmeldingsmål valideres av en SSRF-utgangsvakt mot private/metadata-IP-områder før noen utgående forespørsel gjøres, og mailto-lenker vises til brukeren i stedet for å sendes automatisk.',
+            },
+            {
+              title: 'Innboks-helse med ett blikk',
+              value:
+                'Et flyttbart dashbord viser volumtrender, toppavsendere og kategorifordeling uten å måtte grave gjennom mapper manuelt.',
+              technical:
+                'Et react-grid-layout-dashbord med per-bruker lagret widget-plassering, støttet av dedikerte analyse-endepunkter (helsekarakter, kategori-varmekart, 90-dagers volum, toppavsendere, vedleggsstatistikk) beregnet server-side i stedet for aggregert på klienten.',
             },
           ],
         },
         {
           kind: 'architecture',
-          heading: 'Arkitektur',
+          heading: 'Tekniske høydepunkter',
           anchorId: 'arkitektur',
           blocks: [
             {
               type: 'p',
-              text: 'En løsning med fire prosjekter i Clean Architecture bak en React-app. Avhengighetsregelen peker innover: Api → Infrastructure → Application → Domain. Kontrollerne har ingen forretningslogikk — de delegerer til tjenestegrensesnitt i Application-laget via DI. En bakgrunnstjeneste synkroniserer Gmail inn i PostgreSQL med Polly retry og backoff.',
+              text: 'Backend er Clean Architecture med avhengighetsregelen håndhevet fra ende til ende: Api → Infrastructure → Application → Domain, kontrollerne har ingen forretningslogikk, og Domain-prosjektet har ingen eksterne avhengigheter bortsett fra én type som trengs for fulltekstsøk. AI er fullt utskiftbart ved DI-grensen — Null-, Ollama- og OpenAI-implementasjoner av samme IAiProvider-grensesnitt — så resten av appen forgrener seg aldri på om AI er skrudd på.',
             },
             {
               type: 'ul',
               items: [
-                'Domain: entiteter og enums, uten eksterne avhengigheter.',
-                'Application: tjenestegrensesnitt, DTO-er, validatorer og Gmail-søkeparser.',
-                'Infrastructure: EF Core, Gmail-klient, synk-tjeneste, AI og eksport.',
-                'Api: ASP.NET Core-kontrollere, auth, DI og Serilog — tynt med hensikt.',
+                'Synk-motor: sjekkpunkter side-token og meldingstall etter hver side, så en avbrutt synk fortsetter i stedet for å starte på nytt; inkrementelle synker bruker Gmails historyId-vannmerke i stedet for å skanne på nytt; alle kall går gjennom Polly retry/backoff.',
+                'Paginering: keyset (markør)-paginering på store resultatsett — O(sidestørrelse) i stedet for OFFSETs O(side × sidestørrelse) — ved siden av vanlig offset-paginering for generell nettlesing.',
+                'AI er kun rådgivende ved kontrakt: hver AiService-metode bærer den eksplisitte garantien at den aldri arkiverer, sletter, merker eller melder av på egen hånd.',
+                'Sikkerhet er egen-revidert med papirspor: en datert, alvorlighetskodet intern revisjon (risiko for klartekst-lagring, manglende ratebegrensning, ukrypterte nøkler) hvor hvert funn er løst via egen sporet PR og nye tester, ikke bare prosapåstander.',
               ],
             },
           ],
         },
         {
           kind: 'decisions',
-          heading: 'Viktige valg og avveininger',
-          anchorId: 'beslutninger',
+          heading: 'Utfordringer',
+          anchorId: 'utfordringer',
           decisions: [
             {
               n: 1,
-              choice: 'Full Clean Architecture over fire prosjekter.',
-              alternative: 'Ett prosjekt hadde vært raskere å levere.',
+              choice:
+                'Fusjonere leksikalsk og semantisk søk med Reciprocal Rank Fusion, med stille degradering ved feil.',
+              alternative: 'Kjøre semantisk søk som en egen modus brukeren må bytte til.',
               rationale:
-                'Jeg ville at avhengighetsregelen skulle håndheves av prosjektstrukturen, ikke bare av disiplin. Det koster mer seremoni i starten og betaler seg i testbarhet og tydelige grenser.',
+                'Nøkkelordsøk alene bommer på omskrevet eller vagt husket e-post; semantisk søk alene mister presisjon på eksakte treff. RRF blander de 50 beste fra hver til én rangert liste automatisk, og hvis Ollama er nede eller en e-post ikke er bakfylt ennå, returnerer spørringen fortsatt leksikalske resultater i stedet for å feile. Resultat: én søkeboks som fungerer uansett om AI-laget er friskt.',
             },
             {
               n: 2,
               choice: 'Kryptere OAuth-refresh-tokens i ro og aldri logge dem.',
-              alternative: 'Lagre dem som vanlige kolonner.',
+              alternative: 'Lagre dem som vanlige kolonner — enklere, raskere å levere.',
               rationale:
-                'Refresh-tokens er langlevde nøkler til noens innboks. De krypteres med ASP.NET Core Data Protection API (AES), med nøkler lagret på et montert volum — det viktigste sikkerhetsvalget i appen.',
+                'Refresh-tokens er langlevde nøkler til noens innboks. De krypteres med ASP.NET Core Data Protection API (AES), med nøkler lagret på et montert volum — flagget i den interne revisjonen som det viktigste sikkerhetsvalget i appen, og verifisert rent ved ny gjennomgang.',
             },
             {
               n: 3,
-              choice: 'Alle destruktive handlinger er forhåndsvis-så-bekreft.',
-              alternative: 'Slette umiddelbart ved forespørsel.',
+              choice:
+                'Kreve obligatorisk forhåndsvisning før enhver destruktiv handling, håndhevet to ganger.',
+              alternative: 'Stole på klientsidebekreftelse og utføre ved forespørsel.',
               rationale:
-                'All opprydding og avmelding krever en server-side forhåndsvisning og et eksplisitt Confirmed-flagg. AI-laget er kun rådgivende og kan aldri utløse en sletting.',
+                'Et revisjonsfunn viste ratebegrensnings- og valideringshull rundt massehandlinger tidlig. Løsningen — forhåndsvis-så-bekreft sjekket både på validator- og tjenestenivå, pluss en SSRF-vakt på hver utgående avmeldingsforespørsel — lukket funnet og ble levert med regresjonstester som beviser 400 ved ugyldig input.',
             },
           ],
         },
@@ -295,10 +451,10 @@ export const inboxintel: Project = {
             {
               type: 'ul',
               items: [
-                'Gmail-scopes er kun lese/endre — send-scope blir aldri etterspurt.',
-                'Polly gir retry og backoff mot Gmail-API-ets rategrenser og forbigående feil.',
-                'FluentValidation på input; strukturert Serilog-logging som aldri lagrer tokens.',
-                'Enhetstester dekker søkeparser og avmeldings-uttrekk; integrasjonstester starter API-verten og sjekker at autorisasjon håndheves.',
+                'Google-OAuth-beskyttet; Gmail-scopes er kun lese/endre — send-scope blir aldri etterspurt.',
+                'Embeddings og sammendrag lages lokalt (Ollama) som standard; en valgfri sky-fallback finnes, men e-post forlater aldri maskinen med mindre det er eksplisitt skrudd på.',
+                'Polly retry/backoff mot Gmails rategrenser; strukturert Serilog-logging som aldri lagrer tokens; OpenTelemetry-instrumentering klar for produksjonsobservabilitet.',
+                'Clean Architecture holder lagene testbare; 39+ enhets- og integrasjonstester, inkludert live-database-tester for fulltekst-/fuzzy-/pgvector-stiene.',
               ],
             },
           ],
@@ -315,7 +471,31 @@ export const inboxintel: Project = {
           blocks: [
             {
               type: 'p',
-              text: 'InboxIntel er under aktiv utvikling: arkitekturen er komplett, lagene kompilerer og er koblet ende til ende, med noen integrasjonspunkter (kanttilfeller i Gmail-parsing, tuning av AI-prompter) igjen som tydelig markerte utvidelsespunkter. Neste steg er å herde disse kantene og utvide integrasjonstestene.',
+              text: 'Implementert i dag:',
+            },
+            {
+              type: 'ul',
+              items: [
+                'Gmail OAuth-synk inn i PostgreSQL, med gjenopptakbar, sjekkpunktet bakgrunnssynk',
+                'Hybrid semantisk + fulltekst + fuzzy søk med keyset-paginering',
+                'Flyttbart analysedashbord: innboks-helse, kategorier, volum, toppavsendere',
+                'Trygg massesletting og avmelding (forhåndsvis-så-bekreft, SSRF-sikret)',
+                'Valgfri lokal AI (Ollama) eller sky-fallback for klassifisering, sammendrag og naturlig-språk-søk',
+                'En egen-revidert, utbedret sikkerhetsstatus med sporede funn og fikser',
+              ],
+            },
+            {
+              type: 'p',
+              text: 'Designet, men ikke bygget ennå — de neste store milepælene:',
+            },
+            {
+              type: 'ul',
+              items: [
+                'Støtte for flere leverandører (Outlook, generisk IMAP) — arkitektur og migreringsplan allerede skrevet',
+                'Regelmotor for automatisert opprydding, avsenderpolicy (blokker/hvitliste/screener) og en aktivitetslogg med angre',
+                'En personvernvakt (lekkasjesjekk mot kjente bruddatabaser)',
+                'Justerte AI-prompter og rikere HTML-body-/vedleggsparsing utover de vanlige tilfellene',
+              ],
             },
           ],
         },

site/src/data/projects/jobtrack.ts

@@ -1,19 +1,21 @@
 import type { Project } from '@lib/schema';
 
-/* JobTrack case study. Source: D:\Job tracker (README + website_details.md). */
+/* JobTrack case study. Source: D:\Job tracker (full codebase + docs audit, 2026-07-12). */
 export const jobtrack: Project = {
   id: 'jobtrack',
   name: 'JobTrack',
   order: 1,
-  status: 'active',
+  status: 'in-development',
   template: 'case-study',
   stack: [
-    { name: '.NET 9', context: { en: 'ASP.NET Core API', no: 'ASP.NET Core-API' } },
-    { name: 'React', context: { en: 'SPA frontend', no: 'SPA-frontend' } },
-    { name: 'TypeScript' },
-    { name: 'SQLite', context: { en: 'EF Core', no: 'EF Core' } },
-    { name: 'FastAPI', context: { en: 'Python AI service', no: 'Python AI-tjeneste' } },
-    { name: 'Ollama', context: { en: 'local LLM', no: 'lokal LLM' } },
+    { name: 'ASP.NET Core', context: { en: '.NET 9 API', no: '.NET 9-API' } },
+    { name: 'Next.js', context: { en: 'React 19 · TypeScript', no: 'React 19 · TypeScript' } },
+    { name: 'EF Core', context: { en: 'SQLite · MySQL/MariaDB', no: 'SQLite · MySQL/MariaDB' } },
+    { name: 'FastAPI + Ollama', context: { en: 'local AI service', no: 'lokal AI-tjeneste' } },
+    {
+      name: 'Multi-provider email',
+      context: { en: 'Gmail · Microsoft · IMAP', no: 'Gmail · Microsoft · IMAP' },
+    },
     { name: 'Docker' },
   ],
   links: [],
@@ -21,8 +23,8 @@ export const jobtrack: Project = {
     viewBox: '0 0 1120 300',
     title: { en: 'JobTrack architecture', no: 'JobTrack-arkitektur' },
     desc: {
-      en: 'A React single-page app talks to an ASP.NET Core API, which persists to SQLite and disk, calls a FastAPI/Ollama AI service, and imports from the external Gmail API over OAuth2.',
-      no: 'En React-app snakker med et ASP.NET Core-API som lagrer til SQLite og disk, kaller en FastAPI/Ollama AI-tjeneste, og importerer fra det eksterne Gmail-API-et via OAuth2.',
+      en: 'A Next.js single-page app talks to an ASP.NET Core API, which persists via EF Core with attachments on disk, calls a FastAPI/Ollama AI service, and syncs correspondence from Gmail, Microsoft Graph and IMAP through one provider abstraction.',
+      no: 'En Next.js-app snakker med et ASP.NET Core-API som lagrer via EF Core med vedlegg på disk, kaller en FastAPI/Ollama AI-tjeneste, og synkroniserer korrespondanse fra Gmail, Microsoft Graph og IMAP gjennom én felles abstraksjon.',
     },
     nodes: [
       {
@@ -32,8 +34,8 @@ export const jobtrack: Project = {
         w: 180,
         h: 72,
         kind: 'internal',
-        label: 'React SPA',
-        sub: { en: 'nginx · PWA', no: 'nginx · PWA' },
+        label: 'Next.js SPA',
+        sub: { en: 'nginx · CSR', no: 'nginx · CSR' },
       },
       {
         id: 'api',
@@ -43,7 +45,7 @@ export const jobtrack: Project = {
         h: 72,
         kind: 'primary',
         label: 'ASP.NET Core API',
-        sub: { en: '.NET 9 · auth · rules', no: '.NET 9 · auth · regler' },
+        sub: { en: 'auth · rules · CV match', no: 'auth · regler · CV-match' },
       },
       {
         id: 'data',
@@ -52,8 +54,8 @@ export const jobtrack: Project = {
         w: 180,
         h: 64,
         kind: 'internal',
-        label: 'SQLite + files',
-        sub: { en: 'EF Core · attachments', no: 'EF Core · vedlegg' },
+        label: 'EF Core + files',
+        sub: { en: 'data · attachments', no: 'data · vedlegg' },
       },
       {
         id: 'ai',
@@ -72,68 +74,69 @@ export const jobtrack: Project = {
         w: 180,
         h: 72,
         kind: 'external',
-        label: 'Gmail API',
-        sub: { en: 'external · OAuth2', no: 'eksternt · OAuth2' },
+        label: 'Email providers',
+        sub: { en: 'Gmail · MS Graph · IMAP', no: 'Gmail · MS Graph · IMAP' },
       },
     ],
     edges: [
       { d: 'M220 148 H300', kind: 'flow', label: '/api', labelX: 248, labelY: 140 },
       { d: 'M500 130 L600 88', kind: 'flow' },
       { d: 'M500 166 L600 200', kind: 'flow' },
-      { d: 'M500 148 H900', kind: 'external', label: 'import', labelX: 690, labelY: 140 },
+      { d: 'M500 148 H900', kind: 'external', label: 'sync', labelX: 690, labelY: 140 },
     ],
   },
   media: [
     {
-      src: '/assets/projects/jobtrack/applications.webp',
+      src: '/assets/projects/jobtrack/workspace.webp',
       width: 1600,
-      height: 768,
+      height: 1000,
       alt: {
-        en: 'JobTrack applications table showing companies, roles, statuses and follow-up flags',
-        no: 'JobTrack-søknadstabell med selskaper, roller, statuser og oppfølgingsmarkører',
+        en: 'JobTrack job workspace: one application with its details, CV match and recruiter thread',
+        no: 'JobTrack jobb-arbeidsrom: én søknad med detaljer, CV-match og rekruttør-tråd',
       },
       caption: {
-        en: 'Applications table — the whole pipeline at a glance, with per-row next actions',
-        no: 'Søknadstabell — hele pipelinen samlet, med neste handling per rad',
+        en: 'Job workspace — everything about one application in one place',
+        no: 'Jobb-arbeidsrom — alt om én søknad på ett sted',
+      },
+    },
+    {
+      src: '/assets/projects/jobtrack/pipeline.webp',
+      width: 1600,
+      height: 1000,
+      alt: {
+        en: 'JobTrack Kanban pipeline with applications across Applied, Waiting, Interview and Offer',
+        no: 'JobTrack Kanban-pipeline med søknader fordelt på stadiene',
+      },
+      caption: {
+        en: 'Pipeline — drag applications between stages, from Applied to Offer',
+        no: 'Pipeline — dra søknader mellom stadier, fra Søkt til Tilbud',
       },
     },
     {
       src: '/assets/projects/jobtrack/dashboard.webp',
       width: 1600,
-      height: 759,
+      height: 1000,
       alt: {
-        en: 'JobTrack dashboard with application trends, response rates and skill tags',
-        no: 'JobTrack-dashbord med søknadstrender, svarrater og ferdighetstagger',
+        en: 'JobTrack dashboard with response rate, funnel and time-in-stage',
+        no: 'JobTrack-dashbord med svarrate, trakt og tid-per-stadium',
       },
       caption: {
-        en: 'Dashboard — trends, response rates and pipeline health',
-        no: 'Dashbord — trender, svarrater og pipeline-helse',
-      },
-    },
-    {
-      src: '/assets/projects/jobtrack/reminders.webp',
-      width: 1600,
-      height: 758,
-      alt: {
-        en: 'JobTrack reminders view surfacing applications that need follow-up',
-        no: 'JobTrack-påminnelser som løfter fram søknader som trenger oppfølging',
-      },
-      caption: {
-        en: 'Reminders — applications that need attention, driven by follow-up rules',
-        no: 'Påminnelser — søknader som trenger oppfølging, styrt av regler',
+        en: 'Dashboard — response rates, funnel and skill demand across the search',
+        no: 'Dashbord — svarrater, trakt og etterspurte ferdigheter',
       },
     },
   ],
   content: {
     en: {
       valueProp:
-        'A job-application workspace covering the full journey from application to follow-up.',
+        'An AI-assisted job-search workspace — import a role, tailor your CV, and track every application from applied to offer.',
       cardTeaser:
-        'One workspace for the whole job-application journey — pipeline, correspondence, attachments, AI summaries.',
+        'Import a role, tailor your CV, and track every application — recruiter threads and a Kanban pipeline in one workspace.',
       tldr: {
-        what: 'Full-stack job-application tracker: pipeline, correspondence, attachments, analytics.',
+        what: 'Full-stack job-search workspace: pipeline, deterministic CV match, multi-provider recruiter threads, AI drafting.',
         why: 'A real problem — my own job search needed production-grade tooling, not a spreadsheet.',
-        stack: 'React + ASP.NET Core + SQLite · FastAPI/Ollama AI service · Docker Compose.',
+        stack:
+          'Next.js + ASP.NET Core (EF Core) · FastAPI/Ollama local AI · Gmail/Microsoft/IMAP · Docker.',
         role: 'Everything: product, backend, frontend, ops and security.',
       },
       sections: [
@@ -144,55 +147,104 @@ export const jobtrack: Project = {
           blocks: [
             {
               type: 'p',
-              text: 'A serious job search spreads across spreadsheets, email threads, notes apps and scattered documents. Nothing shows you, at a glance, which applications need attention or what was said last. I wanted one focused workspace — and I wanted to build it to the standard I would ship at work, not as a throwaway.',
+              text: 'A serious job search spreads across spreadsheets, email threads, notes apps and scattered documents. Nothing shows you, at a glance, which applications need attention or what was said last, and every CV-tailoring tool either charges a subscription or hands back an opaque "match score" you can\'t interrogate. I wanted one focused workspace — from importing a role to the final offer — built to the standard I would ship at work, not as a throwaway.',
+            },
+          ],
+        },
+        {
+          kind: 'solution',
+          heading: 'Solution',
+          anchorId: 'solution',
+          blocks: [
+            {
+              type: 'p',
+              text: 'JobTrack is a self-hosted workspace that carries one job application through its whole life: import the posting, see how your CV stacks up against it, track it through a pipeline, and keep every recruiter message attached to the right job — with an assistive AI layer that drafts but never sends anything on your behalf.',
+            },
+            {
+              type: 'ul',
+              items: [
+                'Pipeline: a Kanban board — Applied, Waiting, Interview, Offer, Rejected, Ghosted — drag to update, with rule-based auto-transition to Ghosted after inactivity.',
+                'CV match: deterministic keyword coverage (matched vs missing), not a black-box score.',
+                'Correspondence: one unified thread view across Gmail, Microsoft/Outlook and generic IMAP, auto-linked to the right job.',
+                'AI is assistive, never autonomous: it drafts CVs, cover letters and follow-ups — you always review and send.',
+              ],
+            },
+          ],
+        },
+        {
+          kind: 'features',
+          heading: 'Feature showcase',
+          anchorId: 'features',
+          features: [
+            {
+              title: 'Deterministic CV↔job match score',
+              value:
+                'See exactly which keywords from a posting your CV covers and which are missing — a stable, reproducible number instead of a $50/month "AI fit score" you can\'t argue with.',
+              technical:
+                'A from-scratch weighted-keyword algorithm (JobCvMatchService): curated skill tags at weight 3 plus a title bonus, frequency-ranked stop-word-filtered posting terms at weight 1, matched with a hand-rolled word-boundary check so "go" never matches "goal". No AI call — same inputs always produce the same score, with an honest "not enough signal" flag instead of false confidence.',
+            },
+            {
+              title: 'One thread, any provider',
+              value:
+                'Recruiter emails land in the right job automatically, whether they come through Gmail, Outlook or any other IMAP mailbox — no more digging through three inboxes to find what a recruiter said.',
+              technical:
+                'Correspondence import runs through a single IEmailProvider interface (SearchAsync / ListThreadMessagesAsync / GetMessageAsync) behind a provider registry, with a Provider discriminator column on each stored message. Gmail shipped first; Microsoft Graph and IMAP were added later as separate implementations of the same contract — no controller logic was duplicated per provider.',
+            },
+            {
+              title: 'AI-assisted drafting, human-gated sending',
+              value:
+                'Get a tailored CV, cover letter or follow-up draft in seconds — but nothing is ever sent or auto-applied without you reading and approving it first.',
+              technical:
+                'CVs are OCR/text-extracted (FastAPI + Tesseract/PyMuPDF), classified into structured blocks by a local Ollama model (qwen2.5:7b), then rendered to PDF via a templated Playwright export. Prompts wrap untrusted CV text in explicit delimiters with an instruction to treat it as inert data, not commands — closing off prompt injection from a CV someone else wrote.',
             },
           ],
         },
         {
           kind: 'architecture',
-          heading: 'Architecture',
+          heading: 'Engineering highlights',
           anchorId: 'architecture',
           blocks: [
             {
               type: 'p',
-              text: 'Four services behind one Docker Compose file. A React SPA talks to an ASP.NET Core (.NET 9) API that owns the domain logic and follow-up rules, persisting to SQLite via EF Core with attachments on disk. A small FastAPI service backed by a local Ollama model produces summaries and skill extraction, and the API imports correspondence from the Gmail API over OAuth2.',
+              text: 'The backend is a modular monolith on ASP.NET Core (.NET 9) with six hosted background services — rules engine, follow-up reminders, scheduled exports, job enrichment, CV processing and an AI-readiness probe — running off the request path. EF Core targets SQLite by default and switches to MySQL/MariaDB via the Pomelo provider for larger deployments. Every tenant table is scoped by a global EF Core query filter (deny-on-null by design), so one database safely serves multiple users.',
             },
             {
               type: 'ul',
               items: [
-                'Frontend: React + TypeScript SPA, served by nginx, installable as a PWA with a mobile share-target for quick capture.',
-                'API: ASP.NET Core, EF Core, rule-driven follow-up reminders, per-application history trail.',
-                'AI: FastAPI wrapper over Ollama for short/full description summaries — advisory only.',
-                'Integration: Gmail OAuth2 with smart query filters and single-message or full-thread import.',
+                'Auth: a custom policy scheme routes Google-issued, Microsoft-issued and local JWTs to the right handler; CSRF double-submit on cookie sessions; rate-limited login and email-sending endpoints.',
+                'CI/CD: Gitea Actions builds and tests the backend, builds the frontend, then SSHes into the production host and redeploys via Docker Compose on every push to main — no staging environment, by deliberate choice.',
+                'i18n: full English + Norwegian Bokmål UI, a genuine differentiator against the mostly US-centric competitors (Teal, Huntr, Simplify).',
               ],
             },
           ],
         },
         {
           kind: 'decisions',
-          heading: 'Key decisions & trade-offs',
+          heading: 'Challenges',
           anchorId: 'decisions',
           decisions: [
             {
               n: 1,
-              choice: 'Run the AI locally with Ollama instead of a cloud API.',
-              alternative: 'A hosted LLM API would have been faster to wire up.',
+              choice:
+                'Generalize Gmail-only import into a provider-neutral IEmailProvider abstraction, incrementally.',
+              alternative:
+                'Rewrite the correspondence layer once, up front, for every provider we might ever need.',
               rationale:
-                'Job-search data is sensitive and I wanted zero per-call cost and no third party in the loop. The trade-off is more setup and heavier local resources — acceptable for a self-hosted, single-user tool.',
+                'Import started Gmail-only; when Microsoft and IMAP support were requested later, I extracted the interface across several small PRs instead of a big-bang rewrite. Outcome: three working providers behind one contract, and no controller ever had to be duplicated per provider.',
             },
             {
               n: 2,
-              choice: 'Ship the PWA with no offline service-worker cache.',
-              alternative: 'A cache would enable full offline use.',
+              choice: 'SSRF-harden the job-import URL fetcher before shipping it.',
+              alternative: 'Trust the pasted URL and fetch it directly — it is only a job posting.',
               rationale:
-                'I deploy frequently, so an aggressive cache risks serving stale builds — a worse failure than a brief offline gap. The manifest still provides installability and share-to-capture. A deliberate anti-feature.',
+                'Letting users paste an arbitrary URL for server-side scraping is a classic path into internal infrastructure. The fetcher resolves the hostname via DNS rather than trusting the literal host, then rejects the resolved IP against the full private/reserved-range table (RFC 1918, CGNAT, link-local, IPv6 unique-local) for both IPv4 and IPv6. Outcome: independently re-verified as fixed in a follow-up security pass.',
             },
             {
               n: 3,
-              choice: 'SQLite rather than PostgreSQL.',
-              alternative: 'Postgres is the default reach for a web backend.',
+              choice: 'Keep CV matching deterministic instead of an AI-generated score.',
+              alternative: 'Let the local model rate the fit directly.',
               rationale:
-                'This is a single-user app; SQLite removes an entire service with no practical downside here. If it ever went multi-tenant, moving to Postgres via EF Core is a contained change.',
+                'A number a candidate can\'t interrogate is useless, and it\'s the exact "AI slop" complaint competitor research turned up against existing tools. Deterministic keyword coverage shows precisely which terms matched and which are missing, so the advice is honest and actionable — and reproducible.',
             },
           ],
         },
@@ -204,10 +256,10 @@ export const jobtrack: Project = {
             {
               type: 'ul',
               items: [
-                'Optional Google sign-in (Google ID tokens) protects the API; every record is scoped to its owner.',
+                'Google and Microsoft sign-in (issuer-routed policy scheme) protect the API; every record is scoped to its owner via EF Core global query filters.',
                 'File uploads are validated and stored per-application with ownership checks on every access.',
-                'The AI layer is advisory only — it never performs destructive actions.',
-                'Runs as a reproducible Docker Compose stack with a documented .env; scheduled JSON/CSV exports for data portability.',
+                'The AI layer is advisory only — it drafts, it never sends or auto-applies.',
+                'Runs as a reproducible Docker Compose stack with a documented .env; JSON/CSV exports and automated database backups for data portability.',
               ],
             },
           ],
@@ -219,25 +271,50 @@ export const jobtrack: Project = {
         },
         {
           kind: 'next',
-          heading: 'What I’d improve next',
+          heading: 'Status & roadmap',
           anchorId: 'next',
           blocks: [
             {
               type: 'p',
-              text: 'The rules engine for follow-ups is simple date logic; I’d make it configurable per pipeline stage. I’d also add a proper integration-test pass around the Gmail import edge cases, and tighten the summariser prompts now that I have real usage to learn from.',
+              text: 'Implemented today:',
+            },
+            {
+              type: 'ul',
+              items: [
+                'Kanban pipeline with rule-based stage automation',
+                'Deterministic CV↔job match scoring',
+                'Multi-provider correspondence (Gmail, Microsoft Graph, IMAP)',
+                'AI-assisted CV, cover-letter and follow-up drafting (local Ollama, optional cloud fallback)',
+                'Attachments, reminders, JSON/CSV exports and automated backups',
+              ],
+            },
+            {
+              type: 'p',
+              text: 'Planned next:',
+            },
+            {
+              type: 'ul',
+              items: [
+                'An interview hub and lightweight recruiter/contacts CRM',
+                'A second analytics pass and a proper PWA offline mode',
+                'Wider integration-test coverage around correspondence-import edge cases',
+                'Configurable per-stage follow-up rules (currently simple date logic)',
+              ],
             },
           ],
         },
       ],
     },
     no: {
-      valueProp: 'Et arbeidsrom for jobbsøking som dekker hele reisen fra søknad til oppfølging.',
+      valueProp:
+        'Et AI-assistert arbeidsrom for jobbsøking — importer en stilling, tilpass CV-en, og følg hver søknad fra søkt til tilbud.',
       cardTeaser:
-        'Ett arbeidsrom for hele jobbsøkerreisen — pipeline, korrespondanse, vedlegg og AI-sammendrag.',
+        'Importer en stilling, tilpass CV-en, og følg hver søknad — rekruttør-tråder og en Kanban-pipeline i ett arbeidsrom.',
       tldr: {
-        what: 'Fullstack jobbsøknads-tracker: pipeline, korrespondanse, vedlegg og analyse.',
+        what: 'Fullstack arbeidsrom for jobbsøking: pipeline, deterministisk CV-match, korrespondanse fra flere kanaler, AI-utkast.',
         why: 'Et ekte problem — min egen jobbsøking trengte skikkelig verktøy, ikke et regneark.',
-        stack: 'React + ASP.NET Core + SQLite · FastAPI/Ollama AI-tjeneste · Docker Compose.',
+        stack:
+          'Next.js + ASP.NET Core (EF Core) · FastAPI/Ollama lokal AI · Gmail/Microsoft/IMAP · Docker.',
         role: 'Alt: produkt, backend, frontend, drift og sikkerhet.',
       },
       sections: [
@@ -248,55 +325,105 @@ export const jobtrack: Project = {
           blocks: [
             {
               type: 'p',
-              text: 'En seriøs jobbsøking sprer seg over regneark, e-posttråder, notatapper og løse dokumenter. Ingenting viser deg med ett blikk hvilke søknader som trenger oppfølging, eller hva som sist ble sagt. Jeg ville ha ett samlet arbeidsrom — og bygge det til samme standard som jeg leverer på jobb, ikke som noe engangs.',
+              text: 'En seriøs jobbsøking sprer seg over regneark, e-posttråder, notatapper og løse dokumenter. Ingenting viser deg med ett blikk hvilke søknader som trenger oppfølging, eller hva som sist ble sagt — og alle CV-tilpasningsverktøy krever enten abonnement eller gir deg en uigjennomsiktig "match-score" du ikke kan etterprøve. Jeg ville ha ett samlet arbeidsrom — fra import av en stilling til endelig tilbud — bygget til samme standard som jeg leverer på jobb.',
+            },
+          ],
+        },
+        {
+          kind: 'solution',
+          heading: 'Løsning',
+          anchorId: 'losning',
+          blocks: [
+            {
+              type: 'p',
+              text: 'JobTrack er et egendriftet arbeidsrom som følger én søknad gjennom hele livsløpet: importer stillingen, se hvordan CV-en din står seg mot den, følg den gjennom en pipeline, og hold hver rekruttør-melding koblet til riktig jobb — med et assisterende AI-lag som skriver utkast, men aldri sender noe på dine vegne.',
+            },
+            {
+              type: 'ul',
+              items: [
+                'Pipeline: et Kanban-brett — Søkt, Venter, Intervju, Tilbud, Avslått, Ghostet — dra for å oppdatere, med regelstyrt auto-overgang til Ghostet ved inaktivitet.',
+                'CV-match: deterministisk nøkkelorddekning (treff vs. mangler), ikke en svart boks.',
+                'Korrespondanse: én samlet tråd-visning på tvers av Gmail, Microsoft/Outlook og generisk IMAP, automatisk koblet til riktig jobb.',
+                'AI-en er assisterende, aldri autonom: den skriver utkast til CV, søknadsbrev og oppfølging — du gjennomgår og sender alltid selv.',
+              ],
+            },
+          ],
+        },
+        {
+          kind: 'features',
+          heading: 'Utvalgte funksjoner',
+          anchorId: 'funksjoner',
+          features: [
+            {
+              title: 'Deterministisk CV↔jobb-match',
+              value:
+                'Se nøyaktig hvilke nøkkelord fra stillingsannonsen CV-en din dekker, og hvilke som mangler — et stabilt, reproduserbart tall i stedet for en uigjennomsiktig "AI-score" til 50 dollar i måneden.',
+              technical:
+                'En egenutviklet, vektet nøkkelordalgoritme (JobCvMatchService): kuraterte kompetanse-tagger med vekt 3 pluss tittelbonus, frekvensrangerte, stoppord-filtrerte annonsetermer med vekt 1, matchet med en håndbygget ordgrense-sjekk så «go» aldri treffer «goal». Ingen AI-kall — samme input gir alltid samme score, med et ærlig «for lite signal»-flagg i stedet for falsk trygghet.',
+            },
+            {
+              title: 'Én tråd, uansett leverandør',
+              value:
+                'Rekruttør-eposter havner automatisk på riktig jobb, uansett om de kommer via Gmail, Outlook eller en annen IMAP-postkasse — ikke flere tre-innbokser å lete gjennom for å finne hva en rekrutterer sa.',
+              technical:
+                'Import av korrespondanse går gjennom ett felles IEmailProvider-grensesnitt (SearchAsync / ListThreadMessagesAsync / GetMessageAsync) bak et leverandørregister, med en Provider-kolonne på hver lagrede melding. Gmail kom først; Microsoft Graph og IMAP ble lagt til senere som separate implementasjoner av samme kontrakt — ingen kontrollerlogikk ble duplisert per leverandør.',
+            },
+            {
+              title: 'AI-assistert utkast, menneske-styrt sending',
+              value:
+                'Få et tilpasset CV-, søknadsbrev- eller oppfølgingsutkast på sekunder — men ingenting sendes eller søkes automatisk uten at du har lest og godkjent det først.',
+              technical:
+                'CV-er tekstutrekkes med OCR (FastAPI + Tesseract/PyMuPDF), klassifiseres i strukturerte blokker av en lokal Ollama-modell (qwen2.5:7b), og rendres til PDF via en malbasert Playwright-eksport. Prompter pakker inn utrygg CV-tekst i eksplisitte skilletegn med instruks om å behandle den som data, ikke kommandoer — som stenger av prompt-injeksjon fra en CV noen andre har skrevet.',
             },
           ],
         },
         {
           kind: 'architecture',
-          heading: 'Arkitektur',
+          heading: 'Tekniske høydepunkter',
           anchorId: 'arkitektur',
           blocks: [
             {
               type: 'p',
-              text: 'Fire tjenester bak én Docker Compose-fil. En React-app snakker med et ASP.NET Core-API (.NET 9) som eier domenelogikken og oppfølgingsreglene, og lagrer til SQLite via EF Core med vedlegg på disk. En liten FastAPI-tjeneste med en lokal Ollama-modell lager sammendrag og trekker ut ferdigheter, og API-et importerer korrespondanse fra Gmail-API-et via OAuth2.',
+              text: 'Backend er en modulær monolitt på ASP.NET Core (.NET 9) med seks bakgrunnstjenester — regelmotor, oppfølgingspåminnelser, planlagte eksporter, jobb-berikelse, CV-prosessering og en AI-klarhetssjekk — som kjører utenfor forespørselsløpet. EF Core bruker SQLite som standard og bytter til MySQL/MariaDB via Pomelo-driveren for større driftssettinger. Hver leietaker-tabell er avgrenset av et globalt EF Core-spørringsfilter (nekt-ved-null by design), så én database trygt kan betjene flere brukere.',
             },
             {
               type: 'ul',
               items: [
-                'Frontend: React + TypeScript, servert av nginx, installerbar som PWA med share-target for rask registrering.',
-                'API: ASP.NET Core, EF Core, regelstyrte oppfølgingspåminnelser og historikk per søknad.',
-                'AI: FastAPI over Ollama for korte og fulle sammendrag — kun rådgivende.',
-                'Integrasjon: Gmail OAuth2 med smarte søkefiltre og import av enkeltmeldinger eller hele tråder.',
+                'Autentisering: et tilpasset policy-skjema ruter Google-utstedte, Microsoft-utstedte og lokale JWT-er til riktig håndterer; CSRF-dobbeltinnsending på cookie-økter; ratebegrenset innlogging og e-postutsending.',
+                'CI/CD: Gitea Actions bygger og tester backend, bygger frontend, og SSH-er så inn på produksjonsserveren og ruller ut på nytt via Docker Compose ved hver push til main — ingen staging-miljø, et bevisst valg.',
+                'i18n: fullt engelsk + norsk bokmål-grensesnitt, en reell differensiator mot de mest USA-sentrerte konkurrentene (Teal, Huntr, Simplify).',
               ],
             },
           ],
         },
         {
           kind: 'decisions',
-          heading: 'Viktige valg og avveininger',
-          anchorId: 'beslutninger',
+          heading: 'Utfordringer',
+          anchorId: 'utfordringer',
           decisions: [
             {
               n: 1,
-              choice: 'Kjøre AI-en lokalt med Ollama i stedet for et sky-API.',
-              alternative: 'Et hostet LLM-API hadde vært raskere å koble til.',
+              choice:
+                'Generalisere Gmail-bare import til en leverandørnøytral IEmailProvider-abstraksjon, trinnvis.',
+              alternative:
+                'Skrive om korrespondanselaget én gang, på forhånd, for hver leverandør vi kanskje trenger.',
               rationale:
-                'Jobbsøkerdata er sensitivt, og jeg ville ha null kostnad per kall og ingen tredjepart i loopen. Avveiningen er mer oppsett og tyngre lokale ressurser — greit for et egendriftet verktøy med én bruker.',
+                'Import startet Gmail-bare; da Microsoft- og IMAP-støtte ble etterspurt senere, trakk jeg ut grensesnittet over flere små PR-er i stedet for en stor omskriving. Resultat: tre fungerende leverandører bak én kontrakt, og ingen kontroller måtte dupliseres per leverandør.',
             },
             {
               n: 2,
-              choice: 'Levere PWA-en uten offline-cache i service-workeren.',
-              alternative: 'En cache ville gitt full offline-bruk.',
+              choice: 'SSRF-sikre jobb-import-URL-henteren før den ble sluppet.',
+              alternative:
+                'Stole på den limte inn URL-en og hente den direkte — det er jo bare en stillingsannonse.',
               rationale:
-                'Jeg ruller ut ofte, så en aggressiv cache risikerer å servere utdaterte bygg — en verre feil enn et kort offline-hull. Manifestet gir fortsatt installerbarhet og share-to-capture. En bevisst anti-funksjon.',
+                'Å la brukere lime inn en vilkårlig URL for server-side skraping er en klassisk vei inn i intern infrastruktur. Henteren slår opp vertsnavnet via DNS i stedet for å stole på den bokstavelige verten, og avviser så den oppløste IP-en mot hele det private/reserverte adresseområdet (RFC 1918, CGNAT, link-lokal, IPv6 unique-local) for både IPv4 og IPv6. Resultat: uavhengig verifisert som fikset i en påfølgende sikkerhetsgjennomgang.',
             },
             {
               n: 3,
-              choice: 'SQLite framfor PostgreSQL.',
-              alternative: 'Postgres er standardvalget for en web-backend.',
+              choice: 'Holde CV-matchen deterministisk i stedet for en AI-generert score.',
+              alternative: 'La den lokale modellen vurdere treffet direkte.',
               rationale:
-                'Dette er en app for én bruker; SQLite fjerner en hel tjeneste uten praktisk ulempe her. Skulle den bli fler-bruker, er overgang til Postgres via EF Core en avgrenset endring.',
+                'Et tall en kandidat ikke kan etterprøve er ubrukelig, og det er nøyaktig «AI-slop»-klagen konkurrentanalysen fant mot eksisterende verktøy. Deterministisk nøkkelorddekning viser nøyaktig hvilke ord som traff og hvilke som mangler, så rådet er ærlig, handlingsrettet — og reproduserbart.',
             },
           ],
         },
@@ -308,10 +435,10 @@ export const jobtrack: Project = {
             {
               type: 'ul',
               items: [
-                'Valgfri Google-innlogging (Google ID-tokens) beskytter API-et; hver post er knyttet til sin eier.',
+                'Google- og Microsoft-innlogging (utsteder-rutet policy-skjema) beskytter API-et; hver post er knyttet til sin eier via globale EF Core-spørringsfilter.',
                 'Filopplastinger valideres og lagres per søknad, med eierskapssjekk ved hvert tilgangspunkt.',
-                'AI-laget er kun rådgivende — det utfører aldri destruktive handlinger.',
-                'Kjører som en reproduserbar Docker Compose-stack med dokumentert .env; planlagte JSON/CSV-eksporter for dataportabilitet.',
+                'AI-laget er kun rådgivende — det skriver utkast, det sender aldri og søker aldri automatisk.',
+                'Kjører som en reproduserbar Docker Compose-stack med dokumentert .env; JSON/CSV-eksport og automatiske databasebackupper for dataportabilitet.',
               ],
             },
           ],
@@ -323,12 +450,35 @@ export const jobtrack: Project = {
         },
         {
           kind: 'next',
-          heading: 'Hva jeg ville forbedret',
+          heading: 'Status og veien videre',
           anchorId: 'videre',
           blocks: [
             {
               type: 'p',
-              text: 'Regelmotoren for oppfølging er enkel datologikk; jeg ville gjort den konfigurerbar per pipeline-steg. Jeg ville også lagt til skikkelige integrasjonstester rundt kanttilfellene i Gmail-importen, og strammet inn sammendrags-promptene nå som jeg har ekte bruk å lære av.',
+              text: 'Implementert i dag:',
+            },
+            {
+              type: 'ul',
+              items: [
+                'Kanban-pipeline med regelstyrt stadie-automasjon',
+                'Deterministisk CV↔jobb-match',
+                'Korrespondanse fra flere kanaler (Gmail, Microsoft Graph, IMAP)',
+                'AI-assistert utkast til CV, søknadsbrev og oppfølging (lokal Ollama, valgfri sky-fallback)',
+                'Vedlegg, påminnelser, JSON/CSV-eksport og automatiske backupper',
+              ],
+            },
+            {
+              type: 'p',
+              text: 'Planlagt videre:',
+            },
+            {
+              type: 'ul',
+              items: [
+                'Et intervjuknutepunkt og en enkel rekrutterer/kontakt-CRM',
+                'En ny analyserunde og et skikkelig offline-modus for PWA-en',
+                'Bredere integrasjonstestdekning rundt kanttilfeller i korrespondanse-import',
+                'Konfigurerbare oppfølgingsregler per stadium (i dag enkel datologikk)',
+              ],
             },
           ],
         },

site/src/lib/schema.ts

@@ -72,8 +72,16 @@ export const decision = z.object({
   rationale: z.string(),
 });
 
+export const feature = z.object({
+  title: z.string(),
+  value: z.string(),
+  technical: z.string(),
+});
+
 export const SECTION_KINDS = [
   'problem',
+  'solution',
+  'features',
   'architecture',
   'decisions',
   'security',
@@ -87,6 +95,7 @@ export const section = z.object({
   anchorId: z.string(),
   blocks: z.array(block).optional(),
   decisions: z.array(decision).optional(),
+  features: z.array(feature).optional(),
 });
 
 export const projectLocaleContent = z.object({

site/src/lib/seo.ts

@@ -49,7 +49,7 @@ export function buildJsonLd(
       addressLocality: 'Tønsberg',
       addressCountry: 'NO',
     },
-    sameAs: [p.links.linkedin, p.links.gitea],
+    sameAs: [p.links.linkedin],
     knowsLanguage: ['en', 'nb'],
     knowsAbout: ['C#', '.NET', 'React', 'TypeScript', 'Python', 'SQL', 'Docker', 'Linux'],
   };

site/src/scripts/theme.ts

@@ -1,19 +1,21 @@
 /*
   Theme toggle (A6). The no-flash init in ThemeScript already set data-theme before
-  paint; this only wires the button, persists the choice, and keeps the aria-label
-  describing the *next* action. Fail-silent if the button is absent.
+  paint; this wires every toggle (header + mobile nav), persists the choice, and keeps
+  each aria-label describing the *next* action. Fail-silent if none are present.
 */
 const html = document.documentElement;
-const btn = document.getElementById('theme-toggle');
+const toggles = document.querySelectorAll<HTMLElement>('[data-theme-toggle]');
 
-function labelFor(theme: string): string {
-  if (!btn) return '';
-  return theme === 'dark' ? (btn.dataset.toLight ?? '') : (btn.dataset.toDark ?? '');
+function label(el: HTMLElement, theme: string): string {
+  return theme === 'dark' ? (el.dataset.toLight ?? '') : (el.dataset.toDark ?? '');
+}
+function syncLabels(theme: string): void {
+  toggles.forEach((el) => el.setAttribute('aria-label', label(el, theme)));
 }
 
-if (btn) {
-  btn.setAttribute('aria-label', labelFor(html.dataset.theme ?? 'dark'));
-  btn.addEventListener('click', () => {
+syncLabels(html.dataset.theme ?? 'dark');
+toggles.forEach((el) =>
+  el.addEventListener('click', () => {
     const next = html.dataset.theme === 'light' ? 'dark' : 'light';
     html.dataset.theme = next;
     try {
@@ -21,6 +23,6 @@ if (btn) {
     } catch {
       /* private mode — ignore */
     }
-    btn.setAttribute('aria-label', labelFor(next));
-  });
-}
+    syncLabels(next);
+  }),
+);