Added team add to calendar button

.codex/caveman.all.md

@@ -0,0 +1,259 @@
+---
+name: caveman
+description: >
+  Ultra-compressed communication mode. Cuts token usage ~75% by speaking like caveman
+  while keeping full technical accuracy. Supports intensity levels: lite, full (default), ultra,
+  wenyan-lite, wenyan-full, wenyan-ultra.
+  Use when user says "caveman mode", "talk like caveman", "use caveman", "less tokens",
+  "be brief", or invokes /caveman. Also auto-triggers when token efficiency is requested.
+---
+
+Respond terse like smart caveman. All technical substance stay. Only fluff die.
+
+## Persistence
+
+ACTIVE EVERY RESPONSE. No revert after many turns. No filler drift. Still active if unsure. Off only: "stop caveman" / "normal mode".
+
+Default: **full**. Switch: `/caveman lite|full|ultra`.
+
+## Rules
+
+Drop: articles (a/an/the), filler (just/really/basically/actually/simply), pleasantries (sure/certainly/of course/happy to), hedging. Fragments OK. Short synonyms (big not extensive, fix not "implement a solution for"). Technical terms exact. Code blocks unchanged. Errors quoted exact.
+
+Pattern: `[thing] [action] [reason]. [next step].`
+
+Not: "Sure! I'd be happy to help you with that. The issue you're experiencing is likely caused by..."
+Yes: "Bug in auth middleware. Token expiry check use `<` not `<=`. Fix:"
+
+## Intensity
+
+| Level | What change |
+|-------|------------|
+| **lite** | No filler/hedging. Keep articles + full sentences. Professional but tight |
+| **full** | Drop articles, fragments OK, short synonyms. Classic caveman |
+| **ultra** | Abbreviate (DB/auth/config/req/res/fn/impl), strip conjunctions, arrows for causality (X → Y), one word when one word enough |
+| **wenyan-lite** | Semi-classical. Drop filler/hedging but keep grammar structure, classical register |
+| **wenyan-full** | Maximum classical terseness. Fully 文言文. 80-90% character reduction. Classical sentence patterns, verbs precede objects, subjects often omitted, classical particles (之/乃/為/其) |
+| **wenyan-ultra** | Extreme abbreviation while keeping classical Chinese feel. Maximum compression, ultra terse |
+
+Example — "Why React component re-render?"
+- lite: "Your component re-renders because you create a new object reference each render. Wrap it in `useMemo`."
+- full: "New object ref each render. Inline object prop = new ref = re-render. Wrap in `useMemo`."
+- ultra: "Inline obj prop → new ref → re-render. `useMemo`."
+- wenyan-lite: "組件頻重繪，以每繪新生對象參照故。以 useMemo 包之。"
+- wenyan-full: "物出新參照，致重繪。useMemo .Wrap之。"
+- wenyan-ultra: "新參照→重繪。useMemo Wrap。"
+
+Example — "Explain database connection pooling."
+- lite: "Connection pooling reuses open connections instead of creating new ones per request. Avoids repeated handshake overhead."
+- full: "Pool reuse open DB connections. No new connection per request. Skip handshake overhead."
+- ultra: "Pool = reuse DB conn. Skip handshake → fast under load."
+- wenyan-full: "池reuse open connection。不每req新開。skip handshake overhead。"
+- wenyan-ultra: "池reuse conn。skip handshake → fast。"
+
+## Auto-Clarity
+
+Drop caveman for: security warnings, irreversible action confirmations, multi-step sequences where fragment order risks misread, user asks to clarify or repeats question. Resume caveman after clear part done.
+
+Example — destructive op:
+> **Warning:** This will permanently delete all rows in the `users` table and cannot be undone.
+> ```sql
+> DROP TABLE users;
+> ```
+> Caveman resume. Verify backup exist first.
+
+## Boundaries
+
+Code/commits/PRs: write normal. "stop caveman" or "normal mode": revert. Level persist until changed or session end.
+
+---
+
+---
+name: caveman-commit
+description: >
+  Ultra-compressed commit message generator. Cuts noise from commit messages while preserving
+  intent and reasoning. Conventional Commits format. Subject ≤50 chars, body only when "why"
+  isn't obvious. Use when user says "write a commit", "commit message", "generate commit",
+  "/commit", or invokes /caveman-commit. Auto-triggers when staging changes.
+---
+
+Write commit messages terse and exact. Conventional Commits format. No fluff. Why over what.
+
+## Rules
+
+**Subject line:**
+- `<type>(<scope>): <imperative summary>` — `<scope>` optional
+- Types: `feat`, `fix`, `refactor`, `perf`, `docs`, `test`, `chore`, `build`, `ci`, `style`, `revert`
+- Imperative mood: "add", "fix", "remove" — not "added", "adds", "adding"
+- ≤50 chars when possible, hard cap 72
+- No trailing period
+- Match project convention for capitalization after the colon
+
+**Body (only if needed):**
+- Skip entirely when subject is self-explanatory
+- Add body only for: non-obvious *why*, breaking changes, migration notes, linked issues
+- Wrap at 72 chars
+- Bullets `-` not `*`
+- Reference issues/PRs at end: `Closes #42`, `Refs #17`
+
+**What NEVER goes in:**
+- "This commit does X", "I", "we", "now", "currently" — the diff says what
+- "As requested by..." — use Co-authored-by trailer
+- "Generated with Claude Code" or any AI attribution
+- Emoji (unless project convention requires)
+- Restating the file name when scope already says it
+
+## Examples
+
+Diff: new endpoint for user profile with body explaining the why
+- ❌ "feat: add a new endpoint to get user profile information from the database"
+- ✅
+  ```
+  feat(api): add GET /users/:id/profile
+
+  Mobile client needs profile data without the full user payload
+  to reduce LTE bandwidth on cold-launch screens.
+
+  Closes #128
+  ```
+
+Diff: breaking API change
+- ✅
+  ```
+  feat(api)!: rename /v1/orders to /v1/checkout
+
+  BREAKING CHANGE: clients on /v1/orders must migrate to /v1/checkout
+  before 2026-06-01. Old route returns 410 after that date.
+  ```
+
+## Auto-Clarity
+
+Always include body for: breaking changes, security fixes, data migrations, anything reverting a prior commit. Never compress these into subject-only — future debuggers need the context.
+
+## Boundaries
+
+Only generates the commit message. Does not run `git commit`, does not stage files, does not amend. Output the message as a code block ready to paste. "stop caveman-commit" or "normal mode": revert to verbose commit style.
+
+---
+
+---
+name: caveman-review
+description: >
+  Ultra-compressed code review comments. Cuts noise from PR feedback while preserving
+  the actionable signal. Each comment is one line: location, problem, fix. Use when user
+  says "review this PR", "code review", "review the diff", "/review", or invokes
+  /caveman-review. Auto-triggers when reviewing pull requests.
+---
+
+Write code review comments terse and actionable. One line per finding. Location, problem, fix. No throat-clearing.
+
+## Rules
+
+**Format:** `L<line>: <problem>. <fix>.` — or `<file>:L<line>: ...` when reviewing multi-file diffs.
+
+**Severity prefix (optional, when mixed):**
+- `🔴 bug:` — broken behavior, will cause incident
+- `🟡 risk:` — works but fragile (race, missing null check, swallowed error)
+- `🔵 nit:` — style, naming, micro-optim. Author can ignore
+- `❓ q:` — genuine question, not a suggestion
+
+**Drop:**
+- "I noticed that...", "It seems like...", "You might want to consider..."
+- "This is just a suggestion but..." — use `nit:` instead
+- "Great work!", "Looks good overall but..." — say it once at the top, not per comment
+- Restating what the line does — the reviewer can read the diff
+- Hedging ("perhaps", "maybe", "I think") — if unsure use `q:`
+
+**Keep:**
+- Exact line numbers
+- Exact symbol/function/variable names in backticks
+- Concrete fix, not "consider refactoring this"
+- The *why* if the fix isn't obvious from the problem statement
+
+## Examples
+
+❌ "I noticed that on line 42 you're not checking if the user object is null before accessing the email property. This could potentially cause a crash if the user is not found in the database. You might want to add a null check here."
+
+✅ `L42: 🔴 bug: user can be null after .find(). Add guard before .email.`
+
+❌ "It looks like this function is doing a lot of things and might benefit from being broken up into smaller functions for readability."
+
+✅ `L88-140: 🔵 nit: 50-line fn does 4 things. Extract validate/normalize/persist.`
+
+❌ "Have you considered what happens if the API returns a 429? I think we should probably handle that case."
+
+✅ `L23: 🟡 risk: no retry on 429. Wrap in withBackoff(3).`
+
+## Auto-Clarity
+
+Drop terse mode for: security findings (CVE-class bugs need full explanation + reference), architectural disagreements (need rationale, not just a one-liner), and onboarding contexts where the author is new and needs the "why". In those cases write a normal paragraph, then resume terse for the rest.
+
+## Boundaries
+
+Reviews only — does not write the code fix, does not approve/request-changes, does not run linters. Output the comment(s) ready to paste into the PR. "stop caveman-review" or "normal mode": revert to verbose review style.
+
+---
+
+---
+name: caveman-help
+description: >
+  Quick-reference card for all caveman modes, skills, and commands.
+  One-shot display, not a persistent mode. Trigger: /caveman-help,
+  "caveman help", "what caveman commands", "how do I use caveman".
+---
+
+# Caveman Help
+
+Display this reference card when invoked. One-shot — do NOT change mode, write flag files, or persist anything. Output in caveman style.
+
+## Modes
+
+| Mode | Trigger | What change |
+|------|---------|-------------|
+| **Lite** | `/caveman lite` | Drop filler. Keep sentence structure. |
+| **Full** | `/caveman` | Drop articles, filler, pleasantries, hedging. Fragments OK. Default. |
+| **Ultra** | `/caveman ultra` | Extreme compression. Bare fragments. Tables over prose. |
+| **Wenyan-Lite** | `/caveman wenyan-lite` | Classical Chinese style, light compression. |
+| **Wenyan-Full** | `/caveman wenyan` | Full 文言文. Maximum classical terseness. |
+| **Wenyan-Ultra** | `/caveman wenyan-ultra` | Extreme. Ancient scholar on a budget. |
+
+Mode stick until changed or session end.
+
+## Skills
+
+| Skill | Trigger | What it do |
+|-------|---------|-----------|
+| **caveman-commit** | `/caveman-commit` | Terse commit messages. Conventional Commits. ≤50 char subject. |
+| **caveman-review** | `/caveman-review` | One-line PR comments: `L42: bug: user null. Add guard.` |
+| **caveman-compress** | `/caveman:compress <file>` | Compress .md files to caveman prose. Saves ~46% input tokens. |
+| **caveman-help** | `/caveman-help` | This card. |
+
+## Deactivate
+
+Say "stop caveman" or "normal mode". Resume anytime with `/caveman`.
+
+## Configure Default Mode
+
+Default mode = `full`. Change it:
+
+**Environment variable** (highest priority):
+```bash
+export CAVEMAN_DEFAULT_MODE=ultra
+```
+
+**Config file** (`~/.config/caveman/config.json`):
+```json
+{ "defaultMode": "lite" }
+```
+
+Set `"off"` to disable auto-activation on session start. User can still activate manually with `/caveman`.
+
+Resolution: env var > config file > `full`.
+
+## More
+
+Full docs: https://github.com/JuliusBrussee/caveman
+
+
+---
+

