Initial public upload from Projekte/CloudCodeUsageAnalysis

.codex/config.toml

@@ -0,0 +1,31 @@
+# Coding MCPs: project-local registration (2026-09-07).
+
+[mcp_servers.serena]
+command = "/home/smlflg/.local/share/coding-mcp/serena/.venv/bin/serena"
+args = ["start-mcp-server", "--context=codex", "--project", "/home/smlflg/Projekte/CloudCodeUsageAnalysis", "--enable-web-dashboard", "false", "--open-web-dashboard", "false", "--enable-gui-log-window", "false"]
+cwd = "/home/smlflg/Projekte/CloudCodeUsageAnalysis"
+enabled = true
+startup_timeout_sec = 120
+tool_timeout_sec = 180
+
+[mcp_servers.serena.env]
+"SERENA_HOME" = "/home/smlflg/.local/share/coding-mcp/serena/state"
+
+[mcp_servers.gitnexus]
+command = "/home/smlflg/.nvm/versions/node/v24.13.0/bin/node"
+args = ["/home/smlflg/.local/share/coding-mcp/gitnexus/node_modules/gitnexus/dist/cli/index.js", "mcp"]
+cwd = "/home/smlflg/Projekte/CloudCodeUsageAnalysis"
+enabled = true
+startup_timeout_sec = 120
+tool_timeout_sec = 180
+
+[mcp_servers.gitnexus.env]
+"GITNEXUS_HOME" = "/home/smlflg/.local/share/coding-mcp/gitnexus/runtime"
+
+[mcp_servers.context7]
+command = "/home/smlflg/.nvm/versions/node/v24.13.0/bin/node"
+args = ["/home/smlflg/.local/share/coding-mcp/context7/node_modules/@upstash/context7-mcp/dist/index.js"]
+cwd = "/home/smlflg/Projekte/CloudCodeUsageAnalysis"
+enabled = true
+startup_timeout_sec = 120
+tool_timeout_sec = 180

README.md

@@ -0,0 +1,43 @@
+# CloudCode Usage Analysis
+
+Lokale Single-Page-Analyse deines Cloud-Code-Monats auf Basis der Projekte in `~/Projekte`.
+
+## Inhalt
+
+- Executive Summary
+- Arbeitszeit-Schaetzung mit Bandbreite
+- Arbeitsprozess- und Workflow-Muster
+- Projekt-Cluster und Aktivitaetsbild
+- Ranking fuer das wertvollste Weiterentwicklungsprojekt
+
+## Generieren
+
+```bash
+cd ~/ProjekteV2/CodexWebsiteSamuelClaudecode/CloudCodeUsageAnalysis
+python3 scripts/build_analysis.py
+```
+
+Das Script scannt `~/Projekte`, ignoriert fruehere/lower Sidecar-Versionen in der Hauptanalyse und schreibt `data/analysis.json`.
+
+## Lokal starten
+
+```bash
+cd ~/ProjekteV2/CodexWebsiteSamuelClaudecode/CloudCodeUsageAnalysis
+python3 -m http.server 8033
+```
+
+Dann im Browser:
+
+`http://localhost:8033`
+
+## Struktur
+
+- `index.html` – Seite
+- `styles.css` – visuelle Gestaltung
+- `app.js` – Rendering der Analyse aus JSON
+- `scripts/build_analysis.py` – Datenerhebung und Ableitung
+- `data/analysis.json` – generierte Datenbasis
+
+## Hinweis
+
+Diese Analyse veraendert keine bestehenden Projekte. Sie liest nur Git-Historie, Projektstruktur und Doku-Artefakte aus und erzeugt einen neuen separaten Analyse-Ordner.

app.js

