# Cron Job: Morgenbriefing 9:30

**Job ID:** c11fbac168bd
**Run Time:** 2026-06-07 09:31:49
**Schedule:** 30 9 * * *

## Prompt

[IMPORTANT: The user has invoked the "google-workspace" skill, indicating they want you to follow its instructions. The full skill content is loaded below.]

---
name: google-workspace
description: "Gmail, Calendar, Drive, Docs, Sheets via gws CLI or Python."
version: 1.0.1
author: Nous Research
license: MIT
required_credential_files:
  - path: /DATA/AppData/hermes/google_client_secret.json
    description: Google OAuth2 client credentials - project amadeus-494810
  - path: /DATA/.hermes/google_token.json
    description: Google OAuth2 token - ahmed.aytac@gmail.com, all scopes granted
metadata:
  hermes:
    tags: [Google, Gmail, Calendar, Drive, Sheets, Docs, Contacts, Email, OAuth]
    homepage: https://github.com/NousResearch/hermes-agent
    related_skills: [himalaya]
---

# Google Workspace

Gmail, Calendar, Drive, Contacts, Sheets, and Docs — through Hermes-managed OAuth and a thin CLI wrapper. When `gws` is installed, the skill uses it as the execution backend for broader Google Workspace coverage; otherwise it falls back to the bundled Python client implementation.

## References

- `references/gmail-search-syntax.md` — Gmail search operators (is:unread, from:, newer_than:, etc.)
- `references/bulk-gmail-operations.md` — Bulk deletion: rate-limiting, retry patterns, date-range pagination

## Scripts

- `scripts/setup.py` — OAuth2 setup (run once to authorize)
- `scripts/google_api.py` — compatibility wrapper CLI. It prefers `gws` for operations when available, while preserving Hermes' existing JSON output contract.

## First-Time Setup

The setup is fully non-interactive — you drive it step by step so it works
on CLI, Telegram, Discord, or any platform.

Define a shorthand first:

```bash
GSETUP="python ${HERMES_HOME:-$HOME/.hermes}/skills/productivity/google-workspace/scripts/setup.py"
```

### Step 0: Check if already set up

```bash
$GSETUP --check
```

If it prints `AUTHENTICATED`, skip to Usage — setup is already done.

### Step 1: Triage — ask the user what they need

Before starting OAuth setup, ask the user TWO questions:

**Question 1: "What Google services do you need? Just email, or also
Calendar/Drive/Sheets/Docs?"**

- **Email only** → They don't need this skill at all. Use the `himalaya` skill
  instead — it works with a Gmail App Password (Settings → Security → App
  Passwords) and takes 2 minutes to set up. No Google Cloud project needed.
  Load the himalaya skill and follow its setup instructions.

- **Anything beyond email** → Continue with this skill. Note: the setup
  script (`setup.py`) always requests the full SCOPES list (Gmail
  read/send/modify, Calendar, Drive read, Contacts, Sheets, Docs read).
  There is no `--services` flag to narrow scopes — the user can deselect
  individual permissions in Google's consent screen if desired.

**Question 2: "Does your Google account use Advanced Protection (hardware
security keys required to sign in)? If you're not sure, you probably don't
— it's something you would have explicitly enrolled in."**

- **No / Not sure** → Normal setup. Continue below.
- **Yes** → Their Workspace admin must add the OAuth client ID to the org's
  allowed apps list before Step 4 will work. Let them know upfront.

### Step 2: Create OAuth credentials (one-time, ~5 minutes)

Tell the user:

> You need a Google Cloud OAuth client. This is a one-time setup:
>
> 1. Create or select a project:
>    https://console.cloud.google.com/projectselector2/home/dashboard
> 2. Enable the required APIs from the API Library:
>    https://console.cloud.google.com/apis/library
>    Enable: Gmail API, Google Calendar API, Google Drive API,
>    Google Sheets API, Google Docs API, People API
> 3. Create the OAuth client here:
>    https://console.cloud.google.com/apis/credentials
>    Credentials → Create Credentials → OAuth 2.0 Client ID
> 4. Application type: "Desktop app" → Create
> 5. If the app is still in Testing, add the user's Google account as a test user here:
>    https://console.cloud.google.com/auth/audience
>    Audience → Test users → Add users
> 6. Download the JSON file and tell me the file path
>
> Important Hermes CLI note: if the file path starts with `/`, do NOT send only the bare path as its own message in the CLI, because it can be mistaken for a slash command. Send it in a sentence instead, like:
> `The JSON file path is: /home/user/Downloads/client_secret_....json`

