@jamestesting888/tum-mcp 0.8.1 → 0.9.1

package/CHANGELOG.md

@@ -1,5 +1,42 @@
 # Changes
 
+## 0.9.1 — 2026-10-27
+
+- Make Audio Notes an optional `audio-notes` extension. Keep five base skills,
+  preserve existing audio files, and describe all extensions in a compact README table.
+
+- Use one compact terminal layout for help, connection status, extensions,
+  skills and permissions. Keep automation output available through `--json`.
+- Give setup, install and uninstall matching status-aware pickers. Uninstall
+  offers full package removal through All. Keep named commands for scripts and
+  show optional workflow state through status, connect and doctor; remove the
+  separate extensions command group. Studocu browser sign-in stays unverified.
+- Include TUMonline connection and permission status in doctor. Default checks
+  do not read credentials or create policy files; live checks verify identity
+  without fetching studies or grades.
+- Make unverified status dots blue, ready/enabled green, action needed amber,
+  failures red and inactive states muted. Preserve labels with color disabled.
+
+## 0.9.0 — 2026-10-26
+
+- Add read-only TUMonline study, public catalog and partial curriculum-position
+  tools, with separate account permissions, verified identity and bounded paging.
+- Add optional Studocu search and reviewed personal PDF collection through
+  `tum-mcp install studocu`. Preserve originals, course bindings and recovery
+  history; supplementary personal-use sources are excluded from publication.
+- Add optional `tum-mcp install lecture` and Prepare Lecture for timestamped
+  Lecture Notes in the existing course app. Prefer transcripts and supplied
+  materials, skip whole-silent recordings, preserve original-time coverage and
+  request only critical video frames. Publication remains an explicit opt-in.
+- Support isolated, pinned CPU recognition on Windows x64, Intel Mac and supported
+  Linux/WSL hosts, alongside Apple Silicon MLX acceleration. Keep heavy recognizer
+  dependencies optional; captions/imported WebVTT need no recognizer installation.
+- Handle persistent Studocu SSE replies, enforce response IDs/search limits and
+  bound TUMonline policy reads and catalog output. Unify extension status/removal
+  and verify both optional workflows together. Shorten the getting-started guide.
+- Preserve existing Moodle compatibility tools, sessions, downloads, customized
+  skills and existing course layouts during installation and upgrades.
+
 ## 0.8.1 — 2026-10-26
 
 - Give every doctor/update status a dot: yellow for unverified or attention-needed

package/README.md

@@ -1,196 +1,89 @@
 # TUM MCP
 
-Connect your coding agent to Moodle, Artemis and Zulip. Read course content and
-build a private, source-backed study workspace. Unofficial; independent of TUM.
+Connect your coding agent to **Moodle, Artemis, Zulip and TUMonline**. Read course
+sources with citations and turn them into a private study app. Unofficial and
+independent of TUM.
 