@@ -0,0 +1,261 @@
+const formatHours = (value) => `${Number(value).toFixed(1)} h`;
+
+const create = (tag, className, text) => {
+  const node = document.createElement(tag);
+  if (className) node.className = className;
+  if (text !== undefined) node.textContent = text;
+  return node;
+};
+
+const load = async () => {
+  const response = await fetch("./data/analysis.json");
+  if (!response.ok) throw new Error("analysis.json konnte nicht geladen werden");
+  return response.json();
+};
+
+const renderHero = (data) => {
+  document.querySelector("#headline").textContent = data.executive_summary.headline;
+  const panel = document.querySelector("#heroPanel");
+  const stats = [
+    ["Best Estimate", formatHours(data.work_estimate.best_estimate_hours)],
+    ["Aktive Projekte", String(data.work_estimate.active_project_count)],
+    ["Top Empfehlung", data.rankings.top_recommendation.name],
+    ["Analysefenster", `${data.meta.window_start} bis ${data.meta.window_end}`],
+  ];
+  stats.forEach(([label, value]) => {
+    const row = create("div", "summary-stat");
+    row.append(create("span", "", label));
+    row.append(create("strong", "", value));
+    panel.append(row);
+  });
+};
+
+const renderFindings = (data) => {
+  const host = document.querySelector("#findingCards");
+  data.executive_summary.key_findings.forEach((finding, index) => {
+    const card = create("article", "card");
+    card.append(create("div", "label", `Antwort ${index + 1}`));
+    card.append(create("p", "supporting", finding));
+    host.append(card);
+  });
+};
+
+const renderWork = (data) => {
+  const host = document.querySelector("#workCards");
+  const cards = [
+    ["Best Estimate", formatHours(data.work_estimate.best_estimate_hours), "Zentralwert aus Session-Bloecken, Commit-Spans und Artefakt-Bonus."],
+    ["Untergrenze", formatHours(data.work_estimate.lower_bound_hours), "Konservative Sicht: nur ein Teil der Session-Zeit zaehlt als aktive Build-Zeit."],
+    ["Obergrenze", formatHours(data.work_estimate.upper_bound_hours), "Erweitert um stille Vor-/Nacharbeit, verworfene Versuche und uncommitted Arbeit."],
+  ];
+  cards.forEach(([label, metric, support]) => {
+    const card = create("article", "card");
+    card.append(create("div", "label", label));
+    card.append(create("p", "metric", metric));
+    card.append(create("p", "supporting", support));
+    host.append(card);
+  });
+
+  const methodList = document.querySelector("#methodList");
+  data.work_estimate.method.forEach((line) => methodList.append(create("li", "", line)));
+  const uncertaintyList = document.querySelector("#uncertaintyList");
+  data.work_estimate.uncertainties.forEach((line) => uncertaintyList.append(create("li", "", line)));
+};
+
+const renderWorkflow = (data) => {
+  const workflow = data.workflow_patterns;
+  const narrative = document.querySelector("#workflowNarrative");
+  [workflow.startup_pattern, workflow.iteration_pattern, workflow.parallel_vs_serial.evidence].forEach((line) => {
+    narrative.append(create("p", "", line));
+  });
+
+  const total = workflow.prototyping_vs_refinement.prototype_signals + workflow.prototyping_vs_refinement.refinement_signals;
+  const protoPct = total ? (workflow.prototyping_vs_refinement.prototype_signals / total) * 100 : 0;
+  const refinePct = 100 - protoPct;
+  const chart = document.querySelector("#ratioChart");
+  [
+    ["Prototyping", protoPct, "proto"],
+    ["Refinement", refinePct, "refine"],
+  ].forEach(([label, pct, klass]) => {
+    const row = create("div", "mini-row");
+    row.append(create("div", "", label));
+    const track = create("div", "track");
+    const fill = create("span");
+    fill.className = klass;
+    fill.style.width = `${pct}%`;
+    track.append(fill);
+    row.append(track);
+    row.append(create("div", "muted", `${pct.toFixed(0)}%`));
+    chart.append(row);
+  });
+  document.querySelector("#ratioNote").textContent = workflow.prototyping_vs_refinement.interpretation;
+
+  const cards = [
+    ["Seriell vs. Parallel", workflow.parallel_vs_serial.label],
+    ["Eval-Loops", workflow.evaluation_loops.interpretation],
+    ["Bevorzugte Projektarten", workflow.preferred_project_types.join(" • ")],
+    ["Meta-Systeme", workflow.meta_systems.join(" • ")],
+  ];
+  const host = document.querySelector("#workflowCards");
+  cards.forEach(([label, support]) => {
+    const card = create("article", "card");
+    card.append(create("div", "label", label));
+    card.append(create("p", "supporting", support));
+    host.append(card);
+  });
+};
+
+const renderClusters = (data) => {
+  const grid = document.querySelector("#clusterGrid");
+  data.project_clusters.forEach((cluster) => {
+    const card = create("article", "cluster-card");
+    card.append(create("div", "label", `${cluster.count} Projekte`));
+    card.append(create("h3", "", cluster.name));
+    card.append(create("p", "supporting", cluster.summary));
+    const pills = create("div", "pill-row");
+    cluster.projects.forEach((project) => {
+      pills.append(create("span", "pill", `${project.name} · ${project.commit_count}`));
+    });
+    card.append(pills);
+    grid.append(card);
+  });
+
+  const tableHost = document.querySelector("#projectTable");
+  const table = create("table");
+  table.innerHTML = `
+    <thead>
+      <tr>
+        <th>Projekt</th>
+        <th>Cluster</th>
+        <th>Commits</th>
+        <th>Sessions</th>
+        <th>Status</th>
+      </tr>
+    </thead>
+    <tbody></tbody>
+  `;
+  const tbody = table.querySelector("tbody");
+  data.projects.slice(0, 12).forEach((project) => {
+    const row = document.createElement("tr");
+    row.innerHTML = `
+      <td>${project.name}</td>
+      <td>${project.cluster}</td>
+      <td>${project.commit_count}</td>
+      <td>${project.session_count}</td>
+      <td>${project.status}</td>
+    `;
+    tbody.append(row);
+  });
+  tableHost.append(table);
+};
+
+const renderTimeline = (data) => {
+  const host = document.querySelector("#timeline");
+  const grid = create("div", "timeline-grid");
+  data.timeline.forEach((day) => {
+    const cell = create("article", `day-cell level-${day.intensity}`);
+    const date = new Date(day.date);
+    const label = date.toLocaleDateString("de-DE", { day: "2-digit", month: "2-digit" });
+    const header = create("div", "day-head");
+    header.append(create("span", "", label));
+    header.append(create("span", "", `${day.projects.length} Projekte`));
+    cell.append(header);
+    const projects = create("div", "day-projects");
+    if (day.projects.length === 0) {
+      projects.append(create("span", "muted", "ruhiger Tag"));
+    } else {
+      day.projects.slice(0, 3).forEach((project) => {
+        projects.append(create("span", "", `${project.name} · ${project.session_count} Session`));
+      });
+    }
+    cell.append(projects);
+    grid.append(cell);
+  });
+  host.append(grid);
+};
+
+const renderRanking = (data) => {
+  const top = data.rankings.top_recommendation;
+  const main = document.querySelector("#topRecommendation");
+  main.append(create("div", "badge", "Top Empfehlung"));
+  main.append(create("h3", "", top.name));
+  main.append(create("p", "metric", `${top.score.toFixed(2)} / 5`));
+  main.append(create("p", "supporting", top.summary));
+
+  const stack = create("div", "mini-stack");
+  Object.entries(top.scores).forEach(([label, value]) => {
+    const row = create("div", "mini-row");
+    row.append(create("div", "", label.replace("_", " ")));
+    const track = create("div", "track");
+    const fill = create("span");
+    fill.style.width = `${(value / 5) * 100}%`;
+    track.append(fill);
+    row.append(track);
+    row.append(create("div", "muted", value.toFixed(1)));
+    stack.append(row);
+  });
+  main.append(stack);
+
+  const topThree = document.querySelector("#topThree");
+  data.rankings.top_three.forEach((project, index) => {
+    const item = create("div", "rank-item");
+    item.innerHTML = `<strong>#${index + 1} ${project.name}</strong><p class="supporting">${project.summary}</p>`;
+    topThree.append(item);
+  });
+
+  const rankingTable = document.querySelector("#rankingTable");
+  const table = create("table");
+  table.innerHTML = `
+    <thead>
+      <tr>
+        <th>Projekt</th>
+        <th>Score</th>
+        <th>Commits</th>
+        <th>Kernaussage</th>
+      </tr>
+    </thead>
+    <tbody></tbody>
+  `;
+  const tbody = table.querySelector("tbody");
+  data.rankings.shortlist.forEach((project) => {
+    const row = document.createElement("tr");
+    row.innerHTML = `
+      <td>${project.name}</td>
+      <td>${project.score.toFixed(2)}</td>
+      <td>${project.commit_count}</td>
+      <td>${project.summary}</td>
+    `;
+    tbody.append(row);
+  });
+  rankingTable.append(table);
+};
+
+const renderEvidence = (data) => {
+  const host = document.querySelector("#evidenceGrid");
+  data.evidence.forEach((entry) => {
+    const card = create("article", "evidence-card");
+    card.append(create("div", "label", entry.project));
+    card.append(create("p", "supporting", `${entry.commits} Commits im Fenster · letzter Commit ${entry.last_commit ?? "n/a"}`));
+    const pills = create("div", "pill-row");
+    Object.entries(entry.artifacts).forEach(([key, value]) => pills.append(create("span", "pill", `${key}: ${value}`)));
+    card.append(pills);
+    const list = create("ul", "bullet-list");
+    entry.sample_messages.forEach((message) => list.append(create("li", "", message)));
+    card.append(list);
+    host.append(card);
+  });
+};
+
+load()
+  .then((data) => {
+    renderHero(data);
+    renderFindings(data);
+    renderWork(data);
+    renderWorkflow(data);
+    renderClusters(data);
+    renderTimeline(data);
+    renderRanking(data);
+    renderEvidence(data);
+  })
+  .catch((error) => {
+    document.body.innerHTML = `<main class="page-shell"><article class="panel"><h1>Ladefehler</h1><p>${error.message}</p></article></main>`;
+  });