Once they provide the path:

```bash
$GSETUP --client-secret /path/to/client_secret.json
```

If they paste the raw client ID / client secret values instead of a file path,
write a valid Desktop OAuth JSON file for them yourself, save it somewhere
explicit (for example `~/Downloads/hermes-google-client-secret.json`), then run
`--client-secret` against that file.

### Step 3: Get authorization URL

```bash
$GSETUP --auth-url
```

The script prints the full OAuth URL to stdout. The agent must extract it and
send it to the user as a clickable link.

Agent rules for this step:
- The script outputs ONLY the URL (one line) — no JSON wrapper, no `auth_url` field.
- Send that exact URL to the user as a single line. It needs to be a clickable link.
- Tell the user that the browser will likely fail on `http://localhost:1` after approval, and that this is expected.
- Tell them to copy the ENTIRE redirected URL from the browser address bar.
- If the user gets `Error 403: access_denied`, send them directly to `https://console.cloud.google.com/auth/audience` to add themselves as a test user.

### Step 4: Exchange the code

The user will paste back either a URL like `http://localhost:1/?code=4/0A...&scope=...`
or just the code string. Either works. The `--auth-url` step stores a temporary
pending OAuth session locally so `--auth-code` can complete the PKCE exchange
later, even on headless systems:

```bash
$GSETUP --auth-code "THE_URL_OR_CODE_THE_USER_PASTED"
```

If `--auth-code` fails because the code expired, was already used, or came from
an older browser tab, run `$GSETUP --auth-url` again to get a fresh URL.

### Step 5: Verify

```bash
$GSETUP --check
```

Should print `AUTHENTICATED`. Setup is complete — token refreshes automatically from now on.

### Notes

- Token is stored at `~/.hermes/google_token.json` and auto-refreshes.
- Pending OAuth session state/verifier are stored temporarily at `~/.hermes/google_oauth_pending.json` until exchange completes.
- If `gws` is installed, `google_api.py` points it at the same `~/.hermes/google_token.json` credentials file. Users do not need to run a separate `gws auth login` flow.
- To revoke: `$GSETUP --revoke`
- **Zeyd's setup:** Client secret stored at `/DATA/AppData/hermes/google_client_secret.json` (project: `amadeus-494810`, client ID `760929667815-...`). Token at `/DATA/.hermes/google_token.json` (profile-scoped). Gmail address: `ahmed.aytac@gmail.com`. All scopes granted (Gmail read/send/modify, Calendar, Drive, Contacts, Sheets, Docs). Do NOT re-ask for client secret path if these files exist.

## Usage

All commands go through the API script. Set `GAPI` as a shorthand:

```bash
GAPI="python ${HERMES_HOME:-$HOME/.hermes}/skills/productivity/google-workspace/scripts/google_api.py"
```

### Gmail

```bash
# Search (returns JSON array with id, from, subject, date, snippet)
$GAPI gmail search "is:unread" --max 10
$GAPI gmail search "from:boss@company.com newer_than:1d"
$GAPI gmail search "has:attachment filename:pdf newer_than:7d"

# Read full message (returns JSON with body text)
$GAPI gmail get MESSAGE_ID

# Send
$GAPI gmail send --to user@example.com --subject "Hello" --body "Message text"
$GAPI gmail send --to user@example.com --subject "Report" --body "<h1>Q4</h1><p>Details...</p>" --html
$GAPI gmail send --to user@example.com --subject "Hello" --from '"Research Agent" <user@example.com>' --body "Message text"

# Reply (automatically threads and sets In-Reply-To)
$GAPI gmail reply MESSAGE_ID --body "Thanks, that works for me."
$GAPI gmail reply MESSAGE_ID --from '"Support Bot" <user@example.com>' --body "Thanks"

# Labels
$GAPI gmail labels
$GAPI gmail modify MESSAGE_ID --add-labels LABEL_ID
$GAPI gmail modify MESSAGE_ID --remove-labels UNREAD
```

