feat: add slides TOC, promote Exercise 4, make Ex1 profile TODO explicit

Adds a numbered section table of contents that renders before every
major section divider in the deck, with the current section
highlighted in Temporal green. Reworks the intro slide to lead with
Tailscale outcomes rather than the AI agent. Promotes the Go agent
(Exercise 4) from a take-home stretch goal to a 15-minute in-session
exercise. Makes the "switch profiles to switch environments" lesson
explicit in Exercise 1 by turning the profile load into a required
code TODO instead of an implicit default. Adds a presenter guide for
the Slidev deck so someone cloning the repo can stand it up without
reading `slides/package.json`.

- `slides/theme-temporal/components/WorkshopToc.vue` lists the eight
  workshop sections and highlights the active row in mint;
  `slides/theme-temporal/layouts/toc.vue` wraps it in a two-column
  layout over the existing perspective-grid background. Eight new
  `layout: toc` dividers seeded through `slides/slides.md` with the
  right `current` id for each section
- `slides/theme-temporal/styles/layout.css` gains numbered-list
  styling: Temporal-green leading-zero markers, tabular-nums,
  indented code blocks inside list items so the numbered Exercise
  slides read cleanly
- "What We're Building Today" becomes "What You'll Learn Today."
  Four outcome bullets now lead with infrastructure (Temporal server
  on a tailnet, one config file for local/remote/tailnet, identity
  based rate limits on a shared key) and treat the durable agent as
  the last bullet rather than the framing. Drops the "By the end of
  this workshop, you will be able to" preamble
- Exercise 4 promoted to in-session: `README.md`,
  `docs/workshop-overview.md`, and the deck's Exercise 4 preview
  slide updated. Ex3 tightened from 25 to 15 minutes to make room,
  take-home language removed everywhere
- Exercise 1 gets a third TODO. `worker.py` and `starter.py` now ship
  with a no-arg `ClientConfig.load_client_connect_config()` call plus
  a TODO instructing learners to pass `profile="tailnet"`. Solution
  files updated to match. `exercises/01_hello_tailnet/README.md`
  renumbered (Step 2 creates the config, Step 3 is the new profile
  load, Step 4 is the workflow-ID TODO, Steps 5-7 are run/verify)
- `docs/slides.md` walks through installing pnpm via corepack,
  `pnpm install`, `pnpm dev`, presenter mode, PDF export, and theme
  tweaks. Linked from `docs/index.md` (sixth audience card),
  `mkdocs.yml` nav under "Teach the workshop",
  `docs/run-with-instruqt.md`, and `docs/run-without-instruqt.md`
- Smaller fixes: Kartik's surname corrected from Venugopal to
  Bharath; Mason's deck bio updated to Senior Solutions Architect
  with the programmer/teacher quote and PSF/PyTexas credits; Aperture
  sequence diagram participant renamed VM to Your Worker in the deck
  and in `docs/architecture.md`; `temporal-ts-net` flags in the deck
  updated to match the VPS (`--max-connections 500`,
  `--connection-rate-limit 50`); section divider "temporal-ts-net &
  Go Agent" becomes "and" for the keyboard-only sweep; leftover
  em-dashes in `exercises/01_hello_tailnet/README.md` replaced with
  commas and periods

Author: MasonEgger

README.md

@@ -46,8 +46,8 @@ Then start with [Exercise 1](exercises/01_hello_tailnet/README.md).
 |---|----------|------|-------------|
 | 1 | [Hello Tailnet](exercises/01_hello_tailnet/README.md) | 15 min | Run a geo-IP workflow on the shared Temporal server via Tailscale |
 | 2 | [Explore Tailscale](exercises/02_explore_tailscale/README.md) | 15 min | Discover your network, understand Aperture, run a Go worker over `tsnet` |
-| 3 | [Weather Agent](exercises/03_weather_agent/README.md) | 25 min | Build a durable AI agent with LLM calls routed through Aperture |
-| 4 | [Go Agent](exercises/04_go_agent/README.md) | Stretch | Same agent pattern in Go (take-home challenge) |
+| 3 | [Weather Agent](exercises/03_weather_agent/README.md) | 15 min | Build a durable AI agent with LLM calls routed through Aperture |
+| 4 | [Go Agent](exercises/04_go_agent/README.md) | 15 min | The same weather agent, in Go |
 
 ## Temporal Web UI
 