index.html

@@ -0,0 +1,115 @@
+<!doctype html>
+<html lang="de">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Cloud Code Usage Analysis</title>
+    <link rel="stylesheet" href="./styles.css" />
+  </head>
+  <body>
+    <div class="page-shell">
+      <header class="hero">
+        <div class="hero-copy">
+          <p class="eyebrow">Cloud Code Month Analysis</p>
+          <h1>Wie dein Monat mit Cloud Code aussah, in Evidenz statt Bauchgefuehl.</h1>
+          <p class="lede" id="headline"></p>
+        </div>
+        <aside class="hero-panel" id="heroPanel"></aside>
+      </header>
+
+      <main>
+        <section class="section" id="summarySection">
+          <div class="section-heading">
+            <p class="kicker">Executive Summary</p>
+            <h2>Drei klare Antworten</h2>
+          </div>
+          <div class="cards three" id="findingCards"></div>
+        </section>
+
+        <section class="section">
+          <div class="section-heading">
+            <p class="kicker">Arbeitszeit</p>
+            <h2>Geschaetzte investierte Stunden</h2>
+          </div>
+          <div class="cards three" id="workCards"></div>
+          <div class="split">
+            <article class="panel">
+              <h3>Methodik</h3>
+              <ul class="bullet-list" id="methodList"></ul>
+            </article>
+            <article class="panel">
+              <h3>Unsicherheiten</h3>
+              <ul class="bullet-list" id="uncertaintyList"></ul>
+            </article>
+          </div>
+        </section>
+
+        <section class="section">
+          <div class="section-heading">
+            <p class="kicker">Arbeitsprozess</p>
+            <h2>Wie du mit Cloud Code gearbeitet hast</h2>
+          </div>
+          <div class="split process-layout">
+            <article class="panel narrative" id="workflowNarrative"></article>
+            <article class="panel">
+              <h3>Protoyping vs. Refinement</h3>
+              <div id="ratioChart" class="ratio-chart"></div>
+              <div class="subnote" id="ratioNote"></div>
+            </article>
+          </div>
+          <div class="cards four" id="workflowCards"></div>
+        </section>
+
+        <section class="section">
+          <div class="section-heading">
+            <p class="kicker">Projektlandschaft</p>
+            <h2>Cluster und aktive Schwergewichte</h2>
+          </div>
+          <div class="cluster-grid" id="clusterGrid"></div>
+          <div class="panel">
+            <h3>Aktive Projekte</h3>
+            <div id="projectTable"></div>
+          </div>
+        </section>
+
+        <section class="section">
+          <div class="section-heading">
+            <p class="kicker">Timeline</p>
+            <h2>Aktivitaetsbild der letzten 30 Tage</h2>
+          </div>
+          <article class="panel">
+            <div id="timeline"></div>
+          </article>
+        </section>
+
+        <section class="section">
+          <div class="section-heading">
+            <p class="kicker">Strategische Empfehlung</p>
+            <h2>Welches Projekt jetzt den groessten Mehrwert hat</h2>
+          </div>
+          <div class="split">
+            <article class="panel recommendation-main" id="topRecommendation"></article>
+            <article class="panel">
+              <h3>Top 3</h3>
+              <div id="topThree"></div>
+            </article>
+          </div>
+          <article class="panel">
+            <h3>Shortlist</h3>
+            <div id="rankingTable"></div>
+          </article>
+        </section>
+
+        <section class="section">
+          <div class="section-heading">
+            <p class="kicker">Evidenz</p>
+            <h2>Worauf die Aussagen beruhen</h2>
+          </div>
+          <div class="evidence-grid" id="evidenceGrid"></div>
+        </section>
+      </main>
+    </div>
+
+    <script src="./app.js" type="module"></script>
+  </body>
+</html>

scripts/build_analysis.py