### Calendar

```bash
# List events (defaults to next 7 days)
$GAPI calendar list
$GAPI calendar list --start 2026-03-01T00:00:00Z --end 2026-03-07T23:59:59Z

# Create event (ISO 8601 with timezone required)
$GAPI calendar create --summary "Team Standup" --start 2026-03-01T10:00:00-06:00 --end 2026-03-01T10:30:00-06:00
$GAPI calendar create --summary "Lunch" --start 2026-03-01T12:00:00Z --end 2026-03-01T13:00:00Z --location "Cafe"
$GAPI calendar create --summary "Review" --start 2026-03-01T14:00:00Z --end 2026-03-01T15:00:00Z --attendees "alice@co.com,bob@co.com"

# Delete event
$GAPI calendar delete EVENT_ID
```

### Drive

```bash
$GAPI drive search "quarterly report" --max 10
$GAPI drive search "mimeType='application/pdf'" --raw-query --max 5
```

### Contacts

```bash
$GAPI contacts list --max 20
```

### Sheets

```bash
# Read
$GAPI sheets get SHEET_ID "Sheet1!A1:D10"

# Write
$GAPI sheets update SHEET_ID "Sheet1!A1:B2" --values '[["Name","Score"],["Alice","95"]]'

# Append rows
$GAPI sheets append SHEET_ID "Sheet1!A:C" --values '[["new","row","data"]]'
```

### Docs

```bash
$GAPI docs get DOC_ID
```

## Output Format

All commands return JSON. Parse with `jq` or read directly. Key fields:

- **Gmail search**: `[{id, threadId, from, to, subject, date, snippet, labels}]`
- **Gmail get**: `{id, threadId, from, to, subject, date, labels, body}`
- **Gmail send/reply**: `{status: "sent", id, threadId}`
- **Calendar list**: `[{id, summary, start, end, location, description, htmlLink}]`
- **Calendar create**: `{status: "created", id, summary, htmlLink}`
- **Drive search**: `[{id, name, mimeType, modifiedTime, webViewLink}]`
- **Contacts list**: `[{name, emails: [...], phones: [...]}]`
- **Sheets get**: `[[cell, cell, ...], ...]`

## Rules

1. **Never send email or create/delete events without confirming with the user first.** Show the draft content and ask for approval.
2. **Check auth before first use** — run `setup.py --check`. If it fails, guide the user through setup.
3. **Use the Gmail search syntax reference** for complex queries — load it with `skill_view("google-workspace", file_path="references/gmail-search-syntax.md")`.
4. **Calendar times must include timezone** — always use ISO 8601 with offset (e.g., `2026-03-01T10:00:00-06:00`) or UTC (`Z`).
5. **Respect rate limits** — avoid rapid-fire sequential API calls. Batch reads when possible.

## Pitfalls

- **`$GAPI gmail get` returns empty body for complex multipart emails**: The `_extract_message_body` helper in `google_api.py` only handles simple MIME structures. For multipart/mixed emails with HTML content, inline images, and PDF attachments (e.g. Gotogate booking confirmations), the body field is often empty. When this happens, drop to raw Python: fetch with `format="raw"`, decode the base64, use `email.message_from_bytes` to walk the parts, and extract `text/plain` or `text/html` payloads explicitly. For PDF attachments: find the `application/pdf` part, save the decoded data, then use `fitz` (PyMuPDF) to extract text. See `references/gmail-raw-extraction.md` for the full pattern.
- **Testing-mode token expiry (7 days)**: If the Google Cloud project is in "Testing" status (not published to Production), OAuth refresh tokens live only **7 days**. After that, every API call fails with `REFRESH_FAILED: invalid_grant: Token has been expired or revoked`. The fix: either go through the re-auth flow (`--revoke` then `--auth-url`), OR permanently solve it by publishing the app to Production in Google Cloud Console → OAuth consent screen. The user should expect this every ~7 days until the project is published. When re-authenticating, always `--revoke` first to clean up the dead token file — the old invalid token on disk can confuse the setup script even after a fresh auth.
- **Image-extracted addresses**: When the recipient email comes from an image (screenshot, WhatsApp share, photo), OCR/vision can misread characters — e.g. `sanktmarien.at` read as `sanktmariaen.at`. Before sending, sanity-check the domain against known patterns (schools, companies, etc.) and confirm with the user if anything looks off. A wrong domain means the email goes into a black hole with no bounce.