docs/architecture.md

@@ -80,7 +80,7 @@ The LLM reasons through multiple steps on its own. The workshop's weather agent
 ```mermaid
 sequenceDiagram
   autonumber
-  participant VM as Attendee VM
+  participant VM as Your Worker
   participant AP as Aperture
   participant OAI as OpenAI
   VM->>AP: POST /v1/responses<br/>(no API key needed)

docs/index.md

@@ -46,6 +46,12 @@ If you are *attending* a session, the [GitHub README](https://github.com/tempora
 
     [Infrastructure](infrastructure.md) covers the persistent VPS that runs `temporal-ts-net` and the Tailscale and Aperture pieces behind it.
 
+- **I just want to run the slides**
+
+    ---
+
+    [Present the slides](slides.md) covers installing pnpm, running the deck locally, presenter mode, and exporting to PDF.
+
 </div>
 
 ## Source material

docs/run-with-instruqt.md

@@ -62,6 +62,10 @@ The Aperture endpoint the workshop points at (`http://ai`) must be reachable fro
 - [ ] One test workflow runs end-to-end from an Instruqt VM
 - [ ] Slides loaded
 
+## Slides
+
+The deck lives at `slides/slides.md` and runs under Slidev. See [Present the slides](slides.md) for installing pnpm, running the deck, presenter mode, and exporting to PDF.
+
 ## Backup plan
 
 If the shared server fails mid-workshop:

docs/run-without-instruqt.md

@@ -97,6 +97,10 @@ Pick (1) if your audience are pro devs with their own accounts. Pick (2) if you
 - [ ] Auth key queued up for sharing (QR code printed, or paste-ready in chat)
 - [ ] Slides open
 
+## Slides
+
+The deck lives at `slides/slides.md` and runs under Slidev. See [Present the slides](slides.md) for installing pnpm, running the deck, presenter mode, and exporting to PDF.
+
 ## Backup plan
 
 If the shared server fails mid-workshop:

docs/slides.md

