@jamestesting888/tum-mcp 0.9.0 → 0.9.2

package/CHANGELOG.md

@@ -1,5 +1,48 @@
 # Changes
 
+## 0.9.2 — 2026-10-27
+
+- Combine connection status, extension status and health checks in `doctor`.
+  Show only installed or configured clients, including in the setup picker.
+- Rename campus sign-in to `login`, paired with `logout`. Keep `connect` and
+  `status` as hidden compatibility aliases, including the previous status JSON.
+- Make the course app consistent across Study and Exercises: one choice style,
+  feedback panel, counter format, arrow controls and disclosure chevron. Revision
+  covers all topics until you choose, and review links open the view with items.
+- Show exercise goals in Guidance, sheet summaries and due dates in the list, Mark
+  reviewed at the end with a visible finish, and a link to the next exercise.
+- Improve detail: readable graph edges, fitted phone diagram labels, word-wrapped
+  boxes, no dark-mode flash, steady flashcard layout, labelled reset and in-app
+  confirmation for deleting comments, and neutral page copy on published sites.
+- Lecture Notes: recording times open from the sources of each passage and figure
+  instead of appearing in the text, and the sidebar lists lectures only.
+- Add a Contents button to Study, Exercises and Lecture Notes. It lists the page's
+  headings and follows your reading; wide screens can keep it docked beside the
+  text. The home resume button shows a play icon with the topic name.
+- Keep queued Contents updates from a previous view from hiding the current
+  page's outline after navigation.
+- Remove unused serif font files. Builds delete unedited copies and publication
+  removes them from managed sites; edited copies are kept.
+- Base the study skills on the app: they describe content and checks and point to
+  the bundled app instead of restating its styling.
+
+## 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

package/README.md

@@ -13,13 +13,13 @@ 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 connect
+tum-mcp setup
+tum-mcp login
 tum-mcp doctor
 ```
 
-Choose `codex`, `claude`, `cursor`, `antigravity` or `generic` as the client.
-Follow the activation/restart instructions. In `connect`, select services with
+Choose a detected client or Generic, or use `--client NAME` for an explicit setup.
+Follow the activation/restart instructions. In `login`, 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.
@@ -40,7 +40,6 @@ submissions, posting and exercise execution are unavailable.
 | `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.” |
-| `audio-notes` | “Turn the prepared lessons into audio notes.” |
 | `publish-course` | “Publish my reviewed study site for phone access.” |
 
 Each project holds one course. Run `tum-mcp study` in its folder to open the app.
@@ -55,28 +54,21 @@ account policy with `tum-mcp manage tumonline`.
 
 ## Optional extensions
 
-Install only the workflows you need, then reload your client:
+Run `tum-mcp install` to choose extensions, then reload your client.
 
-```sh
-tum-mcp install lecture          # Prepare Lecture + TUM-Live tools and local ASR
-tum-mcp install lecture --no-asr # Use captions/imported WebVTT instead
-tum-mcp install studocu         # Supplementary Studocu collection workflow
-tum-mcp extensions status
-```
-
-**Lecture Notes** captures the professor's extra explanations, examples and
-caveats, with timestamp links. It starts with transcripts and lecture materials;
-only critical visuals need recording frames. Local recognition uses Apple Silicon
-acceleration or a separate CPU runtime on supported hosts.
-[Lecture Notes and recognizer requirements](docs/lecture-notes.md).
+| 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. |
 