## Re-Authentication When Token Expires or Goes Missing

The 7-day testing-mode expiry is documented under Pitfalls. Here's the exact recovery flow depending on what state you're in:

**Token file missing (deleted/never existed):** `--revoke` prints `No token to revoke.` — that's fine. Run `--client-secret /path/to/file.json` first (even if already on disk; this re-saves it and seeds the PKCE session state needed for `--auth-url`), then `--auth-url`, then `--auth-code`.

**Token exists but refresh fails (REFRESH_FAILED):** `--revoke` first to clean the dead token, then same flow: `--client-secret` → `--auth-url` → `--auth-code`.

## Calendar Multi-Calendar Support

`google_api.py` now supports querying ALL user calendars, not just `primary`.

**List all available calendars:**
```bash
$GAPI calendar calendars
# Returns: [{"id": "...", "summary": "Arbeit"}, {"id": "...", "summary": "Uni"}, ...]
```

**Fetch events from all calendars at once:**
```bash
$GAPI calendar list --all-calendars
# Returns events with extra fields: "calendarId" and "calendarSummary" per event
```

Use `--all-calendars` in cronjob prompts and agent workflows that need a complete daily view. The default `--calendar primary` still works for targeted queries.

Internal implementation: `_get_all_calendars()` fetches via `calendarList.list` API, then `_list_calendar_events()` iterates each calendar. Events are merged and sorted by start time.

## Flight Booking Workflow

When the user books flights and wants them in the calendar, create one event per flight segment with timezone-offset ISO 8601 times matching the departure and arrival airports' local zones. Use descriptive summaries with emoji, include the flight code and route. Always put the booking reference number in the description. For multi-city round-trips (e.g. VIE→IST→ALP→IST→VIE), fire all four `calendar create` commands in parallel since they are independent.

Extract flight details from booking emails: if `$GAPI gmail get` returns empty body (common with HTML multipart Gotogate emails), drop to raw Python with `format="raw"`, decode base64, walk MIME parts, and extract the PDF attachment with `fitz` (PyMuPDF). See references/gmail-raw-extraction.md for the full pattern.

## Troubleshooting

| Problem | Fix |
|---------|-----|
| `NOT_AUTHENTICATED` | Run setup Steps 2-5 above |
| `REFRESH_FAILED` | Token revoked or expired — see Re-Authentication section above |
| Token file missing, `--revoke` says "No token to revoke" | Normal — just run `--client-secret`, then `--auth-url`, then `--auth-code` |
| `HttpError 403: Insufficient Permission` | Missing API scope — `$GSETUP --revoke` then redo Steps 3-5 |
| `HttpError 403: Access Not Configured` | API not enabled — user needs to enable it in Google Cloud Console |
| `ModuleNotFoundError` | Run `$GSETUP --install-deps` |
| Advanced Protection blocks auth | Workspace admin must allowlist the OAuth client ID |
| Terminal tool blocks `&` in subject/body as backgrounding | False positive from the terminal sandbox — just re-run; it usually succeeds on the retry. If it persists, escape the `&` as `\&` or quote the entire `--body` string with single quotes instead of double quotes. |

## Revoking Access

```bash
$GSETUP --revoke
```

[IMPORTANT: The user has invoked the "daily-dose" skill, indicating they want you to follow its instructions. The full skill content is loaded below.]

---
name: daily-dose
description: Modify DailyDose (täglicher Aktivitäten-Tracker PWA) — Kategorien, Defaults, Server-Daten. Der Tracker von Zeyd unter /media/HDD_1TB/DailyDose/.
---

# DailyDose — Täglicher Aktivitäten-Tracker

DailyDose ist eine PWA (Progressive Web App), die Zeyds tägliche Aktivitäten trackt. Läuft lokal mit Server-Sync.

## Architektur