-**Package: [@jamestesting888/tum-mcp](https://www.npmjs.com/package/@jamestesting888/tum-mcp).**
-[Release notes](CHANGELOG.md).
+[**npm package**](https://www.npmjs.com/package/@jamestesting888/tum-mcp) ·
+[Release notes](CHANGELOG.md) · [Setup guide](docs/setup.md)
 
-## Agent setup
+## Get started
 
-Paste this into your coding agent to install the published package:
-
-```text
-Install @jamestesting888/tum-mcp on this computer. Check Node.js is 22.14+.
-Run npm install --global @jamestesting888/tum-mcp@latest, then:
-  tum-mcp setup --client codex
-Use --client claude, cursor, antigravity, or generic for a different client.
-Preserve existing settings and customized skills. Follow the activation steps.
-Help me run tum-mcp connect in an interactive terminal and choose services.
-I will complete sign-in/MFA in the browser. Never request secrets in chat.
-Run tum-mcp doctor to explain what is available and what still needs setup.
-```
-
-## Connect
-
-You need **Node.js 22.14+**, **a Chromium browser**, and your TUM account.
+Requires **Node.js 22.14+**, a Chromium browser and your TUM account.
 
 ```sh
 npm install --global @jamestesting888/tum-mcp@latest
-tum-mcp setup --client codex
+tum-mcp setup
 tum-mcp connect
 tum-mcp doctor
-tum-mcp --help
 ```
 
-Select services with **Space**, then **Enter**. Choose an installed browser and
-complete sign-in there. Only selected tabs open; Zulip needs no API key.
-Read access follows your campus account's permissions; no course/channel scope setup is needed.
-Use `tum-mcp study build --help` for a command's options.
-
-Choose a client with `--client`: `codex`, `claude`, `cursor` or `antigravity`.
-Setup configures MCP and installs all six skills; follow any activation or
-restart prompts. Use `generic` for manual MCP setup.
-
-For existing Cursor and Antigravity setups, run `tum-mcp update` to add the skills.
-Updates and uninstall preserve customized files and report them for review.
+Select `codex`, `claude`, `cursor`, `antigravity` or `generic`, or pass `--client NAME`.
+Follow the activation/restart instructions. In `connect`, select services with
+**Space**, then **Enter**, and complete sign-in/MFA in the browser. Never paste
+credentials into chat. Setup supplies its own Python runtime; Git, Docker and a
+native keyring are unnecessary.
 
-Supports macOS, Windows, glibc Linux x86_64/ARM64 and WSL 3.x. In WSL, sign-in
-opens a Windows browser. Add `--host windows` to setup for a Windows client that
-uses the WSL backend. [Browser and WSL setup](docs/setup.md#wsl).
-
-Setup supplies a private Python runtime. Connections use encrypted local
-files and need no native keyring, Git or Docker.
+Works on macOS, Windows, glibc Linux x86_64/ARM64 and WSL. For a Windows client
+using a WSL backend, add `--host windows` to setup.
+[Browser and platform details](docs/setup.md).
 
 ## Read and study
 
-| Source | Available content |
-| --- | --- |
-| Moodle | Materials, pages, announcements, forums, original downloads and cited PDF pages |
-| Artemis | Lectures, text/online/video units, student slide PDFs, released exercise statements and permitted own feedback |
-| Zulip | Selected course channels, discussion search and cited catch-up |
-
-Campus access is read-only. Exercise start, deployment, execution, submission,
-posting and read-state changes are unavailable.
-
-### Skills and example requests
-
-The package includes six skills. Once you've chosen a course from
-your connections, try requests like these:
-
-| Skill | Use it to | Example request |
-| --- | --- | --- |
-| `read-content` | Read and explain course sources with citations | "Can you explain what we covered in last week's lecture?" |
-| `sync-course` | Create or refresh a course project | "Set up a study project for this course." |
-| `prepare-study` | Build lessons, flashcards and practice | "Make me a study website with flashcards and practice questions." |
-| `prepare-exercises` | Prepare optional hints, checks and worked solutions | "Help me work through this week's exercises in the same app." |
-| `publish-course` | Put a prepared website on GitHub Pages | "Put my study site online so I can open it on my phone." |
-| `audio-notes` | Save spoken lessons under `audio/` | "Turn this into audio notes I can listen to on the go." |
-
-Useful follow-ups in an existing project:
-
-- "Did I miss anything important on Zulip this week?"
-- "There's new course material. Can you update my study site?"
-- "I've left some comments on the site. Can you fix those parts?"
-- "Can you update the audio notes too?"
-
-Client setup installs managed copies of the
-[skill sources](src/tum_mcp/bundled/skills/). Develop or review skills in this repository.
-
-### Recommended study flow
-
-1. **`sync-course`**: Set up a project for your course and collect its material.
-   Use it again when new material is available.
-2. **`prepare-study`**: Turn that material into a study website with explanations,
-   flashcards and practice questions. Use **`prepare-exercises`** for released sheets
-   with prepared interactive guidance. Both workspaces share one app; either can come first.
-3. **`publish-course`** (optional): Put the website online so you can study on your
-   phone. Check the [publishing requirements](#publish-for-phone-access-optional) first.
-4. **`audio-notes`** (optional): Turn the prepared content into spoken lessons.
-   Use them to revisit prepared topics while walking or commuting.
-
-Each project holds one course. To open the website locally, run this from the
-course project folder:
-
-```sh
-tum-mcp study
-```
+Ask your agent to explain course material, find announcements or catch up on a
+Zulip channel. Campus access is read-only and follows your account permissions;
+submissions, posting and exercise execution are unavailable.
 
-Your browser opens at `http://127.0.0.1:8765`. Press **Ctrl+C** in the terminal to stop.
-See the [study guide and local demo](docs/study.md) for more examples.
+| Workflow | Example request |
+| --- | --- |
+| `read-content` | “Explain this week's lecture with source citations.” |
+| `sync-course` | “Set up a project for this course and collect its materials.” |
+| `prepare-study` | “Build lessons, flashcards and practice in a study website.” |
+| `prepare-exercises` | “Add guided exercises from this week's released sheet.” |
+| `publish-course` | “Publish my reviewed study site for phone access.” |
 
-### Publish for phone access (optional)
+Each project holds one course. Run `tum-mcp study` in its folder to open the app.
+Ask the agent to refresh it when sources change or address comments left in the
+app. [Study guide and demo](docs/study.md).
 
-Publishing requires [GitHub CLI](https://cli.github.com/) on the computer where
-your agent runs and an eligible paid GitHub plan. Sign in locally, then check it:
+TUMonline currently provides study names/degrees, public course catalog metadata
+and partial course curriculum positions. The catalog does not show enrollments.
+Grades, exams, progress and full curricula are unavailable. Review its local
+account policy with `tum-mcp manage tumonline`.
+[TUMonline permissions](docs/tum-mcp.md#tumonline-permissions).
 
-```sh
-gh auth login --hostname github.com
-tum-mcp doctor --live
-```
+## Optional extensions
 
-`doctor` checks CLI availability; `--live` also verifies GitHub authentication.
-A coding platform's GitHub connector does not sign in the local CLI. No token
-needs to be pasted into the agent or stored by TUM MCP.
-
-**The repository is private. The website is public.** Review the lesson text,
-quotations and source links before asking your agent to publish.
-
-Later builds update the same site. `tum-mcp study` also prints its hosted URL.
-See [publishing details](docs/study.md#publish-a-study-website).
-
-## Sign-in and session privacy
-
-Sign-in and MFA happen in a temporary browser window. Only service-owned session
-cookies are retained; identity-provider cookies are discarded when it closes.
-Sessions stay on your computer in encrypted files with owner-restricted keys.
-Configured local clients share those connections and saved preferences.
-
-## Your study project
-
-The agent keeps each course in its own folder. After preparing the website,
-your project looks like this, with audio added when requested:
-
-```text
-my-course/
-├── AGENTS.md                 Your rules and a short pointer to agent context
-├── materials/
-│   ├── content/              Lectures, slides and reading
-│   ├── exercises/            Exercise sheets and practice material
-│   ├── exams/                Available exam and revision material
-│   └── other/                Announcements and course information
-├── app/
-│   ├── content.json          Lessons, flashcards and practice questions
-│   └── index.html            Your study website
-├── audio/                    Optional audio notes
-│   ├── scripts/              Narration text
-│   └── tracks/               Audio lessons
-└── .tum-mcp/
-    ├── course.md             Cited course orientation, rules and unknowns
-    ├── state.json            Course identity and source versions
-    └── comments.json         Passage comments, when added
-```
+Run `tum-mcp install` to choose extensions, then reload your client.
 
-Your agent uses your configured AI provider to work with course material.
-Publishing uploads only the generated website; materials, audio and comments
-stay local. Study progress is saved in your browser.
+| Extension | Skill added | What it offers |
+| --- | --- | --- |
+| `lecture` | `prepare-lecture` | Lecture Notes with the professor's extra explanations, timestamps and selected critical visuals. Prefers transcripts and slides; local recognition is optional. |
+| `studocu` | `sync-studocu` | Search and collect selected supplementary PDFs saved in your browser. Personal use only; excluded from published sites. |
+| `audio-notes` | `audio-notes` | Turn prepared Study lessons into concise audio tracks, with resumable generation and coverage tracking. Voice setup happens when used. |
 
-## Update
+Use `tum-mcp status` to see installed workflows and `tum-mcp uninstall` to remove
+them. Named commands also work, such as `tum-mcp install audio-notes` and
+`tum-mcp uninstall lecture`. Existing notes, audio and customizations are retained.
+Audio Notes needs no additional campus sign-in. Studocu uses your own browser.
 
-```sh
-tum-mcp update
-```
+[Lecture and recognition](docs/lecture-notes.md) ·
+[Studocu collection](docs/study.md#studocu-materials) · [Setup details](docs/setup.md)
 
-`update` downloads the latest release, validates its backend, installs it in the
-same npm location and refreshes configured clients. It never downgrades a newer
-installation. Use `tum-mcp update --local` to refresh the installed version without checking npm.
-From 0.6.0 or earlier, upgrade the npm package once to obtain this command.
-Sessions, preferences and downloads carry forward. User-edited entries and skills are
-preserved and reported for review. Reload the client; refresh its cached plugin
-if needed. Study sites are updated separately through the study workflows.
+## Privacy, updates and removal
 
-## Remove
+Sessions are encrypted locally. Your agent uses your configured AI provider to
+process selected material. Publishing requires local GitHub CLI authentication
+and an eligible GitHub plan: **the repository is private; the website is public**.
+Review content before publishing. [Publishing details](docs/study.md#publish-a-study-website).
 
 ```sh
+tum-mcp update    # Upgrade the package and refresh managed clients
 tum-mcp uninstall
 ```
 
-The npm package, managed registrations and unchanged skills are removed. Settings, sessions,
-downloads and study projects are preserved. After closing clients, add
-`--purge-runtime` to remove generated runtimes or `--forget-credentials` to
-remove saved local credentials. [Removal details](docs/setup.md#update-and-remove).
-Use `--client NAME` to remove just one client, or `--keep-package` to retain npm.
-
-[Guide](docs/tum-mcp.md) · [Setup](docs/setup.md) · [Study workflows](docs/study.md) · [Development](docs/development.md)
+Sessions, downloads, course projects and edited skills are preserved. Reload the
+client after updates. [Update and removal options](docs/setup.md#update-and-remove).
 
+[Command guide](docs/tum-mcp.md) · [Development](docs/development.md) ·
 [MIT](LICENSE) · [NOTICE](NOTICE) · [Report a problem](https://github.com/jamestesting0/tum-mcp/issues)

package/docs/development.md

@@ -22,6 +22,9 @@ npm run test:package-lifecycle
 
 Python 3.13 is the managed runtime. Install Tesseract for OCR tests. Default tests
 use synthetic sources and credentials. No language-server installation is needed.
+Studocu fixtures must likewise use synthetic documents and local transports, never
+browser cookies, personal account details or live downloaded PDFs. The extension
+is off by default; validate both selected and unselected skill packs.
 Set `TUM_MOODLE_SYSTEM_KEYRING=1` for a unique synthetic native-store round trip.
 The ordinary campus runtime uses encrypted local files and owner-restricted keys.
 Set `TUM_MCP_BROWSER_INTEGRATION=1` to include the real HTTP static-export browser
@@ -37,7 +40,7 @@ Each layer owns a different failure boundary:
 | Unit | Parsing, policy, malformed input and failure branches with synthetic collaborators |
 | Integration | Real files, CLI/MCP, transactions, HTTP confinement and isolated project updates |
 | Installed consumer | Actual npm/wheel contents, managed runtime and complete browser workflows |
-| Public upgrade | Earlier published versions, repair, ownership conflicts and removal |
+| Public upgrade | Published 0.9.0, repair, ownership conflicts and removal |
 | Native platform | OS credential/ACL behavior; WSL Windows browser transport on both engines |
 
 Study integration fixtures build the private rich regression fixture once, then copy it into a fresh
@@ -56,12 +59,21 @@ CI runs macOS, Windows and Linux, plus both distribution engines on WSL 3.x.
 Consumer checks install the actual npm artifact, discover tools, build a study
 site and test available Chromium browsers with temporary profiles and synthetic
 pages. WSL verifies Windows browser transport. No live account is used.
-Upgrade checks cover public 0.8.0, client refresh, customized-file conflicts,
-failed preparation, runtime repair and removal that preserves work/credentials.
+Upgrade checks start from public 0.9.0 and cover all five clients, optional-extension
+retention, customized-file conflicts, failed preparation, runtime repair and
+removal that preserves work/credentials. Earlier releases are outside this matrix.
 The package-lifecycle check uses a local synthetic registry and real isolated
 global npm prefixes to verify downloads, backend validation, replacement,
 failure ordering and one-command removal. It does not publish a test release.
 All five jobs must pass on the exact pushed commit before completion is claimed.
+Desktop jobs additionally install the optional hash-locked CPU recognizer and
+transcribe the synthetic speech fixture; supported Apple Silicon runners also
+exercise MLX. This explicit test downloads public pinned model files, never campus
+recordings. Ordinary test runs skip it unless `TUM_MCP_LECTURE_ASR_INTEGRATION=1`.
+Recognition runs before package lifecycle checks to expose native dependency
+failures early. Windows also runs the affected browser/UTF-8 fixture checks first.
+Its complete job budget is 35 minutes for native ACL and subprocess coverage;
+the macOS and Linux budgets remain 25 minutes.
 
 Live Moodle checks are opt-in: `TUM_MOODLE_LIVE=1 uv run pytest tests/live -q`.
 They use the developer's selected course and saved session. Keep them out of CI.
@@ -129,3 +141,20 @@ Chromium sign-in/MFA, read a PDF and forum, download a file, then restart and ch
 session reuse. Automated synthetic sign-in does not certify human SSO on every OS.
 For UI changes, exercise the generated app at narrow/wide widths in both themes;
 check keyboard navigation, reduced motion, source links and retained progress.
+
+## Optional Lecture extension
+
+Base setup exposes five workflows and no `tum_live_*` tools. `install lecture`
+records explicit selection, refreshes managed clients and provisions the optional
+recognizer only when requested/supported. `--no-asr` keeps captions/imported WebVTT.
+Heavy recognition dependencies and model weights stay outside the base environment
+and package artifacts. `lecture_processing/` owns bounded media/ASR evidence;
+`lecture_content.py`, `lecture_data.py` and `lecture_assets.py` validate the notes
+and figures used by the static app. See [the workflow guide](lecture-notes.md).
+
+Use `skills validate --all` to check the packaged optional workflow without installing
+it; default validation checks the selected workflows. Activation statistics remain
+unmeasured until genuine fresh-session trial records exist. Default tests use
+synthetic media and course data. `test:consumer` and `test:upgrade` exercise optional
+install/update/export/removal from an actual local npm artifact. Never publish or
+stage npm as a test.

package/docs/lecture-notes.md

@@ -0,0 +1,138 @@
+# Lecture Notes
+
+Install the optional extension only when needed:
+
+```sh
+tum-mcp install lecture
+# Captions/imported WebVTT without provisioning recognition:
+tum-mcp install lecture --no-asr
+```
+
+Restart the coding client to load Prepare Lecture and the three TUM-Live metadata
+tools. Base setup keeps its five skills and existing services. Removing the option
+with `tum-mcp uninstall lecture` preserves course notes, evidence, sessions,
+model caches and customizations. Reinstalling can reuse them.
+
+Ask: “Prepare Lecture Notes from this recording and these slides, focusing on
+what the professor explains beyond the material.” It adds Lecture Notes to the
+same course app, alongside Study and Exercises. Notes have coherent explanations,
+examples, important qualifications, formulas, selective source images and direct
+timestamp access. Attribution review stays private, so the reading flow is clean.
+Lecture Notes has no quizzes or flashcards; broader teaching/practice stays in Study.
+
+## Processing order and cost
+
+1. Validate the selected recording. Whole-recording silence markers make it invalid;
+   stop before content, including cached transcripts/images. Missing duration can
+   be resolved from bounded playlist metadata. Partial silence/cuts retain the
+   original recording clock.
+2. Prefer existing captions or supplied original-time WebVTT. Otherwise the optional
+   pinned local recognizer scans retained audio in resumable chunks. It checks all
+   channels, preserves coverage gaps and flags uncertain/repetitive recognition.
+   Three quiet samples alone cannot invalidate a recording.
+3. Read compact transcript passages, map the full retained lecture and compare with
+   verified slides/materials. Select additional reasoning, examples, corrections,
+   caveats and advice; do not claim novelty when comparison materials are missing.
+4. Use only a few critical recording frames when text/materials leave a consequential
+   visual question unresolved. No default previews or frame-by-frame model calls.
+   Captures use measured times and verified image bytes. Supporting diagrams use
+   normal content blocks, with private attribution review.
+5. Review the notes, citations and selected figures, then build a coherent batch.
+
+Vision cost depends on the chosen model and image size. This workflow reduces
+unnecessary images and model context; it does not promise a fixed price or a
+measured accuracy improvement. In the selected 81-minute retained-audio experiment,
+compact text for 200 passages used 39,412 bytes versus 372,519 with word details,
+with identical text/times. An unchanged preparation reused 12 recognition
+checkpoints with zero inference and fetched about 456 KB of playlist metadata.
+These are observations from that source and cache, not universal benchmarks.
+A direct media playlist offered no separate audio rendition; the processor used
+bounded muxed segments rather than guessing alternative download URLs.
+
+## Host commands
+
+Use the existing course binding and campus connection. Authentication is separate
+from HTTP media retrieval; do not export cookies or pass signed URLs to download
+commands. Captions and imported original-time WebVTT work without a recognizer.
+Automatic ASR installs separately with hash-locked CPython 3.13 wheels and lazy,
+revision-pinned public model weights; neither is part of the base runtime.
+
+| Host | Local recognizer |
+| --- | --- |
+| Apple Silicon macOS 15+ | MLX acceleration by default |
+| Apple Silicon macOS 14 | CPU int8 |
+| Intel macOS 13+ | CPU int8 |
+| Windows x64 | CPU int8; Microsoft Visual C++ runtime required |
+| Linux/WSL x86_64 or ARM64, glibc 2.28+ | CPU int8 |
+
+Native Windows ARM64, 32-bit systems and musl Linux have no supported locked
+runtime. Use captions/imported WebVTT there. CPU inference requires compatible
+CTranslate2 instructions (SSE4.1 on x86); installation verifies native imports and
+int8 support before selecting the runtime. See the upstream
+[CTranslate2 requirements](https://opennmt.net/CTranslate2/installation.html).
+Windows, Linux x64 and Apple Silicon recognition have native CI smoke checks;
+Intel Mac and Linux ARM64 compatibility also depends on the published wheels.
+
+FFmpeg and ffprobe must be on PATH for recording audio extraction or selected
+video frames. They are unnecessary for imported captions and cached text.
+`lecture runtime status` reports the selected engine and missing prerequisites.
+Use `lecture runtime install` to retry after fixing a prerequisite. Advanced users
+can set `TUM_MCP_LECTURE_ENGINE=cpu` consistently for installation and preparation
+to bypass Metal; the default `auto` retains existing MLX runtimes and model caches.
+An engine switch uses separate caches. No cloud transcription API is configured.
+
+CPU decoding uses int8, one worker and at most four threads. It consumes the full
+retained audio, with word timestamps and no VAD retiming. ASR remains fallible,
+especially for names and notation; compare important wording with slides and the
+recording rather than treating confidence scores as proof.
+
+```sh
+tum-mcp lecture inspect PROJECT
+tum-mcp lecture runtime status
+tum-mcp lecture prepare PROJECT --recording URL
+# One selected recording with supplied captions:
+tum-mcp lecture prepare PROJECT --recording URL --transcript lecture.vtt
+# Read bounded compact pages; continue with returned next_offset:
+tum-mcp lecture transcript PROJECT --recording KEY --start 0 --end 28800 --limit 200 --offset 0
+# Only after identifying an unresolved visual question:
+tum-mcp lecture prepare PROJECT --recording URL --frame-at SECONDS
+tum-mcp lecture frames PROJECT --recording KEY --start START --end END
+```
+
+`--words` adds word alignment details to transcript reads. `prepare --previews`
+explicitly requests approximate seek candidates; they are not verified capture
+times. `--language en` is appropriate only for a known English recording.
+
+Prepared media, raw transcripts, receipts and review notes stay under `.tum-mcp/`.
+Safe source receipts can be reconciled into the shared inventory:
+
+```sh
+tum-mcp lecture export-snapshot PROJECT --output snapshot.json
+tum-mcp study sync PROJECT --snapshot snapshot.json
+tum-mcp study schema lectures
+tum-mcp study build PROJECT --local-only
+tum-mcp study inspect PROJECT
+```
+
+The agent authors `app/lectures.json` using real source hashes and coverage; the
+legacy `study/` layout stays supported. Captured images stage in
+`.tum-mcp/lecture-assets/` and copy only when selected. Source freshness and note
+semantic revision are separate, preserving passage comments through harmless
+receipt/image updates. Local comments support `--view lectures --lecture KEY`.
+
+Open with `tum-mcp study` from the course folder. For a credential-free synthetic
+preview after installing the extension, use `tum-mcp study demo PROJECT --lectures`.
+The default demo still has only Study and Exercises. Synthetic teaching/timestamps
+exercise the product and do not establish real lecture accuracy.
+
+## Publication
+
+Lecture Notes is excluded from publication by default, including old saved
+configurations. After reviewing public exposure, use the existing publish-course
+workflow with `--include-lectures`; Exercises has a separate choice. Exclusion
+removes lecture text, lecture-only sources/math and referenced images from exports,
+and removes previously managed remote images while preserving unrelated files.
+Raw media/transcripts, comments and private review metadata are never exported.
+The entire export, including its ownership marker, must fit 16 MiB and 100 files.
+Essential figures are not silently omitted/compressed; a notes-only app excluded
+from publication cannot produce an empty site.

package/docs/setup.md

@@ -19,24 +19,59 @@ tum-mcp doctor
 tum-mcp --help
 ```
 
-Use `--client claude`, `cursor`, `antigravity`, or `generic` for another client.
+Run `tum-mcp setup` to choose clients interactively, or pass `--client claude`,
+`cursor`, `antigravity`, or `generic` directly. Existing registrations have status dots.
 Codex needs the plugin enabled and a restart when prompted. Cursor and
-Antigravity setup installs all six skills and MCP configuration; restart each
+Antigravity setup installs all five base skills and MCP configuration; restart each
 client afterward. Existing MCP-only setups gain the skills through `tum-mcp update`
 or another setup run. Generic setup writes configuration for manual installation.
+
+Studocu is optional: run `tum-mcp install studocu`, then reload the client. The
+extension adds the `sync-studocu` skill and its tools. `tum-mcp status`
+reports the local selection; `tum-mcp uninstall studocu` disables it and
+preserves course materials and customized files. Generic clients use
+`tum-mcp skills export DESTINATION` to install the active pack manually.
 Setup preserves unrelated settings and refuses to
 replace customized entries. It does not authenticate or fetch courses.
 
+Audio Notes is optional: use `tum-mcp install audio-notes`. It adds the
+`audio-notes` skill for prepared Study content; synthesis is set up when used.
+Existing course audio is retained when the extension is disabled.
+
+## Terminal output
+
+`tum-mcp status` shows saved connections and optional workflows;
+`tum-mcp doctor` also checks clients and prerequisites, including TUMonline.
+Green dots mean ready or enabled, blue means not verified, amber means action
+needed, red means failed, and muted dots mean inactive. Every dot has a text
+label. `NO_COLOR` disables color; narrow terminals use stacked rows.
+
+Bare `tum-mcp setup`, `tum-mcp install` and `tum-mcp uninstall` share the same
+keyboard controls as connect. Nothing is preselected; Ctrl+C cancels. Uninstall
+also offers **All — TUM MCP**, which removes the package and managed client setup.
+Personal notes, sessions and customized files are retained. Scripts can name one or both:
+`tum-mcp uninstall lecture studocu --json`.
+
+Use `--json` for machine-readable status, named extension removal/installation,
+skill listing/validation, lecture runtime status or TUMonline permissions.
+The default human output changed in 0.9.1; scripts that parsed those commands
+must add `--json`. The former `extensions` group is removed; use `status` and
+`uninstall NAME`. Named client/extension arguments remain suitable for scripts.
+Data-oriented course authoring commands retain JSON output.
+
 ## Connect
 
 Run **`tum-mcp connect`**, with no arguments, in an interactive terminal:
 
-1. Use up/down to move and Space to select Moodle, Artemis and/or Zulip.
+1. Use up/down to move and Space to select services. Installed Lecture adds TUM-Live;
+   installed Studocu adds Studocu.
 2. Press Enter. If several browsers are installed, choose one and press Enter.
 3. Complete TUM sign-in/MFA in the opened window. Only selected service tabs open.
 4. Return to the terminal for the saved-connection result.
 
-All three services use the same sign-in and encrypted session storage flow.
+Campus services use temporary-browser sign-in and encrypted session storage.
+Studocu opens your own default browser (the Windows browser from WSL); sign in
+there. Its browser session is neither copied nor claimed as verified.
 No API key or native credential-store prompt is needed. A temporary browser
 profile keeps the connection separate from your everyday browser. Ctrl+C closes it and preserves
 connections that already completed. A dumb terminal uses numbered prompts.
@@ -51,6 +86,12 @@ After sign-in, Artemis and Zulip can read content available to your campus accou
 No local course/channel grants are required. Your agent uses status/discover and
 course metadata to find relevant current-semester material, then makes bounded reads.
 An account ID identifies a saved service connection; it is not your TUM login.
+TUMonline additionally has a local policy: `tum-mcp manage tumonline --show`
+shows it, `tum-mcp manage tumonline` changes the studies and courses permission,
+and `tum-mcp manage tumonline --disconnect` removes its saved local session.
+Use `--account ACCOUNT_ID` if more than one TUMonline account is configured.
+Study names, public course metadata and public course curriculum positions are available by default; full curriculum and
+grades or progress are not yet available. [Details and limitations](tum-mcp.md#tumonline-permissions).
 `tum-mcp --help` lists commands; `tum-mcp study build --help` shows command options.
 
 ## WSL
@@ -155,6 +196,7 @@ the npm package and all managed registrations:
 
 ```sh
 tum-mcp uninstall
+# Choose All to remove TUM MCP and its managed client setup.
 ```
 
 Custom edits and user-added files are preserved. Codex's local source/catalog

package/docs/study.md

@@ -1,13 +1,46 @@
 # Course study projects
 
-Six focused skills cover source reading, course sync, Study preparation, Exercises preparation, audio and publishing.
-They run in your local agent, using the connected
+Five base skills cover source reading, course sync, Study preparation, Exercises
+preparation and publishing. They run in your local agent, using the connected
 MCP tools to read course sources. The CLI validates and stores the resulting local
 files; it does not run an AI model.
+The optional `prepare-lecture` skill adds a Lecture Notes workspace; install it with
+`tum-mcp install lecture`. See [Lecture Notes](lecture-notes.md).
+The optional `sync-studocu` skill collects selected student-uploaded material separately.
+The optional `audio-notes` skill turns prepared lessons into spoken tracks; install
+it with `tum-mcp install audio-notes`.
+
+## Studocu materials
+
+Install the optional extension with `tum-mcp install studocu` and reload your
+client. Ask `sync-studocu` to collect materials for a course project. It can
+initialize a Studocu-only project with a verified course and semester.
+Search is anonymous and bounded; a limited result set is not a complete inventory.
+`tum-mcp studocu connect` explains how to sign in to Studocu in your own browser.
+The extension cannot infer account entitlement or download original files through
+the public MCP. Save an original that your account permits in the browser.
+
+The skill records a reviewed selection with `tum-mcp studocu plan PROJECT
+--selection FILE` and tracks it with `tum-mcp studocu status PROJECT --json`.
+Import a selected original with `tum-mcp studocu import PROJECT --document-id ID
+--file FILE`. The document-to-file association is user-selected. Originals go to
+`materials/studocu/summaries`, `materials/studocu/exams` (including mocks and
+solutions), or `materials/studocu/other`. Files remain local and retain their
+original bytes. Consult the skill's collection reference for the selection schema.
+Exact matches in the same group, type and known year share one original through
+a private alias. Each selected document retains its own source identity and URL.
+Changing a document's classification or refreshing its original separates aliases
+when they no longer match; previous versions remain in private history.
+When an existing selection is planned again, unchanged duplicate originals are
+consolidated. Edited or missing files are preserved for review.
+
+Local study material can cite student uploads. Publishing rejects included
+Studocu-backed sources; this source check cannot identify uncited copied text or
+replace a review of the published content.
 
 ## Publish a study website
 
-The optional `publish-course` skill makes a prepared site accessible from a phone
+The `publish-course` skill makes a prepared site accessible from a phone
 or another computer. Its GitHub repository is private; the Pages website is
 public. An eligible paid GitHub plan is required for Pages from private repositories.
 This workflow does not provide private website access. Review lesson text,
@@ -35,8 +68,10 @@ failed setup retries the same saved repository rather than creating duplicates.
 Study is the default hosted workspace, including for old settings. Exercise
 statements, hints and full solutions need explicit `--include-exercises` on the
 publish command after reviewing their public exposure. `--exclude-exercises`
-returns a combined site to Study only, using the same repository and URL. An
-Exercises-only site also requires explicit inclusion.
+removes Exercises from subsequent eligible exports, using the same repository and URL. An
+Exercises-only site also requires explicit inclusion. Lecture Notes separately requires
+`--include-lectures`; old settings default to exclusion. `--exclude-lectures` also removes
+previously managed lecture images. A notes-only export with notes excluded is refused.
 
 Only the selected generated website renderer and data are uploaded. Downloaded
 originals, credentials, AGENTS.md, study inventory, passage comments, progress,
@@ -96,7 +131,7 @@ pse-ws26/
     course.md               Cited course structure, logistics, rules and unknowns
     state.json              Course binding, source versions and coverage
     notes/                  Detailed course/agent notes when needed
-  app/                      Shared Study and Exercises website
+  app/                      Shared Study, Exercises and optional Lecture Notes website
     content.json            Optional source-backed Study content
     exercises.json          Optional prepared exercise guidance
   audio/                    Optional category audio derived from the prepared website
@@ -279,6 +314,7 @@ is a no-op. Do not create `app/` alongside an existing `study/` by hand.
 
 ## Create and maintain audio notes
 
+Install the optional workflow with `tum-mcp install audio-notes`.
 Use `prepare-study` to author the interactive course, then ask `audio-notes` to
 convert that prepared content into spoken lessons. For example:
 

package/docs/tum-mcp.md

@@ -2,7 +2,7 @@
 
 Package: `@jamestesting888/tum-mcp`, CLI: `tum-mcp`, backend: Python 3.13.
 The package combines read-only course retrieval, managed client installation and
-six local course workflows.
+five base course workflows and three optional extensions.
 
 ## Current capabilities
 
@@ -107,7 +107,7 @@ tum-mcp study build --help
 `connect` takes no arguments or connection options. Move with up/down, toggle
 services with Space, and press Enter. Choose a browser when more than one is
 installed. Only selected tabs open in one temporary browser context. Moodle,
-Artemis and Zulip all follow this flow.
+Artemis, Zulip and TUMonline all follow this flow.
 Sign-in/MFA stays in the browser. `TERM=dumb` uses numbered prompts. Ctrl+C
 cancels and retains completed connections.
 
@@ -121,15 +121,53 @@ when the temporary browser closes. Existing browser profiles are never imported.
 Zulip uses its read-only `/json/` routes with the browser session; no API key is
 required. Reconnect through the same selector when a session expires.
 See [Zulip's dispatcher](https://github.com/zulip/zulip/blob/12.0/zerver/lib/rest.py).
-Read access follows the authenticated account's server permissions. No local course,
+For Moodle, Artemis and Zulip, read access follows the authenticated account's server permissions. No local course,
 channel, private-channel or personal-feedback grant is required. Older saved grant
 fields remain readable for compatibility and do not restrict read access. Agents
 prefer relevant current-semester courses and channels, inspect metadata first, and
 page through only the content needed for the request. Explicit older-course requests
 remain supported. Server-denied content, staff-only material and remote writes stay unavailable.
 
+### TUMonline permissions
+
+TUMonline has a separate, account-specific policy. New connections allow study
+names and degrees, public course catalog metadata and public curriculum positions
+for a selected course by default. The position endpoint is anonymous: no student
+session or identifier is sent. These positions are a partial view, not a full
+program curriculum or personal enrollment list; page order can change upstream.
+Course catalog searches accept a title or course number using 2–80 letters,
+numbers, spaces, dots, underscores, plus signs, slashes or hyphens; continue pages
+with the same query.
+Full curriculum structure is unavailable because its public API requires a separate
+service account. Grades and progress need
+separate consent, but their readers are not yet available; exams, admission,
+account, other IT and miscellaneous readers are also unavailable. No campus write
+operations are provided.
+
+Run `tum-mcp manage tumonline --show` to inspect the policy and
+`tum-mcp manage tumonline` in a terminal to select permissions with Space and
+save with Enter. Studies and courses can be allowed or revoked; the remaining
+categories are shown as unavailable and cannot be selected. On basic terminals,
+the command offers a numbered text prompt instead.
+When multiple accounts exist, add `--account ACCOUNT_ID`. Reconnecting preserves
+the policy. `tum-mcp manage tumonline --disconnect` removes the local TUMonline
+credential and retains the policy; it does not revoke remote sessions. An expired
+session requires `tum-mcp connect` again. If the policy is missing or corrupt, use
+`tum-mcp manage tumonline --account ACCOUNT_ID --disconnect` to remove that saved
+session without resetting permissions or affecting other providers.
+
+The policy governs what these TUMonline tools return to all MCP clients sharing
+the same local configuration. A local program running as the same user can access
+local files independently, and this policy does not govern other providers' tools,
+including Moodle's own grades tools. Study names are personal and permitted results
+may be transmitted to your configured agent or its AI provider. TUMonline's study
+chooser can contain extra personal fields in its upstream response; the integration
+holds that bounded response only in memory, projects the permitted fields, and does
+not save the response body. Revoking a permission prevents subsequent reads, but
+cannot recall a response already delivered to a client.
+
 Settings live outside the installed package in `TUMMCP/config/preferences.json`.
-Moodle sessions live under `TUMMoodle/local-session/`; Artemis and Zulip credentials
+Moodle sessions live under `TUMMoodle/local-session/`; Artemis, Zulip and TUMonline credentials
 live under `TUMMCP/credentials/local/`. Each directory has an independent `session.key`.
 Encrypted records and keys have owner-only permissions: 0700 directories / 0600
 keys on POSIX; protected current-user DACLs on Windows through PowerShell. No
@@ -187,9 +225,11 @@ writing files with activation.
 
 The Codex adapter uses a contained Node launcher to pin the managed Python in
 isolated mode; portable stdio manifests require a bare or contained executable.
-The shipped pack contains six skills: `read-content`, `sync-course`,
-`prepare-study`, `prepare-exercises`, `audio-notes` and `publish-course`. Website-specific retrieval
-guidance is loaded from references within read-content. Teaching, schema and design contracts live
+The base pack contains five skills: `read-content`, `sync-course`,
+`prepare-study`, `prepare-exercises` and `publish-course`. Optional extensions add
+`prepare-lecture`, `sync-studocu` and `audio-notes`; choose them with `tum-mcp install`.
+Website-specific retrieval guidance is loaded from references within read-content.
+Teaching, schema and design contracts live
 with prepare-study; the renderer and synthetic example ship as reusable assets.
 Audio Notes converts prepared content into category tracks and maintains coverage,
 scripts, voice settings, candidates and archives under the course's `audio/` root.
@@ -208,7 +248,7 @@ routing quality is a separate evaluation from structural and discovery checks.
 Claude's invocation metadata follows each workflow's selected policy; automatic
 selection is enabled by default and never grants permission for a mutation.
 
-`setup --client cursor` writes `~/.cursor/mcp.json` and installs all six skills
+`setup --client cursor` writes `~/.cursor/mcp.json` and installs the active skills
 under `~/.cursor/skills/`.
 `setup --client antigravity` installs the same skills under `~/.gemini/config/skills/`
 and writes `~/.gemini/config/mcp_config.json`; an existing

package/npm/backend/manifest.json

@@ -1,5 +1,5 @@
 {
-  "wheel": "tum_mcp-0.8.1-py3-none-any.whl",
-  "wheelSha256": "eb55c85f6b1edfb538ff19ddad3b020625dbaf91df7790f5efd4294f337363d8",
-  "requirementsSha256": "25f9efa7a4ffb0b97abcfeb9d4706d04808273ab1b35abcfaa1ef0b66e87591b"
+  "wheel": "tum_mcp-0.9.1-py3-none-any.whl",
+  "wheelSha256": "69d65afa35c27518f03c95e47ddfc23cc77a3d442853804fcb58c2e78b539fe0",
+  "requirementsSha256": "39a401b6e606d3292eb91b8fe9ef60367d4852f203eb409dc52f38b76e513ccf"
 }

package/npm/backend/requirements.txt

@@ -342,6 +342,10 @@ latex2mathml==3.81.1 \
     --hash=sha256:c337668441b71c819b6733905a8058ba9a9d767bae11a0c5fdacb3aff31361bd \
     --hash=sha256:c95add0c0fcdecad2d70567e0643050d5ea1149fb2e98a5d5792fb1c8eea2ed5
     # via tum-mcp
+m3u8==6.0.0 \
+    --hash=sha256:566d0748739c552dad10f8c87150078de6a0ec25071fa48e6968e96fc6dcba5d \
+    --hash=sha256:7ade990a1667d7a653bcaf9413b16c3eb5cd618982ff46aaff57fe6d9fa9c0fd
+    # via tum-mcp
 markdown-it-py==4.2.0 \
     --hash=sha256:04a21681d6fbb623de53f6f364d352309d4094dd4194040a10fd51833e418d49 \
     --hash=sha256:9f7ebbcd14fe59494226453aed97c1070d83f8d24b6fc3a3bcf9a38092641c4a
@@ -368,6 +372,10 @@ opentelemetry-api==1.45.1 \
     --hash=sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75 \
     --hash=sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb
     # via mcp
+packaging==26.3 \
+    --hash=sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79 \
+    --hash=sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c
+    # via tum-mcp
 pillow==12.3.0 \
     --hash=sha256:06ff022112bc9cbf83b60f8e028d94ad87b60621706487e65f673de61610ab59 \
     --hash=sha256:0740a512dc522224c77d9aa5a8d70d8b7d73fb91f2c21125d8d025d3b8990e45 \

package/npm/package-manager.mjs

@@ -72,7 +72,7 @@ async function operate(job) {
     const staging = join(job.temporary, 'prepared');
     runNpm(job.npm, ['install', '--prefix', staging, '--global=false', archive], true);
     const prepared = join(staging, 'node_modules', packageName);
-    runLauncher(prepared, ['setup'], true);
+    runLauncher(prepared, ['setup', '--runtime-only'], true);
     // Only a healthy prepared release may replace the user's npm installation.
     runNpm(job.npm, ['install', ...scope, job.target.global ? archive : `${packageName}@${latest}`]);
     if (JSON.parse(readFileSync(join(job.root, 'package.json'), 'utf8')).version !== latest) throw new Error('npm did not install the selected version; client activation was stopped.');

package/npm/tum-mcp.mjs

@@ -4,71 +4,107 @@ import { readFileSync } from 'node:fs';
 import { parseArgs } from 'node:util';
 import { acquireSetupLock, currentPython, dataRoot, ensureRuntime, removeRuntimeFiles } from './runtime.mjs';
 import { managePackage } from './package-manager.mjs';
+import { printHelp } from './ui.mjs';
 
 let args = process.argv.slice(2);
 const version = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
 try {
-  if (args.length === 0 || (args.length === 1 && ['--help', '-h'].includes(args[0]))) {
-    console.log(`TUM MCP ${version}
-Usage: tum-mcp COMMAND [OPTIONS]
-
-  setup       Configure your coding client and managed runtime
-  connect     Sign in to selected campus services
-  status      Show saved connections
-  discover    List accessible courses or channels
-  doctor      Check installation and authentication
-  update      Update the package and configured clients
-  uninstall   Remove managed setup and the npm package
-  logout      Remove one saved connection
-  serve       Run the MCP server over stdio
-  version     Show the installed version
-  skills      Manage local workflow skills
-  study       Prepare, preview and publish a course app
-
-Use --help for options, for example: tum-mcp study build --help
-Run setup to provision the managed backend, then connect to sign in.
-Reads use your campus account permissions; no local scope selection is needed.`);
+  const wantsHelp = args.length === 0 || args.some(arg => ['--help', '-h'].includes(arg));
+  const helpPython = wantsHelp ? currentPython() : null;
+  if (helpPython) {
+    const forwarded = args.length ? args.filter(arg => !['--local', '--keep-package'].includes(arg)) : ['--help'];
+    const env = { ...process.env }; delete env.PYTHONPATH; delete env.PYTHONHOME;
+    const child = spawnSync(helpPython, ['-I', '-m', 'tum_mcp', ...forwarded], { env, stdio: 'inherit', shell: false });
+    if (child.error) throw new Error('Managed backend could not start; run setup again.');
+    process.exitCode = child.status ?? 1;
+  } else if (args.length === 0 || (args.length === 1 && ['--help', '-h'].includes(args[0]))) {
+    printHelp(version, 'Campus tools and local study workflows.', 'tum-mcp [OPTIONS] COMMAND [ARGS]...', [
+      ['Options', [['--version', 'Show the installed version.'], ['-h, --help', 'Show this help.']]],
+      ['Commands', [
+        ['setup', 'Configure your coding client and managed runtime.'],
+        ['connect', 'Sign in to selected campus services.'],
+        ['status', 'Show saved connections and optional workflows.'],
+        ['doctor', 'Check installation and authentication.'],
+        ['install', 'Choose optional Lecture, Studocu or Audio Notes workflows.'],
+        ['uninstall', 'Choose extensions or All to remove TUM MCP.'],
+        ['manage', 'Manage TUMonline permissions.'],
+        ['skills', 'Inspect and validate workflow skills.'],
+        ['study', 'Prepare, preview and publish a course app.'],
+        ['lecture', 'Prepare lecture recording evidence (optional extension).'],
+        ['studocu', 'Collect selected supplementary materials (optional extension).'],
+        ['discover', 'List accessible courses or channels.'],
+        ['update', 'Update the package and configured clients.'],
+        ['logout', 'Remove one saved connection.'],
+        ['serve', 'Run the MCP server over stdio.'],
+        ['version', 'Show the installed version.'],
+      ]],
+      ['Get started', [['tum-mcp setup --client codex', 'Prepare the backend and a client.'], ['tum-mcp connect', 'Choose services and sign in.']]],
+    ]);
   } else if (['--version', 'version'].includes(args[0])) {
     console.log(version);
+  } else if (args[0] === 'install' && args.some(arg => ['--help', '-h'].includes(arg))) {
+    printHelp(version, 'Choose optional workflows to install, or provide their names.', 'tum-mcp install [lecture|studocu|audio-notes]... [OPTIONS]', [
+      ['Options', [['--asr / --no-asr', 'Provision isolated lecture recognition; models load on demand.'], ['--json', 'Print machine-readable results.'], ['-h, --help', 'Show this help.']]],
+    ]);
   } else if (['setup', 'update', 'uninstall'].includes(args[0]) && args.some(arg => ['--help', '-h'].includes(arg))) {
     const help = {
-      update: 'Usage: tum-mcp update [--local]\nInstall the latest npm release and refresh configured clients.\n--local refreshes this installed version without contacting npm.',
-      setup: 'Usage: tum-mcp setup [--client codex|claude|cursor|antigravity|generic] [--host local|windows]\nProvision the managed runtime and register explicitly selected clients.',
-      uninstall: 'Usage: tum-mcp uninstall [--all] [--purge-runtime] [--forget-credentials]\nRemove managed client setup and this npm installation. Saved data is retained by default.\n--client NAME removes one client only. --keep-package keeps npm installed.',
+      update: {
+        description: 'Install the latest npm release and refresh configured clients.',
+        usage: 'tum-mcp update [OPTIONS]',
+        options: [['--local', 'Refresh the installed version without contacting npm.']],
+      },
+      setup: {
+        description: 'Prepare the runtime and choose coding clients to configure.',
+        usage: 'tum-mcp setup [OPTIONS]',
+        options: [['--client NAME', 'Choose codex, claude, cursor, antigravity or generic; repeat as needed.'], ['--host local|windows', 'Choose the client host; windows is for WSL registrations.']],
+      },
+      uninstall: {
+        description: 'Remove managed setup while retaining saved user data by default.',
+        usage: 'tum-mcp uninstall [lecture|studocu|audio-notes]... [OPTIONS]',
+        options: [['(no arguments)', 'Choose extensions or All in the interactive picker.'], ['--client NAME', 'Remove one client registration.'], ['--host local|windows', 'Choose the client host.'], ['--purge-runtime', 'Remove verified runtimes when All is selected.'], ['--forget-credentials', 'Forget saved credentials when All is selected.']],
+      },
     };
-    console.log(help[args[0]]);
+    const selected = help[args[0]];
+    printHelp(version, selected.description, selected.usage, [
+      ['Options', [...selected.options, ['-h, --help', 'Show this help.']]],
+    ]);
   } else {
+    const hasExtension = args.slice(1).some(arg => ['lecture', 'studocu', 'audio-notes'].includes(arg));
     let packageAction = args[0] === 'update';
     if (args[0] === 'update') {
       if (args.length > 2 || (args.length === 2 && args[1] !== '--local')) throw new Error('Usage: tum-mcp update [--local]. Use --help for details.');
       if (args[1] === '--local') { packageAction = false; args = ['update']; }
     }
-    if (args[0] === 'uninstall') {
+    if (args[0] === 'uninstall' && !hasExtension) {
       const { values } = parseArgs({ args: args.slice(1), options: {
         all: { type: 'boolean' }, client: { type: 'string' }, host: { type: 'string' },
-        'keep-package': { type: 'boolean' }, 'purge-runtime': { type: 'boolean' }, 'forget-credentials': { type: 'boolean' },
+        'keep-package': { type: 'boolean' }, 'purge-runtime': { type: 'boolean' }, 'forget-credentials': { type: 'boolean' }, json: { type: 'boolean' },
       } });
       if (values.host && !['local', 'windows'].includes(values.host)) throw new Error('Choose --host local or windows.');
       if (values.client !== undefined && !['codex', 'claude', 'cursor', 'antigravity', 'generic'].includes(values.client)) throw new Error('Choose a supported --client name.');
       if (values.client && (values.all || values['purge-runtime'] || values['forget-credentials'])) throw new Error('Client-only removal cannot use --all or data/runtime cleanup options.');
-      if (!values.client && !values.all) args.push('--all');
-      packageAction = !values.client && !values['keep-package'];
+      if (values.all && values.json) throw new Error('--json requires named extensions.');
+      if (values['keep-package'] && !values.all && !values.client) throw new Error('Use --client for registration-only removal.');
+      packageAction = Boolean(values.all) && !values['keep-package'];
       args = args.filter(arg => arg !== '--keep-package');
     }
     if (packageAction) {
       process.exitCode = await managePackage(args[0], args.slice(1), dataRoot());
     } else {
-      let python = ['setup', 'update'].includes(args[0]) ? await ensureRuntime() : currentPython();
+      let python = ['setup', 'update', 'install'].includes(args[0]) ? await ensureRuntime() : currentPython();
       if (args[0] === 'uninstall' && !python) python = await ensureRuntime();
       if (!python) throw new Error('SETUP_REQUIRED: Run tum-mcp setup first.');
       const forwarded = args;
       const env = { ...process.env, TUM_MCP_NPM_LAUNCHER: '1' }; delete env.PYTHONPATH; delete env.PYTHONHOME;
-      const purge = args[0] === 'uninstall' && args.includes('--purge-runtime');
+      const purge = args[0] === 'uninstall' && args.includes('--purge-runtime') && args.includes('--all');
       const release = purge ? await acquireSetupLock() : null;
       try {
         const child = spawnSync(python, ['-I', '-m', 'tum_mcp', ...forwarded], { env, stdio: 'inherit', shell: false });
         if (child.error) throw new Error('Managed backend could not start; run setup again.');
         process.exitCode = child.status ?? (child.signal === 'SIGINT' ? 130 : 1);
+        if (args[0] === 'uninstall' && child.status === 20) {
+          process.exitCode = await managePackage('uninstall', [...args.slice(1), '--all'], dataRoot());
+        }
         if (purge && child.status === 0) await removeRuntimeFiles();
       } finally { if (release) await release(); }
     }

package/npm/ui.mjs

@@ -0,0 +1,51 @@
+// Bootstrap help stays available before Python setup; installed help uses the backend.
+const color = process.stdout.isTTY && !('NO_COLOR' in process.env) && process.env.TERM !== 'dumb';
+const width = Math.min(Number(process.env.COLUMNS) || process.stdout.columns || 80, 100);
+const styled = (text, code) => color ? `\x1b[${code}m${text}\x1b[0m` : text;
+
+function line(text, indent = '') {
+  const available = Math.max(16, width - indent.length);
+  let remaining = text;
+  while (remaining.length > available) {
+    const space = remaining.lastIndexOf(' ', available);
+    const end = space > 0 ? space : available;
+    console.log(indent + remaining.slice(0, end));
+    remaining = remaining.slice(end).trimStart();
+  }
+  console.log(indent + remaining);
+}
+
+export function printHelp(version, description, usage, sections = []) {
+  console.log(`${styled('TUM MCP', '1')}  Help  ${styled(version, '2')}`);
+  line(description);
+  console.log();
+  line('Usage');
+  line(usage, '  ');
+  console.log();
+  for (const [title, rows] of sections) {
+    console.log(styled(title, '1'));
+    const labelWidth = Math.max(...rows.map(([label]) => label.length)) + 2;
+    for (const [label, detail] of rows) {
+      if (width < 70 || labelWidth > width / 2) {
+        line(label);
+        line(detail, '  ');
+      } else {
+        const prefix = label.padEnd(labelWidth);
+        const available = Math.max(16, width - prefix.length);
+        const words = detail.split(' ');
+        let row = '';
+        let first = true;
+        for (const word of words) {
+          if (row && row.length + word.length + 1 > available) {
+            console.log((first ? prefix : ' '.repeat(labelWidth)) + row);
+            first = false;
+            row = '';
+          }
+          row += (row ? ' ' : '') + word;
+        }
+        console.log((first ? prefix : ' '.repeat(labelWidth)) + row);
+      }
+    }
+    console.log();
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@jamestesting888/tum-mcp",
-  "version": "0.8.1",
-  "description": "Read-only TUM Moodle, Artemis and Zulip integration with source-backed study workflows",
+  "version": "0.9.1",
+  "description": "Read-only TUM campus tools and source-backed study, exercise and lecture workflows",
   "license": "MIT",
   "type": "module",
   "bin": {
@@ -12,6 +12,7 @@
   },
   "files": [
     "npm/tum-mcp.mjs",
+    "npm/ui.mjs",
     "npm/runtime.mjs",
     "npm/download.mjs",
     "npm/lock.mjs",
@@ -28,7 +29,8 @@
     "docs/setup.md",
     "docs/development.md",
     "docs/tum-mcp.md",
-    "docs/study.md"
+    "docs/study.md",
+    "docs/lecture-notes.md"
   ],
   "scripts": {
     "prepack": "node npm/build.mjs",
@@ -54,6 +56,9 @@
     "moodle",
     "artemis",
     "zulip",
-    "codex"
+    "codex",
+    "tumonline",
+    "studocu",
+    "lecture-notes"
   ]
 }