-**Studocu** adds public search and reviewed import of permitted original PDFs you
-save in your browser. Search coverage is incomplete; browser credentials stay out
-of the integration. These supplementary materials remain for personal use and
-cannot be included in published sites. [Studocu workflow](docs/study.md#studocu-materials).
+Use `tum-mcp doctor` 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.
 
-Remove either extension with `tum-mcp uninstall lecture` or
-`tum-mcp uninstall studocu`. Notes, evidence and customizations are preserved.
+[Lecture and recognition](docs/lecture-notes.md) ·
+[Studocu collection](docs/study.md#studocu-materials) · [Setup details](docs/setup.md)
 
 ## Privacy, updates and removal
 

package/docs/development.md

@@ -40,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
@@ -59,8 +59,9 @@ 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 and 0.8.1, 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.
@@ -126,10 +127,15 @@ native MathML; legacy MathML remains accepted. Unit `path` labels group the outl
 without changing learning-progress revisions. Shared modules render all units;
 content changes do not require a framework or per-unit HTML.
 
-Shared renderer assets live in `src/tum_mcp/bundled/course_app/site/`. The shipped
-component preview is deliberately minimal; richer learning pilots live in
-`tests/fixtures/course_app/`. The distributed design/teaching/verification contracts live under
-`src/tum_mcp/bundled/skills/prepare-study/references/`. Local agent notes and
+Shared renderer assets live in `src/tum_mcp/bundled/course_app/site/`; they are the
+source of truth for layout, styling and interaction. Design tokens sit at the top of
+`styles.css`, and the owned-browser fixtures in `tests/integration/` hold the UI
+regressions. The preparation skills describe content and point to the app instead
+of restating its styling, so app changes need no skill edits unless an authored field
+or its meaning changes. Remove a template file by moving it to
+`RETIRED_TEMPLATE_FILES`: builds then delete unedited copies and publication removes
+them from managed sites. The shipped component preview is deliberately minimal;
+richer learning pilots live in `tests/fixtures/course_app/`. Local agent notes and
 screenshots belong in ignored `docs/local/` or `.omo/`. Keep real course projects,
 session files, databases, downloads and environment files out of artifacts.
 
@@ -143,7 +149,7 @@ check keyboard navigation, reduced motion, source links and retained progress.
 
 ## Optional Lecture extension
 
-Base setup exposes six workflows and no `tum_live_*` tools. `install lecture`
+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
@@ -152,7 +158,7 @@ and package artifacts. `lecture_processing/` owns bounded media/ASR evidence;
 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 six/seven. Activation statistics remain
+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

package/docs/lecture-notes.md

@@ -9,15 +9,17 @@ 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 six skills and existing services. Removing the option
+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.
+examples, important qualifications, formulas and selective source images. The
+sources of each passage and figure open the recording at the measured time, so the
+text carries no timestamps, and the Contents button lists the lecture's sections. 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

package/docs/setup.md

@@ -14,35 +14,73 @@ Linux needs a graphical desktop for native browser sign-in; WSL can use Windows.
 ```sh
 npm install --global @jamestesting888/tum-mcp@latest
 tum-mcp setup --client codex
-tum-mcp connect
+tum-mcp login
 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 base 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 extensions status`
-reports the local selection; `tum-mcp extensions remove studocu` disables it and
+extension adds the `sync-studocu` skill and its tools. `tum-mcp doctor`
+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.
 
-## Connect
+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.
 
-Run **`tum-mcp connect`**, with no arguments, in an interactive terminal:
+## Terminal output
 
-1. Use up/down to move and Space to select Moodle, Artemis, Zulip and/or TUMonline.
+`tum-mcp doctor` is the overview for saved connections, optional extensions,
+client setup and runtime health, including TUMonline. Client rows appear only
+for installed clients or existing TUM MCP registrations; unrelated config
+folders do not count as installations. Setup detects the same clients and
+also offers Generic. Use `--client NAME` for an undetected or nonstandard install.
+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 login. 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 `doctor` and
+`uninstall NAME`. Named client/extension arguments remain suitable for scripts.
+Data-oriented course authoring commands retain JSON output.
+
+`login` replaces `connect`, and `doctor` replaces the separate status screen.
+The old command names remain hidden compatibility aliases. `status --json`
+retains its previous configuration format; new integrations should use `doctor --json`.
+
+<a id="connect"></a>
+
+## Login
+
+Run **`tum-mcp login`**, with no arguments, in an interactive terminal:
+
+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.
 
-The services use the same temporary-browser 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.
@@ -50,11 +88,11 @@ connections that already completed. A dumb terminal uses numbered prompts.
 Chrome, Edge, Brave, Chromium, Vivaldi and Opera are detected in their standard
 locations. Selected preview channels and Opera GX are detected where installed.
 For another Chromium build, set `TUM_MCP_BROWSER` to its executable path before
-running connect. Compatible builds must allow Playwright automation. Safari and
+running login. Compatible builds must allow Playwright automation. Safari and
 Firefox are not supported.
 
 After sign-in, Artemis and Zulip can read content available to your campus account.
-No local course/channel grants are required. Your agent uses status/discover and
+No local course/channel grants are required. Your agent uses MCP status/discovery 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`
@@ -76,7 +114,7 @@ Both engines have dedicated CI checks on the current WSL 3.x runner image.
 ```sh
 npm install --global @jamestesting888/tum-mcp@latest
 tum-mcp setup --client cursor --host windows
-tum-mcp connect
+tum-mcp login
 tum-mcp doctor
 ```
 
@@ -115,7 +153,7 @@ browser discovery still requires functioning interop.
   `gh auth login --hostname github.com` interactively on the agent's execution host.
   The [publishing workflow](study.md#publish-a-study-website) uses private repositories
   with public Pages websites and requires an eligible paid GitHub plan.
-- An expired session uses the same `tum-mcp connect` selector. Reconnecting the
+- An expired session uses the same `tum-mcp login` selector. Reconnecting the
   same identity preserves saved preferences.
 - If no browser appears, check its installation or `TUM_MCP_BROWSER`. A managed
   or incompatible Chromium build may prevent automation; try another browser.
@@ -167,6 +205,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,104 +1,14 @@
 # Course study projects
 
-Six base skills cover source reading, course sync, Study preparation, Exercises preparation, audio and publishing.
+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.
-
-## 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.
-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.
-
-## Publish a study website
-
-The optional `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,
-quotations and source links for the intended public audience before publishing.
-
-Install GitHub CLI on the execution host and run `gh auth login --hostname github.com`.
-`tum-mcp doctor` checks CLI availability without network access; `doctor --live`
-also verifies GitHub authentication. It does not publish anything, open sign-in
-automatically, extract tokens, or change Git credential settings.
-
-```sh
-# Preview the chosen name and hosting requirements without GitHub mutations.
-tum-mcp study publish --project PROJECT
-# After choosing public website content; the repository stays private.
-tum-mcp study publish --project PROJECT --public-site
-# Optional account/name override on first setup:
-tum-mcp study publish --project PROJECT --public-site --repository OWNER/NAME
-```
-
-Names use `study-<course>-<semester>` in lowercase with hyphens. A collision gets
-a stable course suffix; existing repositories are never made public. Settings in
-`.tum-mcp/github.json` bind updates to that course, semester and repository. A
-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`
-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,
-audio and arbitrary files stay local. Git itself is not required: the publisher
-uses authenticated GitHub API calls through `gh`. Local publication settings do
-not contain credentials.
-
-After setup, successful `tum-mcp study build PROJECT` commands update that same
-repository automatically. Unchanged verified exports require no network calls
-or commits. The study skills finish related edits in one build. Remote edits
-are preserved for review; the publisher never force-pushes.
-
-```sh
-tum-mcp study publish status PROJECT
-tum-mcp study publish sync PROJECT       # retry pending/failed deployment
-tum-mcp study publish pause PROJECT      # pause future automatic uploads
-tum-mcp study publish resume PROJECT
-tum-mcp study build PROJECT --local-only # skip uploading this build
-```
-
-Uploads are verified against the Pages build and GitHub checks for the exact
-commit. Pending deployment exits with code 2 and is resumable; a successful
-repository update alone is not a deployed site. Authentication, plan or network
-failures preserve the local build. Polling has a budget of at most 60 seconds,
-in addition to bounded API requests.
-The `tum-mcp study` launcher prints local, hosted and repository URLs, plus pending
-or paused status. Study progress remains per browser; passage comments require
-the local preview and are disabled in the hosted export. Device synchronization
-and offline support are not included.
+The optional `audio-notes` skill turns prepared lessons into spoken tracks; install
+it with `tum-mcp install audio-notes`.
 
 ## Start with one course
 
@@ -190,63 +100,31 @@ restores files when possible and reports any remaining conflict.
 
 ## Prepare the website
 
-Ask `prepare-study` to create or extend the Study workspace in `app/`. Units follow the course's
-lecture/week sequence when useful, or use consistent topics. For a single course, use a flat list or one category level followed by topics,
-including several topics in one week. Every unit has:
+Ask `prepare-study` to create or extend the Study workspace in `app/`. The agent
+writes `app/content.json` from your stored course material, and `tum-mcp study build`
+installs the shared course app and checks every cited source. Units follow the
+course's lecture or week sequence when useful, or consistent topics, with at most
+one category level. Every unit has:
 
-- A concise explanation with source links, assumptions and worked examples.
-- Editable LaTeX formulas and inline variables, diagrams, code or comparison tables where they explain the concept.
-- Flip cards with arrow navigation, Space to flip and 1/2 for Again/Got it.
-- Practice questions with exactly four options, one justified answer and feedback for every option.
+- Content: a short lesson with objectives, source links, assumptions and worked
+  examples, using formulas, tables, code, diagrams or line graphs where they help.
+- Flashcards for recall. On a keyboard, arrows move, Space flips and 1/2 rate a card.
+- Practice questions with plausible options and feedback for every option.
 
 The agent uses stored material first, so local content edits work offline. Ask for
 an upstream refresh when you want new course content; an existing check is reused
-within the same request. Unchanged units and reviewed material are retained.
-
-The skill audits objective coverage, technical accuracy and distractors. Its
-STE-inspired English uses short, direct sentences while retaining necessary terms
-and conditions. The design contract uses TUM blue/navy with quiet reading surfaces,
-local fonts, light/dark themes, keyboard navigation and a phone layout. The outline
-collapses using a midpoint boundary arrow revealed on hover or keyboard focus;
-touch screens keep a visible control. On phones it opens a viewport overlay from
-any reading position, with its own scroll and Escape to close. Theme stays in the
-outline; the reset icon is on the course home. A Next link follows the active
-activity at the end of each view.
-
-Revision combines flashcards and practice from topics you select. Open Revision in
-the outline, choose topics and collapse the checklist when ready. It reuses the
-course's categories; selecting a category includes all its topics, and a mixed
-checkbox shows a partly selected category. Revision reuses the
-original items, sources and progress; selecting or removing topics never clears
-your results. The topic selection is remembered locally for this course.
-
-The topic picker and its nested categories collapse independently. You can select a
-whole category while it is closed; its count and mixed state reflect the selection.
-At End of set, outlined question rows include a Review action and chevron. Click
-one to review it in a popup. Closing the popup returns
-you to the same results row without changing progress.
-
-The website uses Atkinson Hyperlegible Next for headings, explanations and controls.
-Code and mathematical notation retain their specialist fonts. Equations adapt to
-their container and keep local horizontal scrolling for indivisible wide expressions.
-Use `\(v_i\)` in teaching text for inline variables and short expressions (JSON:
-`"Use \\(v_i\\)."`). They compile locally to native MathML, including in tables,
-glossaries, cards, questions and feedback. Code and dollar signs stay literal.
-
-Select text in Content, Flashcards or Practice, then click **Comment** to record what is unclear.
-You can also use Ctrl/Command+Alt+M after selecting text. The local preview saves
-notes in `.tum-mcp/comments.json`, separately from learning progress. Click a
-numbered passage marker or highlighted text to open its notes beside the quote.
-Markers sit beside section headings or the current card/question position.
-Notes can be edited, resolved or reopened; changed passages retain their original quotes.
-Revision notes retain their original topic and card/question identity.
-
-Tell your agent: **“Address the open comments in this study project.”** The skill
-reads the notes, checks the cited material, improves the affected explanation and
-verifies the result before recording a resolution. Notes and status changes sync
-automatically while the preview is open. Your draft is kept if a note changes
-elsewhere; choose Use latest or Keep mine before saving. Reload after the agent
-rebuilds the teaching content.
+within the same request. Unchanged units and reviewed material are retained. The
+skill audits objective coverage, technical accuracy and distractors, and writes in
+short, direct sentences that keep necessary terms and conditions.
+
+The course home introduces the course, resumes where you left off and lists topics
+with progress. Each view ends with a Next link through cards and practice to the
+next unit. Revision pools cards and questions from the topics you choose (all topics
+until you choose) and can focus on cards marked Again and questions you missed. It
+reuses the original items and progress, so changing the topic selection never clears
+results, and it remembers your selection for this course. Formulas and inline
+notation such as `\(v_i\)` compile locally to native MathML; code and dollar signs
+stay literal. The app has light and dark themes and a phone layout.
 
 Content lives in `app/content.json`; shared renderer modules and CSS keep the
 site extensible. Source hashes identify affected units. A stale source stops a
@@ -259,6 +137,8 @@ tum-mcp study inspect ./pse-ws26
 tum-mcp study build ./pse-ws26
 ```
 
+## Preview the app
+
 From the course project folder, launch the prepared app with:
 
 ```sh
@@ -277,25 +157,39 @@ same-origin endpoint. It makes no campus requests.
 No course credentials are copied into the website. Browser storage holds progress
 locally. Nothing is published by these commands.
 
+## Passage comments
+
+Select text in Content, Flashcards, Practice, Exercises or Lecture Notes, then click
+**Comment** to record what is unclear. You can also use Ctrl/Command+Alt+M after
+selecting text. The local preview saves notes in `.tum-mcp/comments.json`, separately
+from learning progress. Click a numbered marker or highlighted text to open its notes
+beside the quote. Notes can be edited, resolved or reopened; changed passages retain
+their original quotes, and Revision notes keep their original topic and item.
+
+Tell your agent: **“Address the open comments in this study project.”** The skill
+reads the notes, checks the cited material, improves the affected explanation and
+verifies the result before recording a resolution. Notes and status changes sync
+automatically while the preview is open. Your draft is kept if a note changes
+elsewhere; choose Use latest or Keep mine before saving. Reload after the agent
+rebuilds the teaching content.
+
 ## Prepare weekly exercises
 
 Ask `prepare-exercises` to prepare released weekly sheets in the same app. Study
-and Exercises can be prepared in either order. When both exist, a selector at the bottom of the sidebar
-switches workspaces and remembers the current place. On phones it lives inside the
-open course outline; there is no second switch in the reading area. Exercises are
-listed directly under sheets, optionally grouped by category.
-
-The original statement and subparts come first. Students can solve on paper, mark
-an exercise Reviewed, reveal a worked solution directly, or open **Guidance**.
-Prepared guidance offers one conceptual step, requested hints and specific repair
-feedback. Numeric checks state units/tolerance; choice checks have four options.
-Fillable tables check numeric cells and explicit text variants individually. Graph
-questions support node/edge selections and ordered paths with a visible diagram.
-Line graphs allow sample-point placement, coordinate edits and keyboard adjustment.
-Long math and programming work use saved writing areas and prepared rubrics; code
-is never executed, and symbolic work, proofs and programs are not automatically
-graded. Arbitrary graph drawing can use paper and rubric comparison. Typing, hints and step-by-step guidance are optional. Reviewed records an
-action, not mastery or an assessment result.
+and Exercises can be prepared in either order. When both exist, the workspace selector
+at the bottom of the outline switches between them and remembers your place; on phones
+it sits inside the open outline. The exercise list groups exercises by sheet and shows
+each sheet's summary and due date when the sources provide them.
+
+Each exercise shows the original statement and subparts first. Work on paper or in
+the app, open the worked solution directly, or open **Guidance** for the exercise's
+goals and one step at a time with optional hints and specific feedback. Checks cover
+numbers with units and tolerance, multiple choice, fillable tables, graph selections
+and paths, and plotted sample points. Long math and programming work use saved drafts
+and prepared rubrics; code is never executed, and symbolic work, proofs and programs
+are not graded automatically. Mark an exercise reviewed when you are done; Reviewed
+records an action, not mastery or an assessment result. A Next link leads to the
+following exercise.
 
 Drafts and assistance stay in this browser. Editing a checked answer clears its
 verdict. Semantic changes start fresh progress for only that exercise, while retaining older
@@ -310,8 +204,73 @@ learning revisions, comments, settings and personal files, and stops on customiz
 generated files, an occupied backup or two layouts. Repeating a completed upgrade
 is a no-op. Do not create `app/` alongside an existing `study/` by hand.
 
+## Publish a study website
+
+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,
+quotations and source links for the intended public audience before publishing.
+
+Install GitHub CLI on the execution host and run `gh auth login --hostname github.com`.
+`tum-mcp doctor` checks CLI availability without network access; `doctor --live`
+also verifies GitHub authentication. It does not publish anything, open sign-in
+automatically, extract tokens, or change Git credential settings.
+
+```sh
+# Preview the chosen name and hosting requirements without GitHub mutations.
+tum-mcp study publish --project PROJECT
+# After choosing public website content; the repository stays private.
+tum-mcp study publish --project PROJECT --public-site
+# Optional account/name override on first setup:
+tum-mcp study publish --project PROJECT --public-site --repository OWNER/NAME
+```
+
+Names use `study-<course>-<semester>` in lowercase with hyphens. A collision gets
+a stable course suffix; existing repositories are never made public. Settings in
+`.tum-mcp/github.json` bind updates to that course, semester and repository. A
+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`
+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,
+audio and arbitrary files stay local. Git itself is not required: the publisher
+uses authenticated GitHub API calls through `gh`. Local publication settings do
+not contain credentials.
+
+After setup, successful `tum-mcp study build PROJECT` commands update that same
+repository automatically. Unchanged verified exports require no network calls
+or commits. The study skills finish related edits in one build. Remote edits
+are preserved for review; the publisher never force-pushes.
+
+```sh
+tum-mcp study publish status PROJECT
+tum-mcp study publish sync PROJECT       # retry pending/failed deployment
+tum-mcp study publish pause PROJECT      # pause future automatic uploads
+tum-mcp study publish resume PROJECT
+tum-mcp study build PROJECT --local-only # skip uploading this build
+```
+
+Uploads are verified against the Pages build and GitHub checks for the exact
+commit. Pending deployment exits with code 2 and is resumable; a successful
+repository update alone is not a deployed site. Authentication, plan or network
+failures preserve the local build. Polling has a budget of at most 60 seconds,
+in addition to bounded API requests.
+The `tum-mcp study` launcher prints local, hosted and repository URLs, plus pending
+or paused status. Study progress remains per browser; passage comments require
+the local preview and are disabled in the hosted export. Device synchronization
+and offline support are not included.
+
 ## 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:
 
@@ -380,30 +339,56 @@ for the updated study website”** to reconcile added, changed, removed or moved
 material with the previous verified coverage. This is an agent skill, not a new
 `tum-mcp study` CLI subcommand or a built-in speech service.
 
-## Packaged app template
+## 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 login` 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.
 
-The shared web-app template is packaged in `bundled/course_app/site/`, separately from skill instructions.
-It includes the shell, navigation, flip cards, practice, diagrams and styling.
-Agents author course content in `app/content.json`; `study build` installs the
-shared template, preserves customized files and checks sources. This keeps new
-course sites consistent without rebuilding the interface. `tum-mcp study template`
-shows the bundled files and their combined revision for reproducible development.
+## The course app
 
-## Try the component template
+The shared course app is packaged in `bundled/course_app/site/`, separately from the
+skill instructions. It owns layout, styling and interaction for Study, Exercises and
+Lecture Notes. Agents author only course content; `study build` installs the app,
+preserves customized files and checks sources, so courses gain app improvements
+without rewriting content. `tum-mcp study template` shows the bundled files and
+their combined revision for reproducible development.
 
-After installing a locally built development artifact:
+To see every component with synthetic data:
 
 ```sh
 tum-mcp study demo ./component-preview
 tum-mcp study serve ./component-preview
 ```
 
-This creates one small Study unit and one exercise covering prose, code, tables,
-formulas, graph/process diagrams, cards and response controls. It is a reusable
-component template, not necessarily a good teaching or question-authoring example.
-Actual course authoring follows reviewed sources and the preparation skills. Rich
-learning pilots stay in private test fixtures.
-It uses no campus account. An existing edited demo is preserved.
+The demo creates one small Study unit and one exercise covering prose, code, tables,
+formulas, graph/process diagrams, cards and response controls. It is a format
+reference, not necessarily a good teaching or question-authoring example; actual
+course authoring follows reviewed sources and the preparation skills. Rich learning
+pilots stay in private test fixtures. It uses no campus account, and an existing
+edited demo is preserved.
 
 ## Local helper inputs
 

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
 
@@ -96,15 +96,15 @@ browser onboarding. See [setup](setup.md) for browser choices and WSL.
 ## Connections and read access
 
 ```sh
-tum-mcp connect
-tum-mcp status
+tum-mcp login
+tum-mcp doctor
 tum-mcp discover artemis ACCOUNT_ID
 tum-mcp discover zulip ACCOUNT_ID
 tum-mcp --help
 tum-mcp study build --help
 ```
 
-`connect` takes no arguments or connection options. Move with up/down, toggle
+`login` 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, Zulip and TUMonline all follow this flow.
@@ -152,7 +152,7 @@ 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
+session requires `tum-mcp login` 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.
 
@@ -225,10 +225,12 @@ 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
-with prepare-study; the renderer and synthetic example ship as reusable assets.
+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 and content guidance lives with prepare-study; the course app and its
+synthetic example ship as reusable assets and define the site's design.
 Audio Notes converts prepared content into category tracks and maintains coverage,
 scripts, voice settings, candidates and archives under the course's `audio/` root.
 Publish Course uses host GitHub CLI authentication to create a private repository
@@ -246,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
@@ -318,4 +320,4 @@ course material, local agent notes and screenshots stay under ignored local path
 Maintainer checks include a reviewed tarball inventory, integrity checks and an
 isolated consumer install. Never publish or stage npm packages as a test. Registry
 publication is an explicit maintainer action.
-`tum-mcp status` reports registry state as `not_checked`; it reads local configuration.
+`tum-mcp doctor` reads local configuration and does not check the npm registry.

package/npm/backend/manifest.json

@@ -1,5 +1,5 @@
 {
-  "wheel": "tum_mcp-0.9.0-py3-none-any.whl",
-  "wheelSha256": "0af36e0b89e055a49ae7a8cfa144ff98fdd4feb9e82b724e6ee629f8f4e51b7b",
+  "wheel": "tum_mcp-0.9.2-py3-none-any.whl",
+  "wheelSha256": "ae00fa0b013a30dc0559d9282b0778a213045c53e367aa2e423c25e286a9e308",
   "requirementsSha256": "39a401b6e606d3292eb91b8fe9ef60367d4852f203eb409dc52f38b76e513ccf"
 }

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,61 +4,87 @@ 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
-  install     Install an optional extension: lecture or studocu
-  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
-  extensions  Manage optional extensions
-  studocu     Manage selected Studocu materials
-  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.'],
+        ['login', 'Sign in to selected campus services.'],
+        ['doctor', 'Show connections, extensions and relevant client/runtime health.'],
+        ['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 login', '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))) {
-    console.log('Usage: tum-mcp install lecture [--asr|--no-asr] | tum-mcp install studocu\nInstall an optional Lecture or Studocu workflow and its tools. Lecture recognition dependencies are isolated; models load on demand.');
-  } else if (['setup', 'update', 'uninstall'].includes(args[0]) && !['lecture', 'studocu'].includes(args[1]) && 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 {
-    if (args[0] === 'install' && !['lecture', 'studocu'].includes(args[1])) throw new Error('Usage: tum-mcp install lecture [--asr|--no-asr] | tum-mcp install studocu.');
+    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' && !['lecture', 'studocu'].includes(args[1])) {
+    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) {
@@ -69,12 +95,15 @@ Reads use your campus account permissions; no local scope selection is needed.`)
       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,6 +1,6 @@
 {
   "name": "@jamestesting888/tum-mcp",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "Read-only TUM campus tools and source-backed study, exercise and lecture workflows",
   "license": "MIT",
   "type": "module",
@@ -12,6 +12,7 @@
   },
   "files": [
     "npm/tum-mcp.mjs",
+    "npm/ui.mjs",
     "npm/runtime.mjs",
     "npm/download.mjs",
     "npm/lock.mjs",