@@ -0,0 +1,577 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import json
+import math
+import os
+import subprocess
+from collections import Counter, defaultdict
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Any
+
+
+ROOT = Path("/home/smlflg/Projekte")
+OUT = Path(__file__).resolve().parents[1] / "data" / "analysis.json"
+WINDOW_END = datetime.fromisoformat("2026-03-20T23:59:59+01:00")
+WINDOW_START = datetime.fromisoformat("2026-02-19T00:00:00+01:00")
+SESSION_GAP_MINUTES = 120
+IGNORED_PROJECTS = {
+    "Sidecar",
+    "Sidecar-V5",
+    "Sidecar-V6",
+    "Sidecar-V7-Lite",
+    "Sidecar-V7-V2",
+    "Sidecar-V8-Plan",
+}
+TOP_RECOMMENDATION_ORDER = [
+    "Sidecar-ng",
+    "MyAIGame",
+    "Sidecar-V7",
+    "ClaudeCodePanel",
+    "Sidecar-Evolution",
+    "AgentArena",
+]
+RANKING_SCORES = {
+    "Sidecar-ng": {
+        "leverage": 5.0,
+        "reusability": 4.6,
+        "strategic_value": 5.0,
+        "product_readiness": 4.5,
+        "synergy": 5.0,
+        "workflow_fit": 5.0,
+    },
+    "MyAIGame": {
+        "leverage": 4.4,
+        "reusability": 5.0,
+        "strategic_value": 4.4,
+        "product_readiness": 3.4,
+        "synergy": 4.8,
+        "workflow_fit": 4.9,
+    },
+    "Sidecar-V7": {
+        "leverage": 4.3,
+        "reusability": 4.3,
+        "strategic_value": 4.4,
+        "product_readiness": 4.5,
+        "synergy": 4.3,
+        "workflow_fit": 4.4,
+    },
+    "ClaudeCodePanel": {
+        "leverage": 4.0,
+        "reusability": 3.4,
+        "strategic_value": 4.2,
+        "product_readiness": 4.8,
+        "synergy": 4.1,
+        "workflow_fit": 4.8,
+    },
+    "Sidecar-Evolution": {
+        "leverage": 3.5,
+        "reusability": 4.4,
+        "strategic_value": 4.8,
+        "product_readiness": 2.3,
+        "synergy": 4.6,
+        "workflow_fit": 3.8,
+    },
+    "AgentArena": {
+        "leverage": 3.9,
+        "reusability": 4.1,
+        "strategic_value": 4.3,
+        "product_readiness": 3.8,
+        "synergy": 4.0,
+        "workflow_fit": 3.7,
+    },
+}
+PROJECT_NOTES = {
+    "Sidecar-ng": "Stateless Hook statt Daemon, direkte Claude-Code-Integration, dokumentierte Evals und klares Accuracy-Signal.",
+    "MyAIGame": "Breites Workflow-Toolkit mit Skills, Hooks, Session-Browser und MCP-Setups als Multiplikator fuer andere Projekte.",
+    "Sidecar-V7": "Reifste volle Sidecar-Ausbaustufe mit hoher Produktnaehe, aber auch sichtbarer Komplexitaetslast.",
+    "ClaudeCodePanel": "Starke Observability-Schicht fuer Sessions, Kosten, Swarms und Events mit direktem Nutzwert im Alltag.",
+    "Sidecar-Evolution": "Meta-Repo fuer KEEP/PARK/KILL-Entscheidungen und Evaluationsarchaeologie, strategisch stark aber indirekt.",
+    "AgentArena": "Eval-Harness mit Benchmark-Logik und Visual-Explainer-Potenzial, aber weniger direkt in den taeglichen Workflow eingebettet.",
+}
+
+
+@dataclass
+class Session:
+    start: datetime
+    end: datetime
+    commit_count: int
+
+    @property
+    def span_hours(self) -> float:
+        return max(0.0, (self.end - self.start).total_seconds() / 3600)
+
+    @property
+    def estimate_hours(self) -> float:
+        padded = self.span_hours + 0.65 + max(0, self.commit_count - 1) * 0.18
+        return max(0.5, min(4.5, padded))
+
+
+def run_git(repo: Path, *args: str) -> str:
+    result = subprocess.run(
+        ["git", "-C", str(repo), *args],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    return result.stdout.strip()
+
+
+def list_repos() -> list[Path]:
+    repos = []
+    for entry in sorted(ROOT.iterdir()):
+        if not entry.is_dir() or entry.name.startswith("."):
+            continue
+        if (entry / ".git").is_dir():
+            repos.append(entry)
+    return repos
+
+
+def parse_log(repo: Path) -> list[dict[str, Any]]:
+    out = run_git(
+        repo,
+        "log",
+        f"--since={WINDOW_START.isoformat(sep=' ')}",
+        f"--until={WINDOW_END.isoformat(sep=' ')}",
+        "--date=iso-strict",
+        "--pretty=format:%ad%x1f%s%x1f%h",
+    )
+    commits = []
+    for line in out.splitlines():
+        if not line.strip():
+            continue
+        date_str, subject, short_hash = line.split("\x1f")
+        ts = datetime.fromisoformat(date_str)
+        commits.append(
+            {
+                "timestamp": ts,
+                "date": ts.strftime("%Y-%m-%d"),
+                "time": ts.strftime("%H:%M"),
+                "subject": subject,
+                "hash": short_hash,
+            }
+        )
+    return commits
+
+
+def build_sessions(commits: list[dict[str, Any]]) -> list[Session]:
+    if not commits:
+        return []
+    ordered = sorted((c["timestamp"] for c in commits))
+    sessions: list[Session] = []
+    current = [ordered[0]]
+    for ts in ordered[1:]:
+        if (ts - current[-1]).total_seconds() / 60 > SESSION_GAP_MINUTES:
+            sessions.append(Session(current[0], current[-1], len(current)))
+            current = [ts]
+        else:
+            current.append(ts)
+    sessions.append(Session(current[0], current[-1], len(current)))
+    return sessions
+
+
+def find_artifacts(repo: Path) -> list[Path]:
+    artifacts = []
+    patterns = ("README", "PLAN", "REVIEW", "BACKLOG", "FOR_SMLFLG")
+    for path in repo.rglob("*"):
+        if path.is_dir():
+            continue
+        if ".git" in path.parts:
+            continue
+        if len(path.relative_to(repo).parts) > 3:
+            continue
+        if any(path.name.upper().startswith(prefix) for prefix in patterns):
+            artifacts.append(path)
+    return sorted(artifacts)
+
+
+def latest_activity(repo: Path) -> str | None:
+    latest = 0.0
+    for path in repo.rglob("*"):
+        if ".git" in path.parts:
+            continue
+        try:
+            if path.is_file():
+                latest = max(latest, path.stat().st_mtime)
+        except OSError:
+            continue
+    if not latest:
+        return None
+    return datetime.fromtimestamp(latest).strftime("%Y-%m-%d %H:%M")
+
+
+def in_window(date_text: str | None) -> bool:
+    if not date_text:
+        return False
+    ts = datetime.strptime(date_text, "%Y-%m-%d %H:%M")
+    return WINDOW_START.replace(tzinfo=None) <= ts <= WINDOW_END.replace(tzinfo=None)
+
+
+def classify_project(repo: Path, artifacts: list[Path]) -> tuple[str, str]:
+    names = {p.name.lower() for p in repo.iterdir()}
+    text = " ".join(path.name.lower() for path in artifacts)
+    repo_name = repo.name.lower()
+    if "sidecar" in repo_name:
+        return "Sidecar / Meta Tooling", "Agent workflow instrumentation, hooks, evals or platforming."
+    if any(token in repo_name for token in ("agent", "swarm", "arena")):
+        return "Agent Infrastructure", "Agent evaluation, orchestration or execution surface."
+    if {"templates", "static"}.issubset(names) or "htmx" in text:
+        return "Vertical App", "Local web app pattern with templates/static/tests suggests end-user MVPs."
+    if any(token in repo_name for token in ("panel", "dashboard", "monitor", "counter", "voicemode")):
+        return "Personal Workflow OS", "Observability or desktop support tooling for your own coding environment."
+    if any(token in repo_name for token in ("prompt", "writing", "bookmark")):
+        return "Knowledge / Content", "Prompt, content or knowledge capture system."
+    return "Tooling", "General-purpose local project tooling."
+
+
+def summarize_commit_types(commits: list[dict[str, Any]]) -> dict[str, int]:
+    counts = Counter()
+    for commit in commits:
+        subject = commit["subject"].lower()
+        for key in ("feat", "fix", "test", "docs", "refactor", "chore"):
+            if subject.startswith(f"{key}:") or subject.startswith(f"{key}(") or subject.startswith(f"{key} "):
+                counts[key] += 1
+                break
+        else:
+            counts["other"] += 1
+    return dict(counts)
+
+
+def has_uncommitted_work(repo: Path) -> bool:
+    return bool(run_git(repo, "status", "--short"))
+
+
+def repo_summary(repo: Path) -> dict[str, Any]:
+    commits = parse_log(repo)
+    sessions = build_sessions(commits)
+    artifacts = find_artifacts(repo)
+    cluster, cluster_reason = classify_project(repo, artifacts)
+    branch = run_git(repo, "rev-parse", "--abbrev-ref", "HEAD") or "unknown"
+    status = run_git(repo, "status", "--short")
+    status_label = "clean"
+    if status:
+        status_label = "dirty" if any(not line.startswith("??") for line in status.splitlines()) else "untracked-only"
+    commit_days = sorted({c["date"] for c in commits})
+    commit_type_counts = summarize_commit_types(commits)
+    plan_count = sum(1 for path in artifacts if path.name.upper().startswith("PLAN"))
+    review_count = sum(1 for path in artifacts if path.name.upper().startswith("REVIEW"))
+    readme_count = sum(1 for path in artifacts if path.name.upper().startswith("README"))
+    backlog_count = sum(1 for path in artifacts if path.name.upper().startswith("BACKLOG"))
+    has_tests = (repo / "tests").exists() or (repo / "e2e").exists()
+    has_eval = (repo / "eval").exists()
+    has_docs = (repo / "docs").exists()
+    return {
+        "name": repo.name,
+        "path": str(repo),
+        "branch": branch,
+        "status": status_label,
+        "has_uncommitted_work": has_uncommitted_work(repo),
+        "latest_activity": latest_activity(repo),
+        "cluster": cluster,
+        "cluster_reason": cluster_reason,
+        "commit_count": len(commits),
+        "commit_days": commit_days,
+        "commit_day_count": len(commit_days),
+        "commits_sample": [
+            {"date": c["date"], "time": c["time"], "subject": c["subject"], "hash": c["hash"]}
+            for c in commits[:8]
+        ],
+        "first_commit": commits[-1]["date"] if commits else None,
+        "last_commit": commits[0]["date"] if commits else None,
+        "artifact_counts": {
+            "readme": readme_count,
+            "plan": plan_count,
+            "review": review_count,
+            "backlog": backlog_count,
+        },
+        "structure_markers": {
+            "tests": has_tests,
+            "eval": has_eval,
+            "docs": has_docs,
+            "systemd": (repo / "systemd").exists(),
+            "knowledge": (repo / "knowledge").exists(),
+            "adapters": (repo / "adapters").exists(),
+            "core": (repo / "core").exists(),
+            "samuel": (repo / "samuel").exists(),
+        },
+        "commit_type_counts": commit_type_counts,
+        "session_count": len(sessions),
+        "sessions": [
+            {
+                "start": s.start.isoformat(),
+                "end": s.end.isoformat(),
+                "commit_count": s.commit_count,
+                "estimate_hours": round(s.estimate_hours, 2),
+            }
+            for s in sessions
+        ],
+        "estimated_hours": round(sum(s.estimate_hours for s in sessions), 2),
+    }
+
+
+def estimate_work_hours(projects: list[dict[str, Any]]) -> dict[str, Any]:
+    active = [
+        p
+        for p in projects
+        if p["commit_count"] > 0 or (p["has_uncommitted_work"] and in_window(p["latest_activity"]))
+    ]
+    session_hours = sum(p["estimated_hours"] for p in active)
+    artifact_bonus = 0.0
+    uncertainty = []
+    for project in active:
+        artifact_count = sum(project["artifact_counts"].values())
+        if artifact_count:
+            artifact_bonus += min(1.0, 0.15 * artifact_count)
+        if project["has_uncommitted_work"] and project["commit_count"] == 0 and in_window(project["latest_activity"]):
+            artifact_bonus += 0.75
+            uncertainty.append(f"{project['name']} hatte lokale Aktivitaet ohne Commit-Spur im Fenster.")
+    best = round(session_hours + artifact_bonus, 1)
+    lower = round(max(1.0, session_hours * 0.72), 1)
+    upper = round(best * 1.38 + 4.0, 1)
+    return {
+        "best_estimate_hours": best,
+        "lower_bound_hours": lower,
+        "upper_bound_hours": upper,
+        "active_project_count": len(active),
+        "method": [
+            "Commit-Timestamps im Fenster 2026-02-19 bis 2026-03-20 zu Sessions gebuendelt (neue Session ab >120 Minuten Luecke).",
+            "Pro Session Schaetzung aus beobachtetem Commit-Span plus Puffer fuer Vor-/Nacharbeit, gedeckelt um einzelne Squash- oder Burst-Sessions nicht zu uebergewichten.",
+            "Zusatzbonus fuer PLAN/REVIEW/BACKLOG-Artefakte und uncommitted Aktivitaet, weil Cloud-Code-Arbeit oft ausserhalb des finalen Commits sichtbar wird.",
+        ],
+        "uncertainties": uncertainty
+        + [
+            "Nicht jede Arbeitsminute landet in Git; besonders lokale Experimente, Copy/Paste, Prompting und verworfene Ansaetze fehlen teilweise.",
+            "Einige Commits koennen squash-/batch-artig sein und daher mehr reale Arbeit reprasentieren als die Zeitdifferenzen zeigen.",
+        ],
+    }
+
+
+def build_timeline(projects: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    days = []
+    cursor = WINDOW_START.date()
+    end_date = WINDOW_END.date()
+    while cursor <= end_date:
+        day_projects = []
+        commit_total = 0
+        for project in projects:
+            matches = [c for c in project["commits_sample"]]  # placeholder for schema consistency
+            count = sum(1 for session in project["sessions"] if session["start"][:10] == cursor.isoformat())
+            if count:
+                day_projects.append({"name": project["name"], "session_count": count})
+            commit_total += sum(1 for d in project["commit_days"] if d == cursor.isoformat())
+        intensity = min(4, commit_total)
+        days.append(
+            {
+                "date": cursor.isoformat(),
+                "commit_days": commit_total,
+                "intensity": intensity,
+                "projects": day_projects,
+            }
+        )
+        cursor += timedelta(days=1)
+    return days
+
+
+def workflow_patterns(projects: list[dict[str, Any]]) -> dict[str, Any]:
+    commit_types = Counter()
+    active_projects = [p for p in projects if p["commit_count"] > 0]
+    day_to_projects: dict[str, set[str]] = defaultdict(set)
+    for project in active_projects:
+        commit_types.update(project["commit_type_counts"])
+        for day in project["commit_days"]:
+            day_to_projects[day].add(project["name"])
+    multi_project_days = sum(1 for names in day_to_projects.values() if len(names) >= 2)
+    prototype_signals = commit_types["feat"] + commit_types["other"]
+    refinement_signals = commit_types["fix"] + commit_types["test"] + commit_types["refactor"] + commit_types["docs"]
+    eval_projects = [
+        p["name"]
+        for p in projects
+        if p["structure_markers"]["eval"] or p["artifact_counts"]["review"] or p["commit_type_counts"].get("test", 0)
+    ]
+    top_active = sorted(active_projects, key=lambda p: p["commit_count"], reverse=True)[:5]
+    return {
+        "startup_pattern": "Du startest Projekte meist mit schriftlicher Rahmung: READMEs, PLAN-Dateien und Kontext-Artefakte tauchen sehr frueh auf und bleiben als Steuerungsoberflaeche erhalten.",
+        "iteration_pattern": "Die dominante Schleife ist nicht linearer Build, sondern schnelle Zyklen aus feat/fix/test/docs. Sidecar-Projekte zeigen besonders stark: erst Scope aufspannen, dann messen, dann radikal zusammenstreichen.",
+        "parallel_vs_serial": {
+            "label": "Hybrid mit Sidecar als seriellem Hauptstrang",
+            "evidence": f"{multi_project_days} Tage im Fenster zeigen Aktivitaet in mindestens zwei Projekten; gleichzeitig konzentrieren sich die meisten Commits auf wenige Kernrepos mit Sidecar-ng, Sidecar-V7, ClaudeCodePanel und AgentArena.",
+        },
+        "prototyping_vs_refinement": {
+            "prototype_signals": prototype_signals,
+            "refinement_signals": refinement_signals,
+            "interpretation": "Der Monat kippt nach fruehem Scope-Aufbau deutlich in Refinement: Tests, Doku, Refactors und Eval-Artefakte sind in den aktiven Kernprojekten stark sichtbar.",
+        },
+        "evaluation_loops": {
+            "projects": eval_projects[:8],
+            "interpretation": "Eval-/Review-Loops sind kein Nachgedanke. AgentArena, Sidecar-ng, Sidecar-Evolution und ClaudeCodePanel zeigen Mess-, Review- oder Validierungsartefakte direkt im Repo.",
+        },
+        "preferred_project_types": [
+            "Agentische Infrastruktur und Eval-Harnesses",
+            "Persoenliche Workflow- und Observability-Tools",
+            "Lokale Python-Web-MVPs mit templates/static/tests",
+        ],
+        "meta_systems": [
+            "Selbstinstrumentierung des eigenen Entwicklungsprozesses",
+            "Core-vs-Personalization-Trennung in reiferen Systemen",
+            "Planungsrepo und Implementierungsrepo bewusst auseinanderziehen",
+        ],
+        "featured_projects": [
+            {"name": project["name"], "commit_count": project["commit_count"], "cluster": project["cluster"]}
+            for project in top_active
+        ],
+    }
+
+
+def ranking(projects: list[dict[str, Any]]) -> dict[str, Any]:
+    lookup = {project["name"]: project for project in projects}
+    rows = []
+    for name in TOP_RECOMMENDATION_ORDER:
+        if name not in lookup:
+            continue
+        scores = RANKING_SCORES[name]
+        weighted = round(
+            (
+                scores["leverage"] * 0.24
+                + scores["reusability"] * 0.16
+                + scores["strategic_value"] * 0.18
+                + scores["product_readiness"] * 0.14
+                + scores["synergy"] * 0.16
+                + scores["workflow_fit"] * 0.12
+            ),
+            2,
+        )
+        project = lookup[name]
+        rows.append(
+            {
+                "name": name,
+                "score": weighted,
+                "scores": scores,
+                "commit_count": project["commit_count"],
+                "last_commit": project["last_commit"],
+                "summary": PROJECT_NOTES[name],
+            }
+        )
+    rows.sort(key=lambda row: row["score"], reverse=True)
+    return {
+        "top_recommendation": rows[0],
+        "top_three": rows[:3],
+        "shortlist": rows[:5],
+        "method": "Editorial scoring auf sechs Kriterien, kombiniert mit Aktivitaetssignalen, Doku-Dichte und Synergie zum Cloud-Code-Workflow.",
+    }
+
+
+def build_executive_summary(projects: list[dict[str, Any]], work_estimate: dict[str, Any], rank: dict[str, Any]) -> dict[str, Any]:
+    active = sorted(
+        (
+            p
+            for p in projects
+            if p["commit_count"] > 0 or (p["has_uncommitted_work"] and in_window(p["latest_activity"]))
+        ),
+        key=lambda p: p["commit_count"],
+        reverse=True,
+    )
+    headline = (
+        f"Im 30-Tage-Fenster liegen geschaetzt {work_estimate['best_estimate_hours']} Stunden Cloud-Code-Arbeit "
+        f"ueber {work_estimate['active_project_count']} aktiv sichtbare Projekte."
+    )
+    return {
+        "headline": headline,
+        "key_findings": [
+            "Der Monat war kein einzelnes Produktprojekt, sondern ein Portfolio aus Meta-Tooling, Evaluationssystemen und persoenlichen Workflow-Oberflaechen.",
+            "Die staerkste Prozesssignatur ist instrumentierte Iteration: PLAN/REVIEW/EVAL-Dateien und test-/docs-lastige Commits begleiten die Umsetzung eng.",
+            f"Die beste Weiterentwicklungswette ist {rank['top_recommendation']['name']}, weil dort Hebel, Reifegrad und direkter Workflow-Fit am staerksten zusammenfallen.",
+        ],
+        "top_activity": [
+            {
+                "name": project["name"],
+                "commit_count": project["commit_count"],
+                "session_count": project["session_count"],
+                "cluster": project["cluster"],
+            }
+            for project in active[:6]
+        ],
+    }
+
+
+def build_clusters(projects: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    grouped: dict[str, list[dict[str, Any]]] = defaultdict(list)
+    for project in projects:
+        grouped[project["cluster"]].append(project)
+    output = []
+    for cluster, items in grouped.items():
+        output.append(
+            {
+                "name": cluster,
+                "count": len(items),
+                "projects": [
+                    {
+                        "name": item["name"],
+                        "commit_count": item["commit_count"],
+                        "status": item["status"],
+                    }
+                    for item in sorted(items, key=lambda p: p["commit_count"], reverse=True)[:8]
+                ],
+                "summary": items[0]["cluster_reason"],
+            }
+        )
+    output.sort(key=lambda item: item["count"], reverse=True)
+    return output
+
+
+def build_evidence(projects: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    lookup = {p["name"]: p for p in projects}
+    evidence_rows = []
+    for name in ["Sidecar-ng", "Sidecar-V7", "ClaudeCodePanel", "AgentArena", "MyAIGame", "Sidecar-Evolution", "Sidecar-V8"]:
+        project = lookup.get(name)
+        if not project:
+            continue
+        evidence_rows.append(
+            {
+                "project": name,
+                "commits": project["commit_count"],
+                "last_commit": project["last_commit"],
+                "artifacts": project["artifact_counts"],
+                "markers": project["structure_markers"],
+                "sample_messages": [entry["subject"] for entry in project["commits_sample"][:3]],
+            }
+        )
+    return evidence_rows
+
+
+def build_payload() -> dict[str, Any]:
+    repos = [repo for repo in list_repos() if repo.name not in IGNORED_PROJECTS]
+    projects = [repo_summary(repo) for repo in repos]
+    projects.sort(key=lambda project: (project["commit_count"], project["estimated_hours"]), reverse=True)
+    work_estimate = estimate_work_hours(projects)
+    rank = ranking(projects)
+    return {
+        "meta": {
+            "generated_at": datetime.now().isoformat(timespec="seconds"),
+            "source_root": str(ROOT),
+            "window_start": WINDOW_START.date().isoformat(),
+            "window_end": WINDOW_END.date().isoformat(),
+            "ignored_projects": sorted(IGNORED_PROJECTS),
+            "project_count": len(projects),
+        },
+        "executive_summary": build_executive_summary(projects, work_estimate, rank),
+        "work_estimate": work_estimate,
+        "workflow_patterns": workflow_patterns(projects),
+        "project_clusters": build_clusters(projects),
+        "timeline": build_timeline(projects),
+        "rankings": rank,
+        "evidence": build_evidence(projects),
+        "projects": projects,
+    }
+
+
+def main() -> None:
+    payload = build_payload()
+    OUT.parent.mkdir(parents=True, exist_ok=True)
+    OUT.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+    print(f"Wrote {OUT}")
+
+
+if __name__ == "__main__":
+    main()

styles.css

@@ -0,0 +1,431 @@
+:root {
+  --bg: #07111d;
+  --bg-soft: #0d1827;
+  --panel: rgba(12, 23, 38, 0.84);
+  --panel-strong: rgba(17, 31, 49, 0.94);
+  --line: rgba(151, 184, 214, 0.17);
+  --text: #edf3fb;
+  --muted: #97aac0;
+  --gold: #f0cf8e;
+  --teal: #77dfd0;
+  --green: #91e5a5;
+  --amber: #f4c16e;
+  --red: #f08f88;
+  --shadow: 0 24px 60px rgba(0, 0, 0, 0.34);
+  --radius: 24px;
+}
+
+* {
+  box-sizing: border-box;
+}
+
+html {
+  scroll-behavior: smooth;
+}
+
+body {
+  margin: 0;
+  color: var(--text);
+  background:
+    radial-gradient(circle at top left, rgba(47, 120, 173, 0.2), transparent 32%),
+    radial-gradient(circle at top right, rgba(240, 207, 142, 0.12), transparent 28%),
+    linear-gradient(180deg, #08111d 0%, #07111d 44%, #0a1522 100%);
+  font-family: "Avenir Next", "Segoe UI", "Helvetica Neue", sans-serif;
+}
+
+body::before {
+  content: "";
+  position: fixed;
+  inset: 0;
+  pointer-events: none;
+  background-image:
+    linear-gradient(rgba(255, 255, 255, 0.02) 1px, transparent 1px),
+    linear-gradient(90deg, rgba(255, 255, 255, 0.02) 1px, transparent 1px);
+  background-size: 48px 48px;
+  mask-image: linear-gradient(180deg, black 35%, transparent 100%);
+}
+
+.page-shell {
+  width: min(1200px, calc(100vw - 32px));
+  margin: 0 auto;
+  padding: 36px 0 80px;
+}
+
+.hero {
+  display: grid;
+  grid-template-columns: 1.5fr 0.9fr;
+  gap: 24px;
+  align-items: stretch;
+  margin-bottom: 40px;
+}
+
+.hero-copy,
+.hero-panel,
+.panel,
+.card,
+.cluster-card,
+.evidence-card {
+  border: 1px solid var(--line);
+  background: var(--panel);
+  box-shadow: var(--shadow);
+  backdrop-filter: blur(18px);
+}
+
+.hero-copy {
+  border-radius: 28px;
+  padding: 36px;
+  min-height: 320px;
+}
+
+.hero-panel,
+.panel {
+  border-radius: var(--radius);
+  padding: 24px;
+}
+
+.eyebrow,
+.kicker {
+  margin: 0 0 10px;
+  color: var(--teal);
+  font-size: 0.82rem;
+  text-transform: uppercase;
+  letter-spacing: 0.18em;
+}
+
+h1,
+h2,
+h3 {
+  font-family: "Iowan Old Style", "Palatino Linotype", "Book Antiqua", Georgia, serif;
+  font-weight: 600;
+  letter-spacing: -0.03em;
+}
+
+h1 {
+  font-size: clamp(2.6rem, 6vw, 5rem);
+  line-height: 0.95;
+  margin: 0 0 18px;
+  max-width: 12ch;
+}
+
+h2 {
+  margin: 0;
+  font-size: clamp(1.8rem, 3vw, 2.7rem);
+}
+
+h3 {
+  margin-top: 0;
+  font-size: 1.25rem;
+}
+
+.lede {
+  color: var(--muted);
+  font-size: 1.08rem;
+  line-height: 1.7;
+  max-width: 58ch;
+}
+
+.summary-stat {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  padding: 16px 0;
+  border-bottom: 1px solid var(--line);
+}
+
+.summary-stat:last-child {
+  border-bottom: 0;
+  padding-bottom: 0;
+}
+
+.summary-stat strong {
+  font-size: 1.8rem;
+  font-family: "Iowan Old Style", "Palatino Linotype", Georgia, serif;
+}
+
+.summary-stat span {
+  color: var(--muted);
+}
+
+.section {
+  margin-top: 34px;
+}
+
+.section-heading {
+  display: flex;
+  justify-content: space-between;
+  gap: 20px;
+  align-items: end;
+  margin-bottom: 18px;
+}
+
+.cards {
+  display: grid;
+  gap: 18px;
+}
+
+.cards.three {
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+}
+
+.cards.four {
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+}
+
+.card,
+.cluster-card,
+.evidence-card {
+  border-radius: 22px;
+  padding: 22px;
+}
+
+.card .label,
+.cluster-card .label {
+  color: var(--muted);
+  text-transform: uppercase;
+  letter-spacing: 0.14em;
+  font-size: 0.74rem;
+  margin-bottom: 12px;
+}
+
+.metric {
+  font-size: 2.4rem;
+  font-family: "Iowan Old Style", "Palatino Linotype", Georgia, serif;
+  margin: 0 0 8px;
+}
+
+.supporting {
+  color: var(--muted);
+  line-height: 1.65;
+}
+
+.split {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 18px;
+  margin-top: 18px;
+}
+
+.process-layout {
+  align-items: stretch;
+}
+
+.narrative p,
+.bullet-list li,
+.subnote,
+table {
+  color: var(--muted);
+  line-height: 1.65;
+}
+
+.bullet-list {
+  margin: 0;
+  padding-left: 18px;
+}
+
+.ratio-chart {
+  display: grid;
+  gap: 12px;
+}
+
+.ratio-bar {
+  position: relative;
+  height: 18px;
+  border-radius: 999px;
+  overflow: hidden;
+  background: rgba(255, 255, 255, 0.06);
+}
+
+.ratio-bar span {
+  display: block;
+  height: 100%;
+}
+
+.proto {
+  background: linear-gradient(90deg, #f0cf8e, #e59d54);
+}
+
+.refine {
+  background: linear-gradient(90deg, #77dfd0, #56a9df);
+}
+
+.mini-stack {
+  display: grid;
+  gap: 10px;
+  margin-top: 18px;
+}
+
+.mini-row {
+  display: grid;
+  grid-template-columns: 110px 1fr auto;
+  gap: 12px;
+  align-items: center;
+}
+
+.track {
+  height: 10px;
+  border-radius: 999px;
+  overflow: hidden;
+  background: rgba(255, 255, 255, 0.06);
+}
+
+.track > span {
+  display: block;
+  height: 100%;
+  border-radius: inherit;
+  background: linear-gradient(90deg, var(--teal), var(--green));
+}
+
+.cluster-grid,
+.evidence-grid {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 18px;
+}
+
+.pill-row {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  margin-top: 12px;
+}
+
+.pill {
+  padding: 7px 10px;
+  border-radius: 999px;
+  background: rgba(255, 255, 255, 0.06);
+  color: var(--text);
+  font-size: 0.86rem;
+}
+
+table {
+  width: 100%;
+  border-collapse: collapse;
+}
+
+th,
+td {
+  text-align: left;
+  padding: 12px 10px;
+  border-bottom: 1px solid var(--line);
+  vertical-align: top;
+}
+
+th {
+  color: var(--text);
+  font-size: 0.84rem;
+  text-transform: uppercase;
+  letter-spacing: 0.12em;
+}
+
+.timeline-grid {
+  display: grid;
+  grid-template-columns: repeat(10, minmax(0, 1fr));
+  gap: 10px;
+}
+
+.day-cell {
+  padding: 12px;
+  border-radius: 18px;
+  min-height: 92px;
+  border: 1px solid var(--line);
+  background: rgba(255, 255, 255, 0.03);
+}
+
+.day-cell.level-0 {
+  opacity: 0.42;
+}
+
+.day-cell.level-1 {
+  background: linear-gradient(180deg, rgba(119, 223, 208, 0.1), rgba(255, 255, 255, 0.02));
+}
+
+.day-cell.level-2 {
+  background: linear-gradient(180deg, rgba(119, 223, 208, 0.18), rgba(255, 255, 255, 0.03));
+}
+
+.day-cell.level-3,
+.day-cell.level-4 {
+  background: linear-gradient(180deg, rgba(240, 207, 142, 0.2), rgba(255, 255, 255, 0.04));
+}
+
+.day-head {
+  display: flex;
+  justify-content: space-between;
+  gap: 10px;
+  margin-bottom: 8px;
+  color: var(--muted);
+  font-size: 0.82rem;
+}
+
+.day-projects {
+  display: grid;
+  gap: 6px;
+  font-size: 0.84rem;
+}
+
+.recommendation-main .badge {
+  display: inline-flex;
+  align-items: center;
+  gap: 10px;
+  padding: 8px 12px;
+  border-radius: 999px;
+  background: rgba(119, 223, 208, 0.1);
+  color: var(--teal);
+  font-size: 0.84rem;
+  text-transform: uppercase;
+  letter-spacing: 0.12em;
+  margin-bottom: 14px;
+}
+
+.rank-item {
+  padding: 14px 0;
+  border-bottom: 1px solid var(--line);
+}
+
+.rank-item:last-child {
+  border-bottom: 0;
+}
+
+.score {
+  font-family: "Iowan Old Style", "Palatino Linotype", Georgia, serif;
+  font-size: 1.35rem;
+}
+
+.muted {
+  color: var(--muted);
+}
+
+@media (max-width: 980px) {
+  .hero,
+  .split,
+  .cards.three,
+  .cards.four,
+  .cluster-grid,
+  .evidence-grid {
+    grid-template-columns: 1fr;
+  }
+
+  .timeline-grid {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+  }
+}
+
+@media (max-width: 640px) {
+  .page-shell {
+    width: min(100vw - 20px, 1200px);
+    padding-top: 18px;
+  }
+
+  .hero-copy,
+  .hero-panel,
+  .panel,
+  .card,
+  .cluster-card,
+  .evidence-card {
+    padding: 18px;
+  }
+
+  .timeline-grid {
+    grid-template-columns: 1fr;
+  }
+}