README.md

@@ -15,21 +15,31 @@ This app reads `assets/events.json` and shows the upcoming seminar list.
 ## Files
 
 - `app.py`: Gradio UI
-- `assets/events.json`: event data read by the app and updated when an attending count is clicked
+- `assets/events.json`: event data read by the app and updated when a Teams calendar event is created or reused
 - `assets/sources.json`: source metadata used for tags
 - `assets/prompt.txt`: prompt for your manual event-generation workflow
 
 ## HF dataset sync
 
-The app pulls the latest remote events file before rendering and pushes updates back after an attending click.
+The app pulls the latest remote events file before rendering and pushes updates back after a calendar action updates `assets/events.json`.
 
 - Dataset repo is fixed to `ar0s/robotic-seminars-cache`
 - `HF_TOKEN` or `HUGGINGFACE_HUB_TOKEN`: token with dataset write access
 - Remote file name is fixed to `events.json`
+- `assets/events.json` schema version is `6`
 - Manual sync commands:
   `python -m src.hf_sync pull`
   `python -m src.hf_sync push`
 
+## Microsoft Teams calendar
+
+The last table column opens a shared Teams meeting for the seminar. The first user creates the service-mailbox event; later users are added to the same event and then redirected to it.
+
+- `MS_TENANT_ID`: Entra tenant id for the app registration
+- `MS_CLIENT_ID`: Entra app client id
+- `MS_CLIENT_SECRET`: Entra app client secret
+- `MS_SERVICE_MAILBOX`: Microsoft 365 mailbox that owns the shared calendar event
+
 ## Local run
 
 ```bash

app.py

@@ -3,14 +3,27 @@ from __future__ import annotations
 import os
 from html import escape
 from pathlib import Path
+from urllib.parse import urlencode
 
 import gradio as gr
 from dotenv import load_dotenv
+from fastapi import Request
+from fastapi.responses import RedirectResponse
 
-from src.attending import COLS, LOCAL_DISPLAY_TZ, filtered_events, format_event_time, inc_attending, results_table
+from src.attending import COLS, LOCAL_DISPLAY_TZ, filtered_events, format_event_time, results_table
 from src.hf_sync import hf_enabled, pull_events
 from src.models import infer_category, load_payload
 from src.org_colors import org_colors
+from src.teams_calendar import (
+    SESSION_COOKIE,
+    SESSIONS,
+    auth_url,
+    begin_auth_flow,
+    consume_auth_flow,
+    ensure_user_on_event,
+    exchange_code_for_user,
+    session_id,
+)
 
 load_dotenv(Path(__file__).with_name(".env"))
 
@@ -225,11 +238,13 @@ CSS = """
   font-weight: 400;
 }
 
-.attending-pill {
+.calendar-pill {
   display: inline-flex;
   align-items: center;
-  gap: 0.45rem;
-  padding: 0.28rem 0.42rem 0.28rem 0.72rem;
+  justify-content: space-between;
+  gap: 0.7rem;
+  min-width: 9.25rem;
+  padding: 0.32rem 0.42rem 0.32rem 0.78rem;
   border: 1px solid rgba(15, 118, 110, 0.16);
   border-radius: 999px;
   background: #eef4f0;
@@ -238,14 +253,16 @@ CSS = """
   font-weight: 700;
   line-height: 1;
   transition: background 0.2s ease, transform 0.2s ease;
+  text-decoration: none !important;
 }
 
-.attending-pill span {
+.calendar-pill strong {
   display: inline-flex;
   align-items: center;
   justify-content: center;
-  width: 1.15rem;
-  height: 1.15rem;
+  min-width: 1.4rem;
+  height: 1.4rem;
+  padding: 0 0.3rem;
   border-radius: 999px;
   background: rgba(15, 118, 110, 0.11);
 }
@@ -296,11 +313,10 @@ CSS = """
 }
 
 #events-table tbody td:last-child {
-  cursor: pointer;
   text-align: center;
 }
 
-#events-table tbody td:last-child:hover .attending-pill {
+#events-table tbody td:last-child .calendar-pill:hover {
   background: var(--accent-soft);
   transform: translateY(-1px);
 }
@@ -388,8 +404,8 @@ def render_spotlight(results: list[dict], query: str = "") -> str:
 
 def build_view(results: list[dict], query: str = ""):
     colors = org_colors(result["org_name"] for result in results)
-    table, row_map = results_table(results, colors, query)
-    return render_spotlight(results, query), table, row_map
+    table = results_table(results, colors, query)
+    return render_spotlight(results, query), table
 
 
 def render():
@@ -397,15 +413,16 @@ def render():
         pull_events(EVENTS_PATH)
     payload = load_payload(EVENTS_PATH)
     results = prepare_results(payload["results"])
-    spotlight, table, row_map = build_view(results)
+    spotlight, table = build_view(results)
     sources = "\n".join(f"- [{result['org_name']}]({result['source_url']})" for result in results)
-    return render_hero(payload, results), spotlight, table, results, row_map, sources
+    return render_hero(payload, results), spotlight, table, results, sources
 
 
-def on_select(results: list[dict], row_map: list[tuple[int, int]], query: str, evt: gr.SelectData):
-    colors = org_colors(result["org_name"] for result in results)
-    table, results, row_map = inc_attending(evt, results, row_map, colors=colors, query=query, events_path=EVENTS_PATH)
-    return render_spotlight(results, query), table, results, row_map
+def route_url(request: Request, route_name: str, **query: str) -> str:
+    base = str(request.url_for(route_name))
+    if not query:
+        return base
+    return f"{base}?{urlencode(query)}"
 
 
 with gr.Blocks(theme=gr.themes.Soft(radius_size="lg"), css=CSS, fill_width=True, title="Robotic seminars") as demo:
@@ -420,24 +437,51 @@ with gr.Blocks(theme=gr.themes.Soft(radius_size="lg"), css=CSS, fill_width=True,
     table = gr.Dataframe(
         headers=COLS,
         datatype=["markdown", "markdown", "markdown", "markdown", "markdown", "markdown"],
-        column_widths=[180, 420, 240, 170, 260, 110],
+        column_widths=[180, 420, 240, 170, 260, 180],
         max_height=100000,
         interactive=False,
         wrap=True,
         elem_id="events-table",
     )
     results_state = gr.State([])
-    row_map_state = gr.State([])
     with gr.Accordion("Sources", open=False):
         sources_box = gr.Markdown()
 
-    demo.load(render, outputs=[hero, spotlight, table, results_state, row_map_state, sources_box])
-    search.input(build_view, inputs=[results_state, search], outputs=[spotlight, table, row_map_state])
-    table.select(
-        on_select,
-        inputs=[results_state, row_map_state, search],
-        outputs=[spotlight, table, results_state, row_map_state],
+    demo.load(render, outputs=[hero, spotlight, table, results_state, sources_box])
+    search.input(build_view, inputs=[results_state, search], outputs=[spotlight, table])
+
+
+@demo.app.get("/calendar/action", name="calendar_action")
+def calendar_action(request: Request, event_key: str):
+    user = SESSIONS.get(request.cookies.get(SESSION_COOKIE, ""))
+    if user is None:
+        return RedirectResponse(route_url(request, "microsoft_start", event_key=event_key), status_code=302)
+    return RedirectResponse(ensure_user_on_event(event_key, user, events_path=EVENTS_PATH), status_code=302)
+
+
+@demo.app.get("/auth/microsoft/start", name="microsoft_start")
+def microsoft_start(request: Request, event_key: str):
+    current_session_id = request.cookies.get(SESSION_COOKIE) or session_id()
+    state = begin_auth_flow(current_session_id, event_key)
+    response = RedirectResponse(
+        auth_url(redirect_uri=str(request.url_for("microsoft_callback")), state=state),
+        status_code=302,
+    )
+    response.set_cookie(SESSION_COOKIE, current_session_id, httponly=True, samesite="lax")
+    return response
+
+
+@demo.app.get("/auth/microsoft/callback", name="microsoft_callback")
+def microsoft_callback(request: Request, code: str, state: str):
+    pending = consume_auth_flow(state)
+    user = exchange_code_for_user(code, redirect_uri=str(request.url_for("microsoft_callback")))
+    SESSIONS[pending["session_id"]] = user
+    response = RedirectResponse(
+        ensure_user_on_event(pending["event_key"], user, events_path=EVENTS_PATH),
+        status_code=302,
     )
+    response.set_cookie(SESSION_COOKIE, pending["session_id"], httponly=True, samesite="lax")
+    return response
 
 
 if __name__ == "__main__":

assets/prompt.txt

@@ -17,7 +17,7 @@ Execution requirements:
 
 - Write only `assets/events.json`.
 - Preserve the existing `meta.ttl_hours`.
-- Set `meta.schema_version` to `5`.
+- Set `meta.schema_version` to `6`.
 - Refresh `meta.cached_at` to the current UTC ISO-8601 timestamp.
 - `results` must contain exactly one object per source with:
   - `org_id`
@@ -45,6 +45,7 @@ Execution requirements:
   - `category`
   - `tags`
   - `attending_count`
+- Preserve `teams_event_id` and `teams_event_web_link` on matched events when they already exist.
 
 Extraction rules:
 
@@ -61,18 +62,18 @@ Extraction rules:
 - Infer tags primarily from the abstract or description of each event when available, and use the title only as a secondary signal.
 - Broad umbrella tags are allowed when appropriate, and one or two more specific tags may be added when they are clearly supported by the event content.
 
-Attending-count preservation rules:
+Calendar-state preservation rules:
 
-- Preserve existing `attending_count` values from the current `assets/events.json` wherever possible.
+- Preserve existing `attending_count`, `teams_event_id`, and `teams_event_web_link` values from the current `assets/events.json` wherever possible.
 - Match first on `(org_id, normalized start_time to minute in UTC, event_url)`.
-- If there is no exact match, reuse the count only when there is exactly one prior event for the same `(org_id, normalized start_time to minute in UTC)`.
-- Otherwise leave `attending_count` at `0`.
+- If there is no exact match, reuse these values only when there is exactly one prior event for the same `(org_id, normalized start_time to minute in UTC)`.
+- Otherwise leave `attending_count` at `0` and omit `teams_event_id` and `teams_event_web_link`.
 
 Validation requirements before finishing:
 
 1. Confirm every `assets/sources.json` id appears exactly once in `assets/events.json.results`.
 2. Confirm every `start_time` is ISO-parseable and sorts correctly in UTC after normalization.
-3. Confirm preserved `attending_count` values remain attached to matched events.
+3. Confirm preserved `attending_count`, `teams_event_id`, and `teams_event_web_link` values remain attached to matched events.
 4. Confirm every event has `category` and `tags`.
 5. Run `conda run -n robotic-seminars pytest -q`.
 6. Manually spot-check at least 3 orgs:

src/attending.py

@@ -2,17 +2,16 @@ from __future__ import annotations
 
 import os
 from html import escape
-from pathlib import Path
+from urllib.parse import quote
 
 import pandas as pd
 
-from .hf_sync import hf_enabled, push_events
-from .models import load_payload, parse_dt_utc, write_payload
+from .models import parse_dt_utc
+from .teams_calendar import event_key
 
 LOCAL_DISPLAY_TZ = os.environ.get("LOCAL_DISPLAY_TZ", "Europe/Rome")
 WHEN_COL = "When"
-COLS = [WHEN_COL, "Event", "Speaker", "Category", "Organization", "Attending"]
-DEFAULT_EVENTS_PATH = Path(os.environ.get("EVENTS_PATH", Path(os.environ.get("ASSETS_DIR", "assets")) / "events.json"))
+COLS = [WHEN_COL, "Event", "Speaker", "Category", "Organization", "Calendar"]
 
 
 def format_event_time(value: str, *, tz_name: str | None = None) -> str:
@@ -47,8 +46,11 @@ def speaker_cell(speaker: str, affiliation: str) -> str:
     return escape(speaker or affiliation)
 
 
-def attending_badge(count: int) -> str:
-    return f"<span class='attending-pill'><strong>{count}</strong><span>+</span></span>"
+def calendar_badge(current_event_key: str, count: int) -> str:
+    return (
+        f'<a class="calendar-pill" href="calendar/action?event_key={quote(current_event_key)}">'
+        f"<span>Add to calendar</span><strong>{count}</strong></a>"
+    )
 
 
 def filtered_events(results: list[dict], query: str = "") -> list[tuple[int, int, dict, dict]]:
@@ -75,9 +77,9 @@ def filtered_events(results: list[dict], query: str = "") -> list[tuple[int, int
     return [(result_index, event_index, result, event) for _, _, result_index, event_index, result, event in sorted(matches)]
 
 
-def results_table(results: list[dict], colors: dict[str, str], query: str = "") -> tuple[pd.DataFrame, list[tuple[int, int]]]:
+def results_table(results: list[dict], colors: dict[str, str], query: str = "") -> pd.DataFrame:
     rows: list[dict[str, object]] = []
-    for result_index, event_index, result, event in filtered_events(results, query):
+    for _, _, result, event in filtered_events(results, query):
         title = event["title"] or "View event"
         source_time = format_event_time(event["start_time"])
         local_time = format_event_time(event["start_time"], tz_name=LOCAL_DISPLAY_TZ)
@@ -96,41 +98,11 @@ def results_table(results: list[dict], colors: dict[str, str], query: str = "")
                 "Speaker": speaker_cell(event["speaker"] or "", event["affiliation"] or ""),
                 "Category": chip(event["category"], "pill"),
                 "Organization": org_badge(result["org_name"], colors),
-                "Attending": attending_badge(event["attending_count"]),
-                "_result": result_index,
-                "_event": event_index,
+                "Calendar": calendar_badge(event_key(result, event), event["attending_count"]),
             }
         )
 
     if not rows:
-        return pd.DataFrame(columns=COLS), []
-
-    df = pd.DataFrame(rows).reset_index(drop=True)
-    row_map = list(zip(df["_result"].astype(int).tolist(), df["_event"].astype(int).tolist()))
-    return df.drop(columns=["_result", "_event"])[COLS], row_map
-
-
-def inc_attending(
-    evt,
-    results: list[dict],
-    row_map: list[tuple[int, int]],
-    *,
-    colors: dict[str, str],
-    query: str = "",
-    events_path: str | Path = DEFAULT_EVENTS_PATH,
-    **_ignored,
-):
-    if evt and evt.index:
-        row_index, column_index = map(int, evt.index)
-        if column_index == COLS.index("Attending"):
-            result_index, event_index = row_map[row_index]
-            results[result_index]["events"][event_index]["attending_count"] += 1
-
-            payload = load_payload(events_path)
-            payload["results"] = results
-            write_payload(payload, events_path)
-            if hf_enabled():
-                push_events(events_path)
-
-    table, row_map = results_table(results, colors, query)
-    return table, results, row_map
+        return pd.DataFrame(columns=COLS)
+
+    return pd.DataFrame(rows).reset_index(drop=True)[COLS]

src/models.py

@@ -6,13 +6,21 @@ from datetime import datetime, timezone
 from pathlib import Path
 
 DEFAULT_EVENTS_PATH = Path(os.environ.get("EVENTS_PATH", Path(os.environ.get("ASSETS_DIR", "assets")) / "events.json"))
+SCHEMA_VERSION = 6
 
 
 def load_payload(path: str | Path = DEFAULT_EVENTS_PATH) -> dict:
     return json.loads(Path(path).read_text(encoding="utf-8"))
 
 
+def ensure_payload_schema(payload: dict) -> dict:
+    meta = payload.setdefault("meta", {})
+    meta["schema_version"] = SCHEMA_VERSION
+    return payload
+
+
 def write_payload(payload: dict, path: str | Path = DEFAULT_EVENTS_PATH) -> None:
+    ensure_payload_schema(payload)
     Path(path).write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
 
 

src/teams_calendar.py

@@ -0,0 +1,254 @@
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+import os
+import secrets
+from datetime import timedelta
+from pathlib import Path
+from urllib.parse import quote, urlencode
+from urllib.request import Request, urlopen
+
+from .hf_sync import hf_enabled, push_events
+from .models import load_payload, parse_dt_utc, write_payload
+
+DEFAULT_EVENTS_PATH = Path(os.environ.get("EVENTS_PATH", Path(os.environ.get("ASSETS_DIR", "assets")) / "events.json"))
+GRAPH_SCOPE = "https://graph.microsoft.com/.default"
+MICROSOFT_AUTH_SCOPE = "openid profile email"
+SESSION_COOKIE = "robotic_seminars_session"
+SESSIONS: dict[str, dict[str, str]] = {}
+PENDING_STATES: dict[str, dict[str, str]] = {}
+
+
+def required_env(name: str) -> str:
+    value = os.environ.get(name, "").strip()
+    if not value:
+        raise RuntimeError(f"Missing required environment variable: {name}")
+    return value
+
+
+def tenant_id() -> str:
+    return required_env("MS_TENANT_ID")
+
+
+def client_id() -> str:
+    return required_env("MS_CLIENT_ID")
+
+
+def client_secret() -> str:
+    return required_env("MS_CLIENT_SECRET")
+
+
+def service_mailbox() -> str:
+    return required_env("MS_SERVICE_MAILBOX")
+
+
+def microsoft_authority() -> str:
+    return f"https://login.microsoftonline.com/{tenant_id()}/oauth2/v2.0"
+
+
+def session_id() -> str:
+    return secrets.token_urlsafe(24)
+
+
+def begin_auth_flow(session_token: str, event_key: str) -> str:
+    state = secrets.token_urlsafe(24)
+    PENDING_STATES[state] = {"session_id": session_token, "event_key": event_key}
+    return state
+
+
+def consume_auth_flow(state: str) -> dict[str, str]:
+    return PENDING_STATES.pop(state)
+
+
+def event_key(result: dict, event: dict) -> str:
+    signature = "\n".join((result["org_id"], event["start_time"], event.get("event_url") or ""))
+    return hashlib.sha256(signature.encode("utf-8")).hexdigest()
+
+
+def auth_url(*, redirect_uri: str, state: str) -> str:
+    query = urlencode(
+        {
+            "client_id": client_id(),
+            "response_type": "code",
+            "redirect_uri": redirect_uri,
+            "response_mode": "query",
+            "scope": MICROSOFT_AUTH_SCOPE,
+            "state": state,
+        }
+    )
+    return f"{microsoft_authority()}/authorize?{query}"
+
+
+def _post_form_json(url: str, form: dict[str, str]) -> dict:
+    request = Request(
+        url,
+        data=urlencode(form).encode("utf-8"),
+        headers={"Content-Type": "application/x-www-form-urlencoded"},
+    )
+    with urlopen(request) as response:
+        return json.loads(response.read().decode("utf-8"))
+
+
+def _request_json(method: str, url: str, *, token: str, body: dict | None = None) -> dict:
+    headers = {"Authorization": f"Bearer {token}"}
+    data = None
+    if body is not None:
+        headers["Content-Type"] = "application/json"
+        data = json.dumps(body).encode("utf-8")
+    request = Request(url, data=data, headers=headers, method=method)
+    with urlopen(request) as response:
+        text = response.read().decode("utf-8")
+        return json.loads(text) if text else {}
+
+
+def _decode_jwt_payload(token: str) -> dict:
+    payload = token.split(".")[1]
+    payload += "=" * (-len(payload) % 4)
+    return json.loads(base64.urlsafe_b64decode(payload.encode("utf-8")).decode("utf-8"))
+
+
+def exchange_code_for_user(code: str, *, redirect_uri: str) -> dict[str, str]:
+    tokens = _post_form_json(
+        f"{microsoft_authority()}/token",
+        {
+            "client_id": client_id(),
+            "client_secret": client_secret(),
+            "grant_type": "authorization_code",
+            "code": code,
+            "redirect_uri": redirect_uri,
+            "scope": MICROSOFT_AUTH_SCOPE,
+        },
+    )
+    claims = _decode_jwt_payload(tokens["id_token"])
+    if claims["tid"] != tenant_id():
+        raise RuntimeError("Signed-in user is outside the configured tenant")
+    email = (claims.get("preferred_username") or claims.get("email") or claims.get("upn") or "").lower()
+    if not email:
+        raise RuntimeError("Signed-in user does not expose an email address")
+    return {"email": email, "name": claims.get("name") or claims.get("preferred_username") or ""}
+
+
+def service_access_token() -> str:
+    tokens = _post_form_json(
+        f"{microsoft_authority()}/token",
+        {
+            "client_id": client_id(),
+            "client_secret": client_secret(),
+            "grant_type": "client_credentials",
+            "scope": GRAPH_SCOPE,
+        },
+    )
+    return tokens["access_token"]
+
+
+def _graph_event_collection_url() -> str:
+    return f"https://graph.microsoft.com/v1.0/users/{quote(service_mailbox())}/calendar/events"
+
+
+def _graph_event_url(event_id: str) -> str:
+    return f"https://graph.microsoft.com/v1.0/users/{quote(service_mailbox())}/events/{quote(event_id, safe='')}"
+
+
+def _attendee_entry(user: dict[str, str]) -> dict:
+    return {
+        "emailAddress": {
+            "address": user["email"],
+            "name": user["name"] or user["email"],
+        },
+        "type": "required",
+    }
+
+
+def _attendee_emails(attendees: list[dict]) -> set[str]:
+    return {
+        attendee["emailAddress"]["address"].lower()
+        for attendee in attendees
+        if attendee.get("emailAddress", {}).get("address")
+    }
+
+
+def _attending_count(attendees: list[dict]) -> int:
+    return len(_attendee_emails(attendees))
+
+
+def _event_times(event: dict) -> tuple[dict[str, str], dict[str, str]]:
+    start = parse_dt_utc(event["start_time"])
+    end = start + timedelta(hours=1)
+    return (
+        {"dateTime": start.strftime("%Y-%m-%dT%H:%M:%S"), "timeZone": "UTC"},
+        {"dateTime": end.strftime("%Y-%m-%dT%H:%M:%S"), "timeZone": "UTC"},
+    )
+
+
+def _event_body(result: dict, event: dict) -> dict[str, str]:
+    source_url = event.get("event_url") or result["source_url"]
+    content = (
+        f"<p>{event['title']}</p>"
+        f"<p>{result['org_name']}</p>"
+        f'<p><a href="{source_url}">Original seminar page</a></p>'
+    )
+    return {"contentType": "HTML", "content": content}
+
+
+def _create_event_payload(result: dict, event: dict, user: dict[str, str], current_event_key: str) -> dict:
+    start, end = _event_times(event)
+    return {
+        "subject": event["title"],
+        "body": _event_body(result, event),
+        "start": start,
+        "end": end,
+        "location": {"displayName": result["org_name"]},
+        "attendees": [_attendee_entry(user)],
+        "isOnlineMeeting": True,
+        "onlineMeetingProvider": "teamsForBusiness",
+        "transactionId": current_event_key,
+    }
+
+
+def _find_event(payload: dict, current_event_key: str) -> tuple[dict, dict]:
+    for result in payload["results"]:
+        for event in result["events"]:
+            if event_key(result, event) == current_event_key:
+                return result, event
+    raise KeyError(f"Unknown event key: {current_event_key}")
+
+
+def ensure_user_on_event(
+    current_event_key: str,
+    user: dict[str, str],
+    *,
+    events_path: str | Path = DEFAULT_EVENTS_PATH,
+) -> str:
+    payload = load_payload(events_path)
+    result, event = _find_event(payload, current_event_key)
+    token = service_access_token()
+
+    if event.get("teams_event_id"):
+        graph_event = _request_json("GET", _graph_event_url(event["teams_event_id"]), token=token)
+    else:
+        graph_event = _request_json(
+            "POST",
+            _graph_event_collection_url(),
+            token=token,
+            body=_create_event_payload(result, event, user, current_event_key),
+        )
+        event["teams_event_id"] = graph_event["id"]
+
+    attendees = graph_event.get("attendees") or []
+    if user["email"] not in _attendee_emails(attendees):
+        attendees = attendees + [_attendee_entry(user)]
+        graph_event = _request_json(
+            "PATCH",
+            _graph_event_url(event["teams_event_id"]),
+            token=token,
+            body={"attendees": attendees},
+        )
+
+    event["teams_event_web_link"] = graph_event["webLink"]
+    event["attending_count"] = _attending_count(graph_event.get("attendees") or [])
+    write_payload(payload, events_path)
+    if hf_enabled():
+        push_events(events_path)
+    return event["teams_event_web_link"]

tests/test_golden.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
-from types import SimpleNamespace
+import pytest
+from fastapi.testclient import TestClient
 
-from src.attending import COLS, WHEN_COL, inc_attending, results_table
-from src.models import infer_category, load_payload, parse_dt_utc, write_payload
+import app
+from src.attending import COLS, WHEN_COL, results_table
+from src.models import SCHEMA_VERSION, infer_category, load_payload, parse_dt_utc, write_payload
+from src.teams_calendar import PENDING_STATES, SESSION_COOKIE, SESSIONS, ensure_user_on_event, event_key
 
 
 def sample_results() -> list[dict]:
@@ -92,8 +95,42 @@ def searchable_results() -> list[dict]:
     ]
 
 
-def test_results_table_shows_source_and_local_time():
-    table, _ = results_table(sample_results(), {"CMU": "#000000"})
+def sample_payload() -> dict:
+    return {
+        "meta": {
+            "schema_version": 5,
+            "cached_at": "2026-04-12T20:22:12+00:00",
+            "ttl_hours": 12.0,
+        },
+        "results": sample_results(),
+    }
+
+
+def first_event_key(results: list[dict]) -> str:
+    return event_key(results[0], results[0]["events"][0])
+
+
+@pytest.fixture(autouse=True)
+def microsoft_env(monkeypatch):
+    monkeypatch.setenv("MS_TENANT_ID", "tenant-123")
+    monkeypatch.setenv("MS_CLIENT_ID", "client-123")
+    monkeypatch.setenv("MS_CLIENT_SECRET", "secret-123")
+    monkeypatch.setenv("MS_SERVICE_MAILBOX", "calendar@example.com")
+    SESSIONS.clear()
+    PENDING_STATES.clear()
+
+
+@pytest.fixture
+def client():
+    with TestClient(app.demo.app) as test_client:
+        yield test_client
+
+
+def test_results_table_shows_source_local_time_and_calendar_badge():
+    results = sample_results()
+    table = results_table(results, {"CMU": "#000000"})
+    current_event_key = first_event_key(results)
+
     assert list(table.columns) == COLS
     assert "Apr 13 at 15:00" in table.loc[0, WHEN_COL]
     assert "Source: Apr 13 at 9:00" in table.loc[0, WHEN_COL]
@@ -101,46 +138,133 @@ def test_results_table_shows_source_and_local_time():
     assert "robotics" in table.loc[0, "Event"]
     assert "university" in table.loc[0, "Event"]
     assert "CMU" in table.loc[0, "Organization"]
+    assert "Add to calendar" in table.loc[0, "Calendar"]
+    assert "calendar-pill" in table.loc[0, "Calendar"]
+    assert f"calendar/action?event_key={current_event_key}" in table.loc[0, "Calendar"]
+
 
+def test_results_table_filters_case_insensitively():
+    table = results_table(searchable_results(), {"CMU": "#000000", "Stanford": "#111111"}, query="VISION")
 
-def test_results_table_filters_case_insensitively_and_keeps_row_map():
-    table, row_map = results_table(searchable_results(), {"CMU": "#000000", "Stanford": "#111111"}, query="VISION")
     assert table.shape[0] == 2
-    assert row_map == [(0, 0), (1, 0)]
     assert "Vision Event" in table.loc[0, "Event"]
     assert "Robot vision in the wild" in table.loc[1, "Event"]
 
 
-def test_inc_attending_updates_results_and_events_file(tmp_path):
+def test_calendar_action_redirects_to_auth_then_microsoft_login(client):
+    response = client.get("/calendar/action", params={"event_key": "abc123"}, follow_redirects=False)
+
+    assert response.status_code == 302
+    assert response.headers["location"].endswith("/auth/microsoft/start?event_key=abc123")
+
+    start_path = response.headers["location"].replace("http://testserver", "")
+    auth_response = client.get(start_path, follow_redirects=False)
+
+    assert auth_response.status_code == 302
+    assert auth_response.headers["location"].startswith(
+        "https://login.microsoftonline.com/tenant-123/oauth2/v2.0/authorize?"
+    )
+    assert "scope=openid+profile+email" in auth_response.headers["location"]
+    assert client.cookies.get(SESSION_COOKIE)
+    assert len(PENDING_STATES) == 1
+
+
+def test_microsoft_callback_stores_session_and_redirects_to_calendar_event(client, monkeypatch):
+    start_response = client.get("/auth/microsoft/start", params={"event_key": "event-123"}, follow_redirects=False)
+    state = next(iter(PENDING_STATES))
+
+    monkeypatch.setattr(
+        app,
+        "exchange_code_for_user",
+        lambda code, redirect_uri: {"email": "alice@example.com", "name": "Alice"},
+    )
+    monkeypatch.setattr(
+        app,
+        "ensure_user_on_event",
+        lambda current_event_key, user, events_path: f"https://outlook.test/{current_event_key}/{user['email']}",
+    )
+
+    response = client.get(
+        f"/auth/microsoft/callback?code=code-123&state={state}",
+        follow_redirects=False,
+    )
+
+    assert start_response.status_code == 302
+    assert response.status_code == 302
+    assert response.headers["location"] == "https://outlook.test/event-123/alice@example.com"
+    session_token = client.cookies.get(SESSION_COOKIE)
+    assert SESSIONS[session_token] == {"email": "alice@example.com", "name": "Alice"}
+
+
+def test_ensure_user_on_event_reuses_shared_event_and_stays_idempotent(tmp_path, monkeypatch):
     path = tmp_path / "events.json"
-    payload = {
-        "meta": {
-            "schema_version": 5,
-            "cached_at": "2026-04-12T20:22:12+00:00",
-            "ttl_hours": 12.0,
-        },
-        "results": sample_results(),
-    }
-    write_payload(payload, path)
+    write_payload(sample_payload(), path)
+    current_event_key = first_event_key(load_payload(path)["results"])
 
-    results = load_payload(path)["results"]
-    table, row_map = results_table(results, {"CMU": "#000000"}, query="speaker")
+    attendees: list[dict] = []
+    calls: list[str] = []
 
-    updated_table, updated_results, updated_row_map = inc_attending(
-        SimpleNamespace(index=(0, COLS.index("Attending"))),
-        results,
-        row_map,
-        colors={"CMU": "#000000"},
-        query="speaker",
+    def fake_request(method: str, url: str, *, token: str, body: dict | None = None) -> dict:
+        nonlocal attendees
+        calls.append(method)
+        if method == "POST":
+            attendees = list(body["attendees"])
+            return {"id": "teams-event-1", "webLink": "https://outlook.test/teams-event-1", "attendees": attendees}
+        if method == "GET":
+            return {"id": "teams-event-1", "webLink": "https://outlook.test/teams-event-1", "attendees": attendees}
+        if method == "PATCH":
+            attendees = list(body["attendees"])
+            return {"id": "teams-event-1", "webLink": "https://outlook.test/teams-event-1", "attendees": attendees}
+        raise AssertionError(method)
+
+    monkeypatch.setattr("src.teams_calendar.service_access_token", lambda: "service-token")
+    monkeypatch.setattr("src.teams_calendar._request_json", fake_request)
+
+    first_link = ensure_user_on_event(
+        current_event_key,
+        {"email": "alice@example.com", "name": "Alice"},
         events_path=path,
     )
+    payload = load_payload(path)
+    event = payload["results"][0]["events"][0]
+    assert first_link == "https://outlook.test/teams-event-1"
+    assert event["teams_event_id"] == "teams-event-1"
+    assert event["teams_event_web_link"] == "https://outlook.test/teams-event-1"
+    assert event["attending_count"] == 1
+    assert payload["meta"]["schema_version"] == SCHEMA_VERSION
+
+    second_link = ensure_user_on_event(
+        current_event_key,
+        {"email": "bob@example.com", "name": "Bob"},
+        events_path=path,
+    )
+    event = load_payload(path)["results"][0]["events"][0]
+    assert second_link == "https://outlook.test/teams-event-1"
+    assert event["attending_count"] == 2
+
+    third_link = ensure_user_on_event(
+        current_event_key,
+        {"email": "alice@example.com", "name": "Alice"},
+        events_path=path,
+    )
+    event = load_payload(path)["results"][0]["events"][0]
+    assert third_link == "https://outlook.test/teams-event-1"
+    assert event["attending_count"] == 2
+    assert calls == ["POST", "GET", "PATCH", "GET"]
+
+
+def test_write_payload_preserves_teams_fields(tmp_path):
+    path = tmp_path / "events.json"
+    payload = sample_payload()
+    payload["results"][0]["events"][0]["teams_event_id"] = "teams-event-1"
+    payload["results"][0]["events"][0]["teams_event_web_link"] = "https://outlook.test/teams-event-1"
+
+    write_payload(payload, path)
+    reloaded = load_payload(path)
 
-    assert updated_results[0]["events"][0]["attending_count"] == 1
-    assert len(updated_table) == 1
-    assert "attending-pill" in updated_table.loc[0, "Attending"]
-    assert ">1<" in updated_table.loc[0, "Attending"]
-    assert updated_row_map == row_map
-    assert load_payload(path)["results"][0]["events"][0]["attending_count"] == 1
+    assert reloaded["meta"]["schema_version"] == SCHEMA_VERSION
+    assert reloaded["results"][0]["events"][0]["teams_event_id"] == "teams-event-1"
+    assert reloaded["results"][0]["events"][0]["teams_event_web_link"] == "https://outlook.test/teams-event-1"
 
 
 def test_parse_dt_utc_normalizes_naive_and_offset_datetimes():