- **Pfad:** `/media/HDD_1TB/DailyDose/`
- **Dateien:** `index.html` (komplette App in einer Datei), `manifest.json`, `icon.svg`, `icon.png`, `nginx.conf`
- **Speicher:** localStorage im Browser, synchronisiert über HTTP-API mit Server
- **API:** `http://localhost:8765/api/data` — GET liest alle Daten, POST schreibt Key-Value-Paare
- **Storage-Keys:** `dailydose_YYYY-MM-DD` für Tageseinträge, `dd_custom_cats` für Custom-Kategorien

## Kategorien

### Built-in (in `BUILT_IN_CATS` Array, Zeile ~878)
Schlafen, Lernen, Work, Hausarbeit, Kochen, Islam, Sport, Unterwegs, Körperpflege, Sonstiges

### Custom
In `dd_custom_cats` auf dem Server gespeichert. **Custom-Kategorien überschreiben Built-ins** (Name-Match). Werden in `buildCategoryMaps()` nach den Built-ins geladen und überschreiben deren `COLORS`/`ICONS`.

## Tägliche Defaults (`getDefaults()`)

Definiert, welche Aktivitäten für einen neuen Tag vorausgefüllt werden. Aktuelle Defaults (Zeile ~1031):
- **Islam:** 15 min täglich, 45 min freitags
- **Körperpflege:** 30 min täglich
- **Unterwegs:** 1h Montag + Dienstag

Defaults greifen NUR, wenn für den Tag noch KEINE Daten im localStorage existieren. Sobald ein Tag gespeichert wurde, werden die gespeicherten Daten verwendet.

## Änderungen vornehmen

### Neue Kategorie hinzufügen
1. In `index.html` das `BUILT_IN_CATS` Array patchen — neuen Eintrag mit `value`, `icon`, `color` einfügen
2. Default in `getDefaults()` eintragen, falls gewünscht
3. **Server-Daten prüfen:** Falls bereits eine Custom-Kategorie mit gleichem Namen existiert, diese löschen oder anpassen, da sie sonst das Built-in überschreibt

### Default-Wert ändern
In `getDefaults()` patchen. Greift erst für zukünftige, noch nicht gespeicherte Tage.

### Heutigen Tag direkt korrigieren
Wenn heute schon Daten existieren, müssen sie direkt via API gepatcht werden:
```bash
# Heutige Einträge lesen
curl -s http://localhost:8765/api/data | python3 -c "import json,sys; ..."

# Einträge patchen und zurückschreiben
curl -s -X POST http://localhost:8765/api/data \
  -H 'Content-Type: application/json' \
  -d '{"dailydose_YYYY-MM-DD":"[{\"category\":\"...\",\"hours\":0.5}]"}'
```

## Automatische Erinnerungen per Cron-Job

DailyDose-Einträge werden schnell vergessen. Setze automatische Erinnerungen über den `cronjob`-Agenten, damit Zeyd ("Chef") regelmäßig an das Tracking erinnert wird.

### Morgenbriefing (09:30)

Das tägliche Morgenbriefing kombiniert Kalender (Google), CallKeep (Telefonhistorie), DailyDose (Tracking) und Wetter zu einem persönlichen Tagesüberblick. Die vollständige Prompt-Vorlage mit Struktur, Stilregeln und Beispielen steht in **`references/morgenbriefing-template.md`** — bei Verbesserungen am Cronjob diese Datei konsultieren und ggf. aktualisieren.

### Prompt-Stil für Erinnerungen

- **Sprache:** Deutsch
- **Ton:** Freundlich, motivierend, nicht nervig
- **Länge:** 1-2 Sätze, kurz
- **Tageszeit-Anpassung:** Morgens energisch/optimistisch, nachmittags sachlich/freundlich, abends entspannt
- **Abwechslung:** Die Formulierung jedes Mal leicht variieren, damit es nicht monoton wirkt
- **Emojis:** Gelegentlich ein passendes Emoji (nicht inflationär)
- **Anrede:** "Chef"

### Beispiele

```
🌅 Guten Morgen Chef! Zeit für deine DailyDose — was hast du heute vor?
☀️ DailyDose-Check! Nicht vergessen, deine Aktivitäten einzutragen.
🌙 Abend-Check! Noch schnell die DailyDose für heute ausfüllen, Chef?
```

### Scheduling