@@ -0,0 +1,96 @@
+# Present the slides
+
+The deck lives at `slides/slides.md` and runs under [Slidev](https://sli.dev). It ships with a Temporal-branded theme at `slides/theme-temporal/` (Inter typography, mint + purple palette, grid + planet backgrounds) and a custom Shiki theme for code blocks.
+
+## Prerequisites
+
+- Node.js 20+
+- `pnpm` (the lockfile in `slides/pnpm-lock.yaml` pins versions for pnpm specifically; npm will work but you will lose reproducible installs)
+
+```shell
+# If you don't have pnpm yet:
+corepack enable
+corepack prepare pnpm@10.33.0 --activate
+```
+
+## Install
+
+```shell
+cd slides
+pnpm install
+```
+
+This pulls in `@slidev/cli` and links the local `slidev-theme-temporal` theme from `slides/theme-temporal/`.
+
+## Run the deck locally
+
+```shell
+pnpm dev
+```
+
+Slidev starts on `http://localhost:3030`. Useful endpoints:
+
+| URL | What it is |
+|---|---|
+| `http://localhost:3030/` | The slideshow |
+| `http://localhost:3030/presenter/` | Presenter mode (current + next slide, speaker notes, timer) |
+| `http://localhost:3030/overview/` | All slides at a glance |
+
+The dev server hot-reloads whenever you edit `slides.md` or anything under `theme-temporal/`.
+
+## Presenting
+
+Run `pnpm dev` on the presenter laptop. Open `http://localhost:3030/presenter/` on your laptop screen and `http://localhost:3030/` on the projector / shared screen. Slidev keeps them in sync. Speaker notes come from HTML comments in `slides.md` (look for the `<!-- ... -->` blocks after each slide).
+
+Handy keyboard shortcuts while presenting:
+
+| Key | Action |
+|---|---|
+| `space`, `right arrow`, `click` | next step (advances through v-click reveals) |
+| `left arrow` | previous step |
+| `f` | toggle fullscreen |
+| `o` | open overview |
+| `d` | toggle dark / light mode |
+
+## Export to PDF
+
+```shell
+pnpm export
+```
+
+Produces `slides-export.pdf` in `slides/`. Needs Chromium; Slidev pulls in `playwright-chromium` automatically on first run.
+
+For a PDF that shows every v-click reveal expanded (useful for handouts):
+
+```shell
+pnpm export -- --with-clicks
+```
+
+For PNGs per slide:
+
+```shell
+pnpm export -- --format png
+```
+
+## Build static HTML
+
+```shell
+pnpm build
+```
+
+Writes a static site to `slides/dist/`. Useful if you want to host the deck somewhere alongside the docs site, or serve it from a USB stick at a conference with sketchy wifi.
+
+## Tweaking the theme
+
+The theme is local, not installed from npm, so you can edit it in place and see changes instantly in the dev server:
+
+| File | What to change |
+|---|---|
+| `slides/theme-temporal/styles/layout.css` | Typography, palette custom properties, heading sizes, footer style, background helpers |
+| `slides/theme-temporal/styles/code.css` | Code-block padding, inline-code styling |
+| `slides/theme-temporal/setup/temporal-dark.json` | Shiki token colors for fenced code blocks |
+| `slides/theme-temporal/setup/mermaid.ts` | Mermaid palette (node colors, edge colors, actor styles) |
+| `slides/theme-temporal/layouts/*.vue` | Per-layout structure and overrides |
+| `slides/theme-temporal/assets/*.webp` | Backgrounds (grid, teal planet, purple planet, rex constellation, glow) |
+
+If you replace a background image, keep it WebP at ~1920 wide and ~200-300 KB for good projector quality without a slow page load. The originals are 16:9.

docs/workshop-overview.md

@@ -31,12 +31,12 @@ Every LLM call goes through Aperture, which holds the real OpenAI key and applie
 | Exercise 1 - Hello Tailnet | 15 min |
 | Exercise 2 - Explore Tailscale + Aperture | 15 min |
 | AI agents on Temporal (talk) | 10 min |
-| Exercise 3 - Weather agent | 25 min |
+| Exercise 3 - Weather agent | 15 min |
 | Rate-limit demo (everyone fires at once) | 5 min |
-| `temporal-ts-net` + Go agent preview | 5 min |
+| Exercise 4 (Go agent) + `temporal-ts-net` walk-through | 15 min |
 | Wrap-up + Q&A | 5 min |
 
-Exercise 4 (the Go agent) is a take-home stretch goal. Files are stubbed and ready.
+Exercise 4 translates the weather agent to Go, reusing the same Temporal server, Aperture endpoint, and tailnet.
 
 ## What attendees need
 

exercises/01_hello_tailnet/README.md

@@ -1,22 +1,22 @@
 # Exercise 1: Hello Tailnet
 
-Your first workflow on the shared Temporal server — accessed through the Tailscale network.
+Your first workflow on the shared Temporal server, accessed through the Tailscale network.
 
 ## Goal
 
 Connect your worker to the shared Temporal dev server running on the tailnet, run a simple geo-IP workflow, and see it in the Temporal Web UI.
 
 ## Background
 
-A Temporal dev server is running on a remote VPS, exposed to this Tailscale network via [temporal-ts-net](https://github.com/temporal-community/temporal-ts-net). You can reach it at `temporal-dev:7233` (gRPC) and `http://temporal-dev:8233` (Web UI) — no VPN setup, no port forwarding, just Tailscale.
+A Temporal dev server is running on a remote VPS, exposed to this Tailscale network via [temporal-ts-net](https://github.com/temporal-community/temporal-ts-net). You can reach it at `temporal-dev:7233` (gRPC) and `http://temporal-dev:8233` (Web UI). No VPN setup, no port forwarding, just Tailscale.
 
 The workflow you'll run is simple: it gets your machine's public IP address, then geolocates it. Two activities, one result.
 
 ### How Environment Configuration Works
 
-Instead of hardcoding server addresses in your code, the Temporal SDK reads connection settings from a [TOML configuration file](https://docs.temporal.io/develop/environment-configuration). This lets you switch between environments (local dev, tailnet, cloud) without changing any code — just switch profiles.
+Instead of hardcoding server addresses in your code, the Temporal SDK reads connection settings from a [TOML configuration file](https://docs.temporal.io/develop/environment-configuration). This lets you switch between environments (local dev, tailnet, cloud) without changing any code. Just switch profiles.
 
-The code already uses `ClientConfig.load_client_connect_config()` to load the active profile. Your job is to create the config file and tell it about the tailnet server.
+Your job is to create the config file, then point the worker and starter at the `tailnet` profile so they connect to the shared server.
 
 ## Instructions
 
@@ -28,9 +28,9 @@ From the repository root:
 uv run scripts/verify_setup.py
 ```
 
-All dependency checks should pass. The Temporal connectivity check will fail — that's expected, you haven't configured the connection yet.
+All dependency checks should pass. The Temporal connectivity check will fail, that's expected, you haven't configured the connection yet.
 
-### Step 2: Complete TODO 1 — Create the Temporal config file
+### Step 2: Complete TODO 1 - Create the Temporal config file
 
 Create the file `~/.config/temporalio/temporal.toml` (you can copy the template from the repo root):
 
@@ -47,23 +47,23 @@ address = "temporal-dev:7233"
 namespace = "default"
 ```
 
-Then make sure your `.env` file sets the active profile:
+### Step 3: Complete TODO 2 - Load the tailnet profile
 
-```bash
-TEMPORAL_PROFILE=tailnet
-```
+Open `practice/worker.py` and `practice/starter.py`. Each one calls `ClientConfig.load_client_connect_config()` with no arguments, which would load the `default` profile (localhost). Change both calls to load the `tailnet` profile:
 
-The worker and starter code use `ClientConfig.load_client_connect_config()` which automatically reads this profile. No code changes needed for the connection — just the config file.
+```python
+config = ClientConfig.load_client_connect_config(profile="tailnet")
+```
 
-### Step 3: Complete TODO 2 — Add your name to the workflow ID
+### Step 4: Complete TODO 3 - Add your name to the workflow ID
 
-Open `practice/starter.py`. Find the TODO (~line 31) and add your `USER_ID` to the workflow ID so you can find it in the shared Temporal UI:
+Still in `practice/starter.py`. Find the TODO near the `execute_workflow` call and add your `USER_ID` to the workflow ID so you can find it in the shared Temporal UI:
 
 ```python
 id=f"{USER_ID}-geo-ip-{uuid.uuid4()}",
 ```
 
-### Step 4: Start the worker
+### Step 5: Start the worker
 
 In one terminal:
 
@@ -74,7 +74,7 @@ uv run worker.py
 
 You should see: `Connecting to Temporal at temporal-dev:7233` followed by `Starting worker on task queue: <your-user-id>-hello-tailnet`
 
-### Step 5: Run the workflow
+### Step 6: Run the workflow
 
 In a second terminal:
 
@@ -85,15 +85,15 @@ uv run starter.py
 
 You should see your public IP address and location printed.
 
-### Step 6: Open the Temporal Web UI
+### Step 7: Open the Temporal Web UI
 
 Open your browser and go to:
 
 ```
 http://temporal-dev:8233
 ```
 
-Find your workflow by searching for your user ID. Click into it to see the execution history — both activities (get_ip, get_location_info) should show as completed.
+Find your workflow by searching for your user ID. Click into it to see the execution history. Both activities (get_ip, get_location_info) should show as completed.
 
 You're now running workflows on a shared Temporal server, accessible only through your Tailscale network. The same config file works for the worker, the starter, and the Temporal CLI:
 

exercises/01_hello_tailnet/practice/starter.py

@@ -16,6 +16,9 @@
 
 
 async def main() -> None:
+    # TODO: Load the "tailnet" profile from ~/.config/temporalio/temporal.toml
+    # so this connects to the shared Temporal server instead of localhost.
+    # Pass profile="tailnet" to load_client_connect_config().
     config = ClientConfig.load_client_connect_config()
     client = await Client.connect(**config)
 

exercises/01_hello_tailnet/practice/worker.py

@@ -17,6 +17,9 @@
 
 
 async def main() -> None:
+    # TODO: Load the "tailnet" profile from ~/.config/temporalio/temporal.toml
+    # so this connects to the shared Temporal server instead of localhost.
+    # Pass profile="tailnet" to load_client_connect_config().
     config = ClientConfig.load_client_connect_config()
     logging.info(f"Connecting to Temporal at {config.get('target_host')}")
     client = await Client.connect(**config)