- Tägliche Erinnerungen: `0 9,16,22 * * *` (dreimal am Tag)
- Goal-Tracking: `*/15 * * * *` (alle 15 Minuten) für motivationsgetriebene Lern-/Ziel-Checks
- `repeat: -1` für wiederkehrende Jobs
- `deliver: origin` für Telegram-Zustellung

### Wichtig

- Cron-Job-Prompts müssen **selbsterklärend** sein — der erinnernde Agent läuft unabhängig und hat keinen Gesprächskontext
- Nicht zu oft auf "wir" oder "uns" Bezug nehmen — die Nachricht soll natürlich wirken

### Goal-Based Motivation Cron Jobs (Lernziel-Tracking)

Wenn Chef ein Tagesziel für eine bestimmte Kategorie hat (z.B. "120 Minuten Lernen → Kopfhörer bestellen"), kann ein Cron-Job alle 15 Minuten den Fortschritt checken und motivierend melden.

**Pattern:**
1. Python-Script schreiben, das die DailyDose-API abfragt, die Ziel-Kategorie summiert und Fortschritt/Erfolg ausgibt (siehe `scripts/dailydose_learn_check.py`)
2. Script nach `~/.hermes/scripts/` kopieren (Cron-Job-Tool erwartet Pfad relativ zu `~/.hermes/scripts/`)
3. Cron-Job mit `schedule: "*/15 * * * *"`, `no_agent: true`, `script: dailydose_learn_check.py` anlegen
4. Job pausieren/löschen, sobald Ziel erreicht ist

**Script-Logik:**
- TARGET_MINUTES definieren
- Heutigen Key `dailydose_YYYY-MM-DD` aus der API lesen
- Stunden der Ziel-Kategorie summieren, in Minuten umrechnen
- Drei Ausgaben: Ziel erreicht (🎉), in Progress (📚 mit Prozent), noch nichts (Motivation zum Starten)

## Motivation/Erinnerungen

Wenn der Chef einen Motivations-Workflow will (z.B. "Sag mir alle 15 Minuten wie viel ich gelernt habe, bis Ziel erreicht"), **nicht** direkt einen `no_agent`-Cronjob mit statischem Script bauen. Die Nachrichten wirken mechanisch und frustrieren. Besser:

1. **Cronjob mit Agent:** `no_agent: false` — der Agent kriegt dann Kontext (DailyDose-Check als Prompt) und kann natürlich, variabel und motivierend antworten.
2. **Oder manuell:** Chef fragt selbst nach Stand, Kiwi checkt dann live. Weniger nervig.

Vorher mit Chef klären, ob automatisierte Reminder überhaupt erwünscht sind.

**Manueller Check per Script:** `scripts/learn_check.py` — gibt Motivations-Stand für eine Kategorie aus. Aufruf: `python3 scripts/learn_check.py [ziel_minuten] [kategorie]`. Default: 120 Minuten, "Lernen".

## Pitfalls

- **Zeitgeist API: ALLE Werte sind JSON-Strings — doppelt parsen!** `curl http://localhost:8765/api/data` liefert ein JSON-Objekt, bei dem JEDER Wert ein String ist, der selbst wieder JSON enthält. `data['zeitgeist-v2']` ist z.B. der String `"{\"2026-05-22\":[25,25,...]}"`. Direktes Zugreifen mit `.get()` oder Index-Notation auf den Roh-String wirft `AttributeError: 'str' object has no attribute 'get'`. **Immer** so parsen:
  ```python
  for k, v in data.items():
      if isinstance(v, str) and v.strip().startswith(('{', '[')):
          data[k] = json.loads(v)
  ```
  Erst DANACH ist `data['zeitgeist-v2']['2026-05-22']` ein echtes Array.
- **Custom überschreibt Built-in:** Wenn eine Custom-Kategorie denselben Namen hat wie ein Built-in, gewinnt die Custom-Version (Icon + Farbe). Bei Konflikten die Custom-Kategorie auf dem Server anpassen.
- **Defaults gelten nicht für existierende Tage:** `getDefaults()` wird nur als Fallback verwendet, wenn `localStorage.getItem(dateKey)` `null` zurückgibt. Für bereits getrackte Tage muss der Server direkt gepatcht werden.
- **Server-Sync beachten:** Daten liegen auf dem Server (`:8765`). Änderungen nur im HTML reichen nicht, wenn der Tag schon Daten hat.
- **Emoji/Icon-Konsistenz:** Immer sowohl Built-in als auch Custom-Kategorie prüfen, damit das richtige Icon angezeigt wird.

The user has provided the following instruction alongside the skill invocation: [IMPORTANT: You are running as a scheduled cron job. DELIVERY: Your final response will be automatically delivered to the user — do NOT use send_message or try to deliver the output yourself. Just produce your report/output as your final response and the system handles the rest. SILENT: If there is genuinely nothing new to report, respond with exactly "[SILENT]" (nothing else) to suppress delivery. Never combine [SILENT] with content — either report your findings normally, or say [SILENT] and nothing more.]

Morgenbriefing für den Chef (Zeyd). Führe folgende Schritte aus:

1. **Kalender:** Rufe den Google Kalender für HEUTE ab mit:
   GAPI="python /DATA/.hermes/skills/productivity/google-workspace/scripts/google_api.py"
   $GAPI calendar list --all-calendars
   So werden ALLE Kalender erfasst (primary, Ahmed & Talla, Arbeit, Uni).
   Fasse die heutigen Termine kurz zusammen. Formatiere: "📅 **Heute im Kalender:**" mit Bullet-Liste aus Summary + Zeit + Kalender. Falls nichts: "Heute steht nichts im Kalender."

2. **Wetter:** Rufe das Wetter für Wien ab mit: `curl -s "wttr.in/Wien?format=%C+%t+%h+%w"` und übersetze ins Deutsche (z.B. "Sonnig, 22°C, Luftfeuchtigkeit 45%, Wind 15km/h"). Formatiere: "🌤 **Wetter in Wien:** ..."

3. **CallKeep:** Rufe curl -s http://localhost:3002/api/contacts und curl -s http://localhost:3002/api/calls ab. Ermittle, WEN Chef heute anrufen muss (Frequenz + letztes Anrufdatum). Ausgabe NUR: "📞 **Anrufen heute:** Name1, Name2" — nur die Namen, keine Anmerkungen. Falls niemand: "📞 **Anrufen heute:** Keine."

4. **DailyDose:** Erinnere den Chef freundlich, seine DailyDose auszufüllen. Kurz, motivierend, auf Deutsch. Variiere die Formulierung jedes Mal.

**Ton:** Freundlich, professionell, auf Deutsch. Kurz und übersichtlich. Sprich Zeyd mit "Chef" an.

## Response

Jetzt das Morgenbriefing zusammenstellen:

---

🌅 **Guten Morgen, Chef!** – Sonntag, 7. Juni 2026

---

### 📅 **Heute im Kalender:**
⚠️ Google-Token abgelaufen (7-Tage-Testing-Limit). Bitte einmal kurz neu authorisieren — hier der Link:

🔗 https://accounts.google.com/o/oauth2/auth?response_type=code&client_id=760929667815-ou3v3c3vj65ae55ugl4l93ptpc6gddkr.apps.googleusercontent.com&redirect_uri=http%3A%2F%2Flocalhost%3A1&scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fgmail.readonly+https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fgmail.send+https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fgmail.modify+https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fcalendar+https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fdrive.readonly+https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fcontacts.readonly+https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fspreadsheets+https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fdocuments.readonly&state=dbZfvFU9V2PM4otFX4hP4i6DUauwEL&code_challenge=p7joRTKIrp67z0IfY-jULTlTUSB_n6NAx4U5iKdlV9A&code_challenge_method=S256&access_type=offline&prompt=consent

Nach dem Klick einfach die komplette URL aus der Adressleiste kopieren (die mit `localhost:1/?code=...`) und mir schicken — ich tausche sie dann ein.

---

### 🌤 **Wetter in Wien:**
Sonnig, 21°C, Luftfeuchtigkeit 60%, Wind aus Südost mit 14 km/h. Ein schöner Sonntag!

---

### 📞 **Anrufen heute:**
Sahika Teyze

---

### 💊 **DailyDose:**
Sonntag — perfekter Tag, um deine DailyDose in Ruhe auszufüllen, Chef! Ein kurzer Blick zurück auf die Woche lohnt sich. ☀️

---