⏳ This skill is pending AI review.
Scores will appear once the review pipeline completes.
code-delegate
>-
Choose how to use this skill
You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.
1. Native installer
This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.
Do not guess an installer command or replace an existing version without reviewing the diff.
2. Complete package recommended
Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.
No complete ProSkills package is published for this listing yet.3. Prompt-only
Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.
Need only the instruction file?
Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.
No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.
// RATINGS
Not yet listed on ClawHub or SkillsMP
// README
🤖 Jarvis AI Desktop Agent
A self-hosted AI chatbot for Linux with a huge feature set — it plans, executes, and gets real work done when you ask it to. It only becomes autonomous through the agent_autonomy_kit skill.
Control your Linux desktop with natural language. Receive tasks via WhatsApp. Search your knowledge base. Automate everything.
🖱️ New: the AI Mouse — drag a frame around anything on your Windows screen, pick a question, get the answer
Your self-hosted AI in every Windows program — no copying, no saving screenshots, no switching windows — details
🛡️ Hardened to the requirements of Germany's Federal Office for Information Security (BSI)
IT-Grundschutz APP.3.1 · TR-02102 · 34 measures implemented, each secured by automated tests — details
Live Demo · Report Bug · Request Feature · Contribute

🖱️ AI Mouse — ask your screen
The AI Mouse brings your self-hosted AI into every Windows program. Hold the right mouse button, drag a frame around an error message, a table, a chart or foreign-language text, pick a question — and the answer appears in a small window right next to it.
| 1 | 2 | 3 | 4 |
|---|---|---|---|
| Hold the right mouse button over any window | Drag a frame around what you are asking about — a normal right-click still works | Pick a question from your list (“read the text”, “explain this error”, “translate” …) or type your own | Read the answer in a small window next to it — ready to copy |
- 📦 Portable, no installation — a single Windows file, no admin rights needed. Your own Jarvis server builds it, with your brand and language (German/English).
- 🏢 Built for the company — distribution via a network share, optional Authenticode signing, automatic updates; access only for explicitly approved users or AD groups.
- 💬 Questions managed centrally — everyone keeps their own list in the portal, administrators provide shared templates; the menu is available even offline.
- 🔎 With your knowledge — optionally looks things up read-only in the knowledge base or in Jira, Confluence and SAP, enabled by the administrator.
- 🖼️ Replace text in images — e.g. swap the English labels of a screenshot for German ones; the edited image appears in the answer window.
- 🔐 Securely connected — signs in to your Jarvis; only an encrypted session token (DPAPI) is stored, never a password. Screen content is treated as untrusted: read-only tools, no special privileges.
Requires Windows 11 (64-bit) and a language model that can read images. Provided in the Jarvis
portal under “AI Mouse” and enabled by the administrator. Source: ai-mouse/ (C#/.NET 8).
🛡️ Security hardened to BSI requirements
Jarvis was systematically checked against the requirements of the German Federal Office for Information Security (BSI) — IT-Grundschutz module APP.3.1 (web applications) and technical guideline TR-02102 (cryptography). Every resulting measure is implemented in code and secured by an automated guard test that fails if the protection is removed.
| 34 | measures implemented (3 critical, 13 high, 12 medium, 6 low findings) |
| 34 | automated security tests, plus counter-tests that deliberately break a fix to prove the test bites |
What this means in practice
- 🔐 Cryptography per BSI TR-02102 — TLS 1.2 restricted to the TR-02102-2 cipher suites, TLS 1.3 to AES-GCM, own certificates with RSA 3072; security headers (HSTS, clickjacking protection, nosniff) per APP.3.1.A21.
- 🪪 Login and session — mandatory 2FA for administrators, account lockout after failed attempts, sessions with maximum lifetime and idle timeout (APP.3.1.A7), session in an HttpOnly cookie with CSRF protection, enforced Content-Security-Policy.
- 🧱 Strict privilege separation — the application runs unprivileged and systemd-hardened; root actions only through a separate broker with named operations and TOTP approval; every endpoint is denied by default.
- 🤖 AI under control — tool results are framed against prompt injection; external or deleting actions require confirmation; shell commands run in a mandatory sandbox (own network namespace, resource limits) — no sandbox, no execution.
- 🗝️ Secrets and data — credentials encrypted with a master key kept outside the data directory; revealing a secret requires re-confirmation; retention periods for histories and logs; tamper-evident security log (hash chain).
- 📦 Secure supply chain — updates are only accepted with a valid signature; every change runs through dependency audit, SBOM, static analysis and secret scanning.
Based on a comparison with BSI requirements (as of 2026-09-29) and the measures implemented as a
result. This is not a certification or audit by the BSI. Some measures (e.g. SSH hardening, packet
filter) are applied by the operator when setting up the server — see deploy/security/README.md.
📋 Table of Contents
- AI Mouse — ask your screen
- Security hardened to BSI requirements
- Overview
- Screenshots
- Key Features
- Architecture
- Tech Stack
- Installation
- Configuration
- Multi-User Chat
- Multi-Agent System
- Skill System
- Email Automation & Outlook Add-in
- SAP Analysis Area
- Short Tracks
- WhatsApp Integration
- Knowledge Base
- Vision & Face Recognition
- AD/LDAP & Security
- Multimedia Attachments
- Feedback & Self-Improvement
- Cognitive Evolution
- Client Apps
- API Reference
- Contributing
- Third-Party Licenses
- License
Overview
Jarvis is a self-hosted AI chatbot with a huge feature set that runs on a Linux server. Give it a goal in plain language — through the web chat, the built-in Support portal, a task pane inside Outlook or Excel, or even WhatsApp — and it plans and executes: browsing the web, reading and writing files, running code, editing existing spreadsheets, generating Office documents & diagrams, answering email by rule, evaluating SAP data read-only, managing your calendar. Whenever you want, you can watch it work live on the desktop via an optional VNC view.
"Find all emails from last week about Project Alpha, summarize them,
and creat
// HOW IT'S BUILT
// FILES
9 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.
deploy/claude_subagent/SKILL.md5.4 KB0c9da2245ec0upstream ↗
--- name: code-delegate description: >- Gibt eine eng umrissene Codeaufgabe an den {marke}-Agenten ab und holt sie als geprueften Patch zurueck – spart Anthropic-Tokens bei mechanischer Breitenarbeit. Nutzen, wenn eine Aenderung VIEL Datei-Lesen und WENIG Beschreibung braucht und eine vorhandene Testdatei das Ergebnis beweist. --- # Codearbeit an {marke} abgeben {marke} rechnet auf kostenlosen Tokens. Diese Faehigkeit verschiebt **Lesen und Suchen** dorthin – nicht das Denken. ## Die Entscheidungsregel **Delegiere nur, wenn die Beschreibung kurz und die Dateiarbeit breit ist.** Musst du den Code erst lesen, um eine brauchbare Spezifikation zu schreiben, hast du die Ersparnis schon ausgegeben. Dann mach es selbst. ### Geeignet | Klasse | Beispiel | |---|---| | Mechanische Breitenarbeit | „`-localhost` an alle x11vnc-Aufrufe" (16 Stellen), „Cache-Buster an 40 Skript-Tags" | | Eine kleine Aenderung mit vorhandenem Waechter | „Variable ergaenzen, `tests/test_branding_aliase.py` muss gruen bleiben" | | Zwei Stellen, die zusammenpassen muessen | Deklaration in `:root` UND `body`, Feld in `create_*` UND der Whitelist von `update_*` | ### NICHT geeignet – hier selbst arbeiten - **Alles Konventionslastige.** CLAUDE.md hat ~167.000 Token. Ein 35B-Modell wendet die Regeln darin nicht zuverlaessig an. - **Alles Sicherheitsrelevante** (Gates, Sandbox, Rechte, Auth). - **Zustandswechsel.** „Aendere X, miss, mach rueckgaengig" ist reproduzierbar gescheitert (17 Schritte, kein Ergebnis). **Eine Delegation = ein Zielzustand.** Den Rueckbau macht der Server per `git checkout`. - **Alles ohne mechanischen Riegel.** Kein Test, der es beweist → nicht delegieren. Die Modellantwort allein ist kein Nachweis. ## Ablauf ```bash S=deploy/claude_subagent/delegiere.py # im Repo versioniert, nicht in .claude/ # 1. Auftrag schreiben (Datei, damit Anfuehrungszeichen nicht stoeren) cat > /tmp/auftrag.txt <<'EOF' In frontend/css/chat.css im :root-Block die Variable ergaenzen: --accent-soft: color-mix(in srgb, var(--accent) 20%, transparent); EOF # 2. Abgeben -> gibt die Auftragskennung aus ID=$(python3 $S senden --spec-datei /tmp/auftrag.txt \ --dateien frontend/css/chat.css \ --riegel tests/test_branding_aliase.py) # 3. Warten; bei Erfolg kommt der Patch auf stdout, der Bericht auf stderr python3 $S warten "$ID" > /tmp/patch.diff ``` ## Die Abbruchregel – ausnahmslos Der Server prueft **alles-oder-nichts** und liefert nur dann einen Patch: Patch nicht leer · nur die freigegebenen Dateien angefasst · Riegel gruen · Patch nicht gekuerzt. Kommt **kein** Patch (Exitcode ≠ 0), dann **mach die Aufgabe selbst**. Nicht nachbessern lassen, nicht ein zweites Mal delegieren, nicht „fast richtig" uebernehmen. Ein zweiter Versuch kostet mehr als die Ersparnis. Kommt ein Patch, **lies ihn**, bevor du ihn anwendest: ```bash git apply --check /tmp/patch.diff && git apply /tmp/patch.diff ``` Ein gruener Riegel beweist, dass die Aenderung *funktioniert* – nicht, dass sie zu den Projektkonventionen passt (Einrueckung, Spaltenausrichtung, Kommentare). Das ist deine Aufgabe und der Grund, warum der Patch klein sein muss. ## Was der Auftragstext enthalten muss Der Agent kennt die Projektregeln **nicht**. Schreibe deshalb: - **Was genau** wo hinein soll – woertlich, wenn es ein fester Text ist. - **Keine** Begruendung, keine Historie, kein „wie ueblich". - **Kein** „raeum dabei auf", „formatiere mit", „pruefe auch noch". Zahlen aus der Antwort des Agenten sind **wertlos** – er zaehlt nachweislich falsch (drei von drei Probelaeufen). Verlass dich auf Patch und Riegel; beides rechnet der Server selbst. ## Voraussetzungen Diese Datei ist bereits auf DIESE Installation ausgestellt – die beiden Befehle unten sind vollstaendig, es fehlt nur der Schluessel: ```bash printf '%s' 'HIER-DEINEN-SCHLUESSEL-EINSETZEN' > ~/.{marke_slug}-csa-key printf '%s' '{adresse}' > ~/.{marke_slug}-csa-url chmod 600 ~/.{marke_slug}-csa-key ``` - **Schluessel** in `{MARKE}_CSA_KEY` oder `~/.{marke_slug}-csa-key` – in {marke} unter `{adresse}/claude` erzeugen. Dort stehen dieselben drei Zeilen samt eingesetztem Schluessel zum Kopieren, und der Schluessel bleibt dauerhaft sichtbar. **Nie ins Repo.** - **Adresse** ist oben schon eingesetzt: `{adresse}`. (Ueber `{MARKE}_CSA_URL` bzw. die Datei laesst sich der Client auch gegen eine andere Installation richten – eine feste Vorgabe im Code gibt es bewusst nicht.) - Der lokale Stand muss auf `origin/master` liegen und die Zieldateien duerfen keine ungespeicherten Aenderungen haben – der Client prueft beides und bricht sonst ab. Laeuft gegen **jede** {marke}-Installation, auch produktive. Der Riegel ist dort verfuegbar, weil der Arbeitsbereich frisch von `origin/master` geklont wird – ein `sparse-checkout` auf dem Server (der `tests/` in `/opt/jarvis` ausblendet) wirkt nur auf dessen eigene Arbeitskopie, nicht auf einen neuen Klon. ## Beiblatt: CLAUDE.md schlank halten Die Ausschlussregel „nichts Konventionslastiges" oben haengt an der Groesse von CLAUDE.md – je dicker die Datei, desto weniger laesst sich abgeben. Ein paste-fertiger Auftrag zum Verschlanken steht in **`claude-md-diaet.md`** (Download im Bereich `{adresse}/claude`, Abschnitt „Anleitung"). Er ist eigenstaendig – kein {marke}, keine Delegation – und wird ausdruecklich **nicht** delegiert: CLAUDE.md ist die Konvention selbst.deploy/claude_subagent/arbeitsbereich.sh1.8 KBaebe6730adbeupstream ↗
#!/bin/bash # ── Machbarkeitsprobe "Claude Subagent" ────────────────────────────────────── # Legt den Arbeitsbereich an. Treu zum Zielentwurf: # * Wegwerf-Klon unter /tmp -> der Lauf kann UNPRIVILEGIERT arbeiten # (sandbox.py: /tmp ist Lese- UND Schreibwurzel fuer Domain-Benutzer) # * Basis = origin/master -> NICHT /opt/jarvis, dessen git-HEAD ist alt # und die Arbeitskopie driftet per scp (CLAUDE.md) # # PROBE-ABKUERZUNG: die Rechte werden hier grob auf a+rwX gesetzt, damit sowohl # das filesystem-Werkzeug (laeuft als 'jarvis') als auch shell_execute (laeuft # als 'jarvis_sandbox') arbeiten koennen. Im Zielentwurf legt der Endpunkt den # Klon als Dienstbenutzer an - hier ist es Wegwerf-Material in tmpfs. set -u BASE=/tmp/csprobe WORK="$BASE/work" rm -rf "$BASE" mkdir -p "$BASE" echo "=== Klon anlegen (flach, origin/master) ===" if ! git clone --depth 1 https://github.com/dev-core-busy/jarvis.git "$WORK" 2>&1 | tail -3; then echo "FEHLER: clone gescheitert" exit 1 fi chmod -R a+rwX "$BASE" echo echo "=== Arbeitsbereich ===" echo "Pfad: $WORK" echo "HEAD: $(git -C "$WORK" rev-parse --short HEAD)" echo "Dateien: $(find "$WORK" -type f -not -path '*/.git/*' | wc -l)" echo "Groesse: $(du -sh --exclude=.git "$WORK" | cut -f1)" echo "tests/: $(ls "$WORK/tests" 2>/dev/null | wc -l) Dateien" echo echo "=== Basislauf der beiden Waechter (Sollwerte fuer die Probe) ===" cd "$WORK" || exit 1 export PYTHONDONTWRITEBYTECODE=1 echo -n "test_branding_aliase.py : " python3 tests/test_branding_aliase.py 2>&1 | grep -oE '[0-9]+ OK, [0-9]+ FAIL' | tail -1 echo -n "test_icon_semantik.js : " node tests/test_icon_semantik.js 2>&1 | grep -oE 'Ergebnis: [0-9]+/[0-9]+' | tail -1deploy/claude_subagent/aufgaben/t1_gegenprobe.txt1.2 KB2e3db29c4ea2upstream ↗
Du bist ein Coding-Agent. Dein Arbeitsbereich ist der Ordner /tmp/csprobe/work (ein vollstaendiger Klon des Jarvis-Repos). Arbeite AUSSCHLIESSLICH dort. Fasse /opt/jarvis nicht an. Nutze shell_execute und das filesystem-Werkzeug. AUFGABE (eine Gegenprobe, wie sie in diesem Projekt ueblich ist) Schritt 1: Fuehre aus cd /tmp/csprobe/work && node tests/test_icon_semantik.js Notiere die Schlusszeile, die so aussieht: "Ergebnis: N/M". Schritt 2: Oeffne frontend/js/tracks.js. Dort wird der Knopf zum LOESCHEN einer Ablage gezeichnet; die Beschriftung kommt aus JarvisIcons.trash(). Ersetze GENAU DIESEN EINEN Aufruf durch das Zeichen × (der Knopf soll also ein "×" als Beschriftung tragen statt des SVG). Aendere sonst nichts. Schritt 3: Fuehre den Test erneut aus und notiere wieder "Ergebnis: N/M". Schritt 4: Mache die Aenderung aus Schritt 2 exakt rueckgaengig und fuehre den Test ein drittes Mal aus. MELDE ZUM SCHLUSS GENAU DIES: 1. Die drei Ergebniszeilen aus Schritt 1, 3 und 4. 2. Wie viele Pruefungen im zweiten Lauf FEHLGESCHLAGEN sind (also M minus N). 3. Bestaetige, dass der dritte Lauf wieder dasselbe Ergebnis wie der erste hat. Arbeite vollstaendig autonom, ohne Rueckfragen.deploy/claude_subagent/aufgaben/t2_inventur.txt693 Bc7f378fbb870upstream ↗
Du bist ein Coding-Agent. Dein Arbeitsbereich ist der Ordner /tmp/csprobe/work (ein vollstaendiger Klon des Jarvis-Repos). Arbeite AUSSCHLIESSLICH dort. DIES IST EINE REINE LESE-AUFGABE. Aendere KEINE Datei. AUFGABE Finde jedes Vorkommen von window.confirm( in diesen beiden Ordnern: /tmp/csprobe/work/frontend/js/ /tmp/csprobe/work/frontend/addin/ MELDE ZUM SCHLUSS GENAU DIES: 1. Eine Liste, eine Zeile je Fundstelle, im Format <dateiname>:<zeilennummer> Nur der Dateiname, nicht der ganze Pfad. Sortiert nach Dateiname. 2. Die Gesamtzahl der Fundstellen. 3. Die Anzahl der verschiedenen Dateien, in denen es vorkommt. Arbeite vollstaendig autonom, ohne Rueckfragen.deploy/claude_subagent/aufgaben/t3_edit.txt1.2 KB1646835b92aeupstream ↗
Du bist ein Coding-Agent. Dein Arbeitsbereich ist der Ordner /tmp/csprobe/work (ein vollstaendiger Klon des Jarvis-Repos). Arbeite AUSSCHLIESSLICH dort. Fasse /opt/jarvis nicht an. Nutze shell_execute und das filesystem-Werkzeug. AUFGABE In frontend/css/chat.css gibt es einen :root-Block mit Alias-Variablen. Fuege dort diese neue Variable hinzu: --accent-soft: color-mix(in srgb, var(--accent) 20%, transparent); PRUEFUNG - DIESER SCHRITT IST PFLICHT Fuehre danach aus: cd /tmp/csprobe/work && python3 tests/test_branding_aliase.py Die Schlusszeile sieht so aus: "N OK, M FAIL". Der Test MUSS am Ende 0 FAIL melden. Meldet er einen FAIL, ist deine Aenderung UNVOLLSTAENDIG. Rate dann nicht herum, sondern lies tests/test_branding_aliase.py und die Fehlermeldung des Tests und behebe die Ursache. Wiederhole, bis der Test 0 FAIL meldet. MELDE ZUM SCHLUSS GENAU DIES: 1. Die Zeile "N OK, M FAIL" aus dem ERSTEN Testlauf. 2. Die Zeile "N OK, M FAIL" aus dem LETZTEN Testlauf. 3. Welche Dateien du geaendert hast (Dateiname und was du dort eingefuegt hast). 4. In EINEM Satz: warum der erste Testlauf fehlgeschlagen ist. Arbeite vollstaendig autonom, ohne Rueckfragen.deploy/claude_subagent/claude-md-diaet.md7.1 KB15fa8d412502upstream ↗
# CLAUDE.md auf Token-Diaet Beiblatt zum Delegations-Skill, **aber eigenstaendig**: dieser Auftrag braucht weder {marke} noch eine Delegation. Er laeuft in einer normalen Claude-Code-Sitzung in deinem Projekt. **Warum es sich lohnt:** CLAUDE.md geht in **jede** Anfrage **jeder** Sitzung. Eine Diaet zahlt sich dauerhaft aus, waehrend eine einzelne delegierte Aenderung einmal spart. Und sie erweitert den Zuschnitt der Delegation: die Ausschlussregel „nichts Konventionslastiges" haengt genau an der Groesse dieser Datei. **⚠ NICHT delegieren.** CLAUDE.md IST die Konvention. Ein kleines Modell soll nicht die Datei umschreiben, deren Regeln es selbst nicht zuverlaessig anwendet – und es gibt keinen mechanischen Riegel, der „richtig gekuerzt" beweisen koennte. --- ## Der Auftragstext (paste-fertig) Zwei Stellen anpassen: `<BUDGET>` (Zielmarke, siehe unten) und `<X>`/`<Y>` im letzten Absatz – dort zwei Themen einsetzen, die in **deiner** Datei wirklich stehen. Diese Stichprobe ist der einzige Beweis, dass nicht zu tief geschnitten wurde. > **Auftrag: CLAUDE.md auf Token-Diaet. Drei Phasen, nichts ohne meine Freigabe.** > > **Phase 0 – messen, nicht schaetzen.** Bevor du eine Zeile aenderst: > ```bash > python3 -c "z=open('CLAUDE.md',encoding='utf-8').read(); print(len(z),'Zeichen ~',round(len(z)/3.6),'Token')" > ``` > Dazu die Groesse je `##`-Abschnitt, absteigend, als Tabelle. Und sag mir, was > ueberhaupt pro Anfrage zahlt: CLAUDE.md, der `MEMORY.md`-Index und die > Skill-**Beschreibungen**. `.claude/settings*.json` (Berechtigungen, Hooks) > landet **nicht** im Modellkontext – dort ist nichts zu holen; nenne das, statt > daran zu kuerzen. Noch keine Aenderung. > > **Phase 1 – Plan vorlegen, nicht umsetzen.** Je Abschnitt eine Zeile: > heutige Groesse → Zielgroesse → was rausfliegt (Kategorie, kein Zitat). Dazu: > welche Lehren mehrfach dastehen und wohin sie **einmal zentral** wandern. > Zielmarke fuer die ganze Datei: **≤ <BUDGET> Token**. Dann warte auf mein OK. > > **Phase 2 – umsetzen, abschnittsweise.** Groesster Abschnitt zuerst, einer pro > Schritt. Nach jedem: neue Gesamtgroesse und in einem Satz, was gestrichen > wurde. Kein Ein-Schuss-Umschreiben der ganzen Datei – ich pruefe den > `git diff`, nicht die neue Fassung. > > **Der Behalte-Test entscheidet, nicht der Klang.** Fuer jeden Satz gilt: > *Wuerde ein Modell ohne diesen Satz denselben Fehler wieder machen?* > Ja → bleibt, gekuerzt auf **eine** Zeile, aber mit der Folge („X tun → Y > bricht"). Nein → weg. > Der Test „klingt allgemein" ist **verboten**: Saetze wie „nie `.index()` in > einer Pruefung" oder „eine Anzeige darf keinen Zustand behaupten" lesen sich > wie Best Practice und sind in Wahrheit bezahlte Vorfaelle. > > **Niemals streichen:** Messwerte und Grenzen (ohne den Server nicht > reproduzierbar) · ausdrueckliche Entscheidungen des Nutzers **samt verworfener > Alternativen** (sonst kommt der abgelehnte Vorschlag zurueck) · Ausrollstaende > („noch nicht ausgerollt" = offene Handlung) · exakte Befehle, Pfade, Datei- und > Feldnamen, Endpunkte · Sicherheits- und Rechte-Invarianten mit Begruendung. > > **Streichbar:** Baugeschichte fertiger Features (der Weg der Anlaeufe, nicht > das Ergebnis) · Verifikations-Absaetze („N Pruefungen, Gegenprobe greift, > md5-gleich") → auf den Testdateinamen eindampfen · mehrfach wiederholte Lehren > → einmal zentral plus Verweis · allgemeines Programmier-, Git- und > Sprachwissen, das ein Modell ohnehin hat. > > **Form:** Stichpunkte, ein Gedanke pro Zeile, Regel und Folge in derselben > Zeile. **Ueberschriften bleiben unveraendert** – Memories und Code-Kommentare > verweisen darauf. Lege **kein Archiv** an: der alte Text steht in der > Git-Historie. > > **Abschluss:** `git diff --stat CLAUDE.md`, die **gemessene** Ersparnis in > Zeichen und Token, und beantworte drei Stichproben ausschliesslich aus der > gekuerzten Datei: Wie wird deployt? Wie heisst der Testlauf fuer `<X>`? Was ist > die Falle bei `<Y>`? Findet die neue Fassung darauf keine Antwort, war der > Schnitt zu tief – dann sag es, statt es zu kaschieren. --- ## Warum nicht die kurze Fassung Die verbreitete Kurzfassung lautet: „loesche alles, was ein modernes LLM ohnehin weiss, schreib den Rest als Stichpunkte, zeig mir den Entwurf und schaetze die Ersparnis." Fuenf Punkte daran kosten mehr, als sie sparen. 1. **Sofort-Umschreiben statt Phasen.** Ein Entwurf ueber die ganze Datei ist bei sechsstelliger Token-Zahl nicht pruefbar, und ein still gestrichener Satz faellt erst auf, wenn der Fehler wiederkommt. Pruefstueck ist der `diff` – die neue Fassung liest sich immer gut. 2. **„Das weiss ein LLM ohnehin" ist der gefaehrlichste Filter.** Er trifft genau die Saetze, die aus Vorfaellen stammen: | Sieht aus wie Standard | Ist in Wahrheit | |---|---| | „nie `.index()` in einer Pruefung" | ein Waechter, der abbrach statt fehlzuschlagen – und dadurch als bestanden galt | | „eine Anzeige darf keinen Zustand behaupten" | drei Anzeigen, die einen Zustand behaupteten, den sie nicht kannten – je Fall Stunden Fehlersuche | | „Kommentare vor dem Vergleich entfernen" | Waechter, die ihre eigene Begruendung lasen und deshalb nichts prueften | | „`asyncio.wait_for` bricht nicht ab" | 20-Sekunden-Freeze fuer ALLE Benutzer, live nachgemessen | Deshalb der Behalte-Test: nicht „klingt allgemein", sondern „passiert es ohne den Satz wieder". 3. **„Radikal" ist keine Vorgabe.** Eine Zahl ist eine. 4. **„Geschaetzte" Ersparnis** – bei einer Datei, deren Groesse ein Einzeiler ausrechnet. Messen, vorher und nachher. 5. **Falscher Scope.** `.claude/settings*.json` kostet **kein** Token pro Anfrage; die Skill-*Beschreibungen* und der `MEMORY.md`-Index dagegen schon. Ein Schnitt an den Berechtigungen spart nichts und erzeugt Zugriffsfehler. Nicht Teil des Auftrags, aber fuer die Sitzung: die Diaet **nicht** mit Feature-Arbeit mischen (die Datei ist die Grundlage genau dieser Arbeit), und danach die Memory-Dateien gegen die gekuerzte Fassung pruefen – Verweise auf gestrichene Abschnitte zeigen sonst ins Leere. --- ## Zielmarke und eigene Fettstellen finden `<BUDGET>` herleiten statt raten: **Zahl der `##`-Abschnitte × ~3.000 Zeichen**, das Ergebnis durch 3,6 (Deutsch) bzw. 4 (Englisch). Drei Befehle, die die Kandidaten zeigen: ```bash # 1. Die groessten Abschnitte - dort liegt fast immer die Haelfte python3 - <<'EOF' import re z=open("CLAUDE.md",encoding="utf-8").read() t=re.split(r"(?m)^(## .*)$", z) p=sorted(((t[i].strip(),len(t[i+1])) for i in range(1,len(t),2)), key=lambda x:-x[1]) print(len(z),"Zeichen ~",round(len(z)/3.6),"Token |",len(p),"Abschnitte") for name,n in p[:10]: print(f"{n:7d} {name[:70]}") EOF # 2. Verifikations-Absaetze: oft ein Zehntel der Datei, Archiv nach dem Rollout grep -cE "^[-*] \*\*(Verifiziert|Live)" CLAUDE.md # 3. Mehrfach erzaehlte Lehren: einmal zentral, danach Verweis grep -oE "Merkregel|FALLSTRICK" CLAUDE.md | sort | uniq -c ``` Erfahrungswert aus einem gewachsenen Projekt: die drei groessten Abschnitte machten 22 % aus, die Verifikations-Absaetze 11 %, und einzelne Lehren standen fuenfmal wortgleich in verschiedenen Abschnitten.deploy/claude_subagent/delegiere.py16 KBacb0175e2041upstream ↗
#!/usr/bin/env python3 """Client fuer den Jarvis-Skill "Claude Subagent". Gibt eine eng umrissene Codeaufgabe an Jarvis ab und holt das Ergebnis als PATCH zurueck. Der Patch wird NICHT automatisch angewandt – das entscheidet Claude nach dem Lesen. ZUGANG – je Jarvis-Installation zu setzen, es gibt KEINE Vorgabe Schluessel <MARKE>_CSA_KEY oder ~/.<marke>-csa-key Adresse <MARKE>_CSA_URL oder ~/.<marke>-csa-url <MARKE> = Name des Assistenten aus dem Branding (z.B. NEXI/.nexi-). Bewusst KEIN voreingestellter Host: derselbe Client laeuft gegen jede Jarvis-Installation. Eine Vorgabe waere die Adresse genau einer davon – bei der naechsten falsch, und der Fehler saehe wie ein Schluesselproblem aus (ein fremder Server kennt den Schluessel nicht und antwortet 401). Der Schluessel gehoert NICHT ins Repo. ~/.<marke>-csa-key liegt ausserhalb, die Umgebungsvariable erst recht. AUFRUF delegiere.py senden --spec-datei auftrag.txt \\ --dateien frontend/css/chat.css \\ --riegel tests/test_branding_aliase.py delegiere.py holen <id> delegiere.py warten <id> # bis fertig, dann Patch auf stdout Die Basis (Commit-Hash) wird aus dem lokalen Repo ermittelt; der Client bricht ab, wenn der Arbeitsbaum an den Zieldateien schmutzig ist – ein Patch gegen einen anderen Stand liesse sich nachher nicht sauber anwenden. """ import argparse import json import os import ssl import subprocess import sys import time import urllib.error import urllib.request from pathlib import Path def fehler(text: str, code: int = 1): print(f"FEHLER: {text}", file=sys.stderr) sys.exit(code) def _aus_umgebung_oder_datei(endung: str, was: str) -> str: """Sucht `<MARKE>_CSA_<ENDUNG>` bzw. `~/.<marke>-csa-<endung>`. Der MARKENNAME steckt in beiden Namen – so steht in der Anleitung der Name des Assistenten und nicht "Jarvis". Der Client kann die Marke aber nicht kennen (sie liegt auf dem Server), deshalb wird nach dem MUSTER gesucht statt nach einem festen Namen. ⚠ MEHRERE TREFFER SIND EIN FEHLER, KEINE AUSWAHL (gemessen 2026-08-30). Wer neben einem bestehenden Zugang einen zweiten hinterlegt, bekam bis dahin weiter den ALTEN: die Liste war alphabetisch sortiert und der erste nicht leere Treffer gewann – `.jarvis-csa-key` steht vor `.fabrikam-csa-key`. Der neue Schluessel lag daneben und tat NICHTS, ohne eine einzige Meldung. Schlimmer ist die halbe Wahl: Schluessel und Adresse werden getrennt ermittelt, ein Zugang koennte also den Schluessel des einen Servers an den anderen schicken – der antwortet 401, und das sieht wie ein kaputter Schluessel aus statt wie eine falsche Adresse. Deshalb fail-closed mit Klartext, der beide Wege aus der Zwickmuehle nennt. """ end = endung.upper() aus_env = sorted(n for n, w in os.environ.items() if n.upper().endswith("_CSA_" + end) and w.strip()) if len(aus_env) > 1: fehler(f"Mehrere Umgebungsvariablen fuer {was}: {', '.join(aus_env)}. " f"Es ist nicht erkennbar, welche Installation gemeint ist – " f"setze genau eine.", 2) if aus_env: return os.environ[aus_env[0]].strip() treffer = [p for p in sorted(Path.home().glob(".*-csa-" + endung.lower())) if p.read_text(encoding="utf-8").strip()] if len(treffer) > 1: namen = ", ".join("~/" + p.name for p in treffer) fehler(f"Mehrere Zugaenge fuer {was} hinterlegt: {namen}. Es ist nicht " f"erkennbar, welche Installation gemeint ist. Benenne die nicht " f"gewuenschte um (ein Name, der nicht auf '-csa-{endung.lower()}' " f"endet, wird nicht mehr gefunden) oder waehle die gewuenschte " f"per Umgebungsvariable <MARKE>_CSA_{end}.", 2) return treffer[0].read_text(encoding="utf-8").strip() if treffer else "" def schluessel() -> str: k = _aus_umgebung_oder_datei("key", "Schluessel") if k: return k fehler("Kein Delegations-Schluessel. Setze <MARKE>_CSA_KEY oder lege " "~/.<marke>-csa-key an – <MARKE> ist der Name des Assistenten aus " "dem Branding (steht im Bereich /claude in der Anleitung).", 2) def basis_url() -> str: u = _aus_umgebung_oder_datei("url", "Adresse") if not u: fehler("Keine Server-Adresse. Setze <MARKE>_CSA_URL oder lege " "~/.<marke>-csa-url an – <MARKE> ist der Name des Assistenten " "aus dem Branding (steht im Bereich /claude in der Anleitung). " "Es gibt bewusst keine Vorgabe: der Client laeuft gegen jede " "Installation.", 2) if not u.startswith(("http://", "https://")): u = "https://" + u return u.rstrip("/") def _ctx() -> ssl.SSLContext: """Jarvis benutzt ein selbst ausgestelltes Zertifikat (backend/security.py). Die Pruefung ist deshalb aus. Das ist hier vertretbar, weil der Schluessel nur zu DIESEM Server passt und ueber ihn keine fremden Daten laufen – aber es ist eine bewusste Ausnahme, kein Versehen. """ c = ssl.create_default_context() c.check_hostname = False c.verify_mode = ssl.CERT_NONE return c def ruf(pfad: str, methode: str = "GET", rumpf: dict | None = None) -> dict: daten = json.dumps(rumpf).encode("utf-8") if rumpf is not None else None req = urllib.request.Request(basis_url() + pfad, data=daten, method=methode) req.add_header("X-Jarvis-Key", schluessel()) if daten: req.add_header("Content-Type", "application/json") try: with urllib.request.urlopen(req, timeout=60, context=_ctx()) as r: return json.loads(r.read().decode("utf-8")) except urllib.error.HTTPError as e: try: return json.loads(e.read().decode("utf-8")) except Exception: # noqa: BLE001 return {"ok": False, "error": f"HTTP {e.code}"} except Exception as e: # noqa: BLE001 fehler(f"{type(e).__name__}: {e}") def git(*args) -> str: p = subprocess.run(["git", *args], capture_output=True, text=True) return (p.stdout or "").strip() def git_ok(*args) -> bool: """Nur der Exitcode zaehlt (fuer Existenzfragen wie `cat-file -e`).""" return subprocess.run(["git", *args], capture_output=True, text=True).returncode == 0 def pruefe_riegel(riegel: str) -> None: """Der Riegel muss im GEPUSHTEN Stand liegen, nicht nur im Arbeitsbaum. DAS HAT EINEN LAUF GEKOSTET (2026-08-25): ein frisch geschriebener, noch nicht committeter Waechter existiert im Klon des Servers nicht. Der Lauf laeuft trotzdem an, der Agent arbeitet, und erst die Bewertung meldet "Riegel existiert im Arbeitsbereich nicht" – Ergebnis: kein Patch, und nach der Abbruchregel macht man die Aufgabe danach selbst. Die Vorbedingung gehoert VOR den Lauf. Zweiter Fall, subtiler: der Riegel ist committet, aber lokal GEAENDERT. Dann prueft der Server die alte Fassung – und ein gruener Riegel beweist etwas anderes als das, was man gerade geschrieben hat. """ if not riegel: return if not git_ok("cat-file", "-e", f"origin/master:{riegel}"): fehler(f"Der Riegel '{riegel}' liegt nicht in origin/master. Der Server " f"klont von dort und findet ihn nicht – der Lauf wuerde ohne " f"Patch enden. Committe und pushe ihn zuerst.") stand = git("status", "--porcelain", "--", riegel).strip() if stand: fehler(f"Der Riegel '{riegel}' ist lokal geaendert, aber nicht gepusht. " f"Geprueft wuerde die Fassung aus origin/master – ein gruener " f"Riegel bewiese dann etwas anderes als das, was du geschrieben " f"hast. Pushe die Aenderung zuerst.") def pruefe_arbeitsbaum(dateien: list) -> str: """Basis-Commit ermitteln und sicherstellen, dass der Patch spaeter passt.""" kopf = git("rev-parse", "HEAD") if not kopf: fehler("Kein git-Repository im aktuellen Verzeichnis.") # Liegt der lokale Stand auf origin/master? Der Server klont von dort. vor = git("rev-list", "--count", "origin/master..HEAD") if vor and vor != "0": fehler(f"Der lokale Stand liegt {vor} Commit(s) VOR origin/master. " f"Jarvis klont origin/master – pushe zuerst, oder delegiere nicht.") schmutzig = [z[3:] for z in git("status", "--porcelain").splitlines()] kollision = [d for d in dateien if any(s.strip() == d for s in schmutzig)] if kollision: fehler("Diese Zieldateien haben lokale Aenderungen – der Patch liesse " "sich nachher nicht sauber anwenden: " + ", ".join(kollision)) return kopf def cmd_senden(a) -> None: spec = Path(a.spec_datei).read_text(encoding="utf-8") if a.spec_datei else a.spec if not spec or not spec.strip(): fehler("Kein Auftragstext (--spec oder --spec-datei).") dateien = [x.strip() for x in a.dateien.split(",") if x.strip()] if not dateien: fehler("--dateien fehlt: nenne die Dateien, die geaendert werden duerfen.") pruefe_riegel(a.riegel) basis = a.basis or pruefe_arbeitsbaum(dateien) antwort = ruf("/api/claude/jobs", "POST", { "spec": spec, "basis": basis, "dateien": dateien, "riegel": a.riegel, }) if not antwort.get("ok"): fehler(antwort.get("error", "unbekannt")) print(antwort["id"]) def _bericht(job: dict) -> int: """Ergebnis ausgeben. Rueckgabe = Exitcode (0 nur bei angenommenem Patch).""" erg = job.get("ergebnis") or {} print(f"# Auftrag {job.get('id')} – {job.get('status')}", file=sys.stderr) if job.get("fehler"): print(f"# Fehler: {job['fehler']}", file=sys.stderr) return 1 if not erg: return 1 print(f"# Riegel {erg.get('riegel')}: " f"{'GRUEN' if erg.get('riegel_ok') else 'ROT'}", file=sys.stderr) print(f"# Dateien: {', '.join(erg.get('dateien') or []) or '(keine)'}", file=sys.stderr) if not erg.get("angenommen"): print("# VERWORFEN:", file=sys.stderr) for g in erg.get("gruende") or []: print(f"# - {g}", file=sys.stderr) aus = (erg.get("riegel_ausgabe") or "").strip() if aus: # ⚠ HIER STANDEN EINMAL NUR DIE LETZTEN 15 ZEILEN – und die # fehlgeschlagenen Pruefungen stehen fast nie am Ende. Am 2026-08-31 # zeigte der Bericht ausschliesslich gruene Haken, waehrend unten # "12 OK, 2 FAIL" stand: die zwei ✗-Zeilen lagen in Abschnitt 2 und # waren abgeschnitten. Die Ursache war danach nur durch Nachstellen # des Laufs zu finden – eine halbe Stunde fuer eine Auskunft, die # der Bericht haette geben koennen. # # Deshalb ZUERST die Fehlzeilen, dann der Schluss. Erkannt an den # ueblichen Markierungen der Waechter dieses Projekts (✗, FAIL, # ✗ mit Farbcode davor) – reicht keine, bleibt es beim Ende. zeilen = aus.splitlines() schlecht = [z for z in zeilen if "✗" in z or "FAIL " in z or z.strip().startswith("FAIL")] if schlecht: print(f"# Riegel-Ausgabe – FEHLGESCHLAGENE Pruefungen " f"({len(schlecht)}):", file=sys.stderr) for z in schlecht[:25]: print(f"# {z}", file=sys.stderr) if len(schlecht) > 25: print(f"# … und {len(schlecht) - 25} weitere", file=sys.stderr) print("# Riegel-Ausgabe (Schluss):", file=sys.stderr) for z in zeilen[-5:]: print(f"# {z}", file=sys.stderr) else: print("# Riegel-Ausgabe (letzte Zeilen):", file=sys.stderr) for z in zeilen[-15:]: print(f"# {z}", file=sys.stderr) return 1 print("# ANGENOMMEN – Patch folgt auf stdout", file=sys.stderr) print(erg.get("diff") or "") return 0 def cmd_holen(a) -> None: antwort = ruf(f"/api/claude/jobs/{a.id}") if not antwort.get("ok"): fehler(antwort.get("error", "unbekannt")) sys.exit(_bericht(antwort["job"])) def cmd_warten(a) -> None: ende = time.time() + a.timeout while time.time() < ende: antwort = ruf(f"/api/claude/jobs/{a.id}") if not antwort.get("ok"): fehler(antwort.get("error", "unbekannt")) job = antwort["job"] if job.get("status") in ("fertig", "fehler"): sys.exit(_bericht(job)) time.sleep(a.takt) fehler(f"Auftrag {a.id} ist nach {a.timeout}s noch nicht fertig.") def cmd_bericht(a) -> None: """Was die Delegation gekostet und gespart hat – aus GEMESSENEN Zeichen. Die Rechnung steht im Kopf von ``backend/claude_subagent.py``: ohne Delegation ~ Quelldateien lesen + Patch schreiben mit Delegation ~ Auftrag schreiben + Patch lesen Ersparnis ~ Quelle - Auftrag Der Patch faellt heraus, er geht in beiden Faellen durch Claude. Ein ABGELEHNTER Auftrag ist ein Kostenpunkt, kein Nullwert: die Spezifikation wurde geschrieben und die Aufgabe danach selbst gemacht. Er zaehlt deshalb mit NEGATIVEM Beitrag. """ antwort = ruf("/api/claude/jobs") jobs = antwort.get("jobs") or [] zjt = float(antwort.get("zeichen_je_token") or 3.6) if not jobs: print("Noch kein Auftrag abgegeben – es gibt nichts zu berichten.") return print(f"{'Zeit':<12} {'Kennung':<13} {'St':<3} {'Dat':>4} " f"{'Auftrag':>9} {'Quelle':>9} {'Patch':>8} {'Bilanz':>9} Riegel") print("-" * 100) sp = qu = pa = 0 ang = abg = 0 for j in jobs[::-1]: m = j.get("messwerte") or {} if not m: continue # Altbestand vor der Buchhaltung ok = bool(m.get("angenommen")) # Bei Ablehnung ist die Quelle NICHT gespart – die Arbeit fiel trotzdem an. bilanz = (m.get("quelle_zeichen", 0) if ok else 0) - m.get("spec_zeichen", 0) sp += m.get("spec_zeichen", 0) qu += m.get("quelle_zeichen", 0) if ok else 0 pa += m.get("patch_zeichen", 0) ang += 1 if ok else 0 abg += 0 if ok else 1 zeit = time.strftime("%d.%m %H:%M", time.localtime(j.get("erstellt", 0))) riegel = j.get("riegel") riegel = riegel if isinstance(riegel, str) else ",".join(riegel or []) print(f"{zeit:<12} {j.get('id',''):<13} {'OK ' if ok else 'ABL':<3} " f"{m.get('dateien_anzahl',0):>4} " f"{m.get('spec_zeichen',0):>9,} {m.get('quelle_zeichen',0):>9,} " f"{m.get('patch_zeichen',0):>8,} {bilanz:>+9,} {riegel.split('/')[-1]}") bilanz = qu - sp print("-" * 100) print(f"{ang + abg} Auftraege: {ang} angenommen, {abg} abgelehnt") print(f"Auftragstexte (gezahlt): {sp:>12,} Zeichen ~{sp/zjt:>10,.0f} Token") print(f"Quelldateien (nicht gelesen): {qu:>12,} Zeichen ~{qu/zjt:>10,.0f} Token") print(f"Patches (in beiden Faellen): {pa:>12,} Zeichen ~{pa/zjt:>10,.0f} Token") print(f"BILANZ: {bilanz:>+12,} Zeichen ~{bilanz/zjt:>+10,.0f} Token") print() print("Gemessen sind die ZEICHEN; die Token sind daraus geschaetzt " f"({zjt} Zeichen/Token).") print("VORBEHALT: die Ersparnis gilt nur, soweit die Dateien vorher NICHT " "gelesen wurden.") print("Wer erst lesen muss, um den Auftrag zu schreiben, hat sie schon " "ausgegeben.") def main() -> None: p = argparse.ArgumentParser(description="Codeaufgabe an Jarvis abgeben") sub = p.add_subparsers(dest="cmd", required=True) s = sub.add_parser("senden") s.add_argument("--spec") s.add_argument("--spec-datei") s.add_argument("--dateien", required=True, help="kommagetrennt, relativ zum Repo") s.add_argument("--riegel", required=True, help="Testdatei, die das Ergebnis beweist (tests/*.py|js)") s.add_argument("--basis", help="Commit-Hash (Vorgabe: HEAD des Arbeitsbaums)") s.set_defaults(fn=cmd_senden) h = sub.add_parser("holen") h.add_argument("id") h.set_defaults(fn=cmd_holen) w = sub.add_parser("warten") w.add_argument("id") w.add_argument("--timeout", type=int, default=900) w.add_argument("--takt", type=int, default=10) w.set_defaults(fn=cmd_warten) b = sub.add_parser("bericht", help="Kosten und Ersparnis aller Auftraege") b.set_defaults(fn=cmd_bericht) a = p.parse_args() a.fn(a) if __name__ == "__main__": main()deploy/claude_subagent/probelauf.py2.4 KB9d7ddb35cffeupstream ↗
#!/opt/jarvis/venv/bin/python """Machbarkeitsprobe "Claude Subagent" - treibt EINEN Agentenlauf an. Bewusst IN-PROCESS statt ueber ``POST /api/agent/task``: jener Endpunkt wrappt den Auftragstext mit einem Benachrichtigungs-Text ("Reagiere angemessen auf die Benachrichtigung, z.B. Begruessung, Bestaetigung"). Fuer eine Coding-Aufgabe ist das ein Stoerfaktor - die Probe wuerde die Untauglichkeit DIESES Endpunkts messen statt der Faehigkeit des Modells. Der Zielentwurf bekommt ohnehin einen eigenen Endpunkt ohne Wrapper. Der Lauf ist UNPRIVILEGIERT (``privileged=False``) - genau wie im Zielentwurf. Damit gilt fuer ihn das volle Pfad-Confinement: Schreiben nur /tmp und data/documents, Lesen nur /tmp + Wissensverzeichnisse. Der Arbeitsbereich liegt unter /tmp/csprobe/work, ist also erreichbar - /opt/jarvis dagegen NICHT. Aufruf: cs_run.py <aufgabendatei> """ import asyncio import hashlib import os import pathlib import sys import time os.environ.setdefault("PYTHONDONTWRITEBYTECODE", "1") sys.path.insert(0, "/opt/jarvis") os.chdir("/opt/jarvis") SETTINGS = pathlib.Path("/opt/jarvis/data/settings.json") def md5(p: pathlib.Path) -> str: """Fingerabdruck der Live-Konfiguration - Schutz gegen ungewollte Migration.""" try: return hashlib.md5(p.read_bytes()).hexdigest() except Exception: return "-" _vorher = md5(SETTINGS) from backend.agent import JarvisAgent # noqa: E402 (erst nach dem Fingerabdruck) async def main() -> None: aufgabe = pathlib.Path(sys.argv[1]).read_text(encoding="utf-8") agent = JarvisAgent() print(f"[probe] Werkzeuge im Kasten: {len(agent.tools_map)}", flush=True) print(f"[probe] Auftragslaenge: {len(aufgabe)} Zeichen", flush=True) t0 = time.monotonic() try: ergebnis = await agent.run_task_headless( aufgabe, actor={"user": "api:claude-subagent-probe", "privileged": False}, ) except Exception as e: # Ausnahme ist ein Messergebnis, kein Abbruchgrund ergebnis = f"(AUSNAHME) {type(e).__name__}: {e}" dauer = time.monotonic() - t0 print(f"[probe] DAUER_S {dauer:.1f}", flush=True) print("[probe] ===ERGEBNIS===", flush=True) print(ergebnis or "(leere Antwort)", flush=True) print("[probe] ===ENDE===", flush=True) asyncio.run(main()) _nachher = md5(SETTINGS) print(f"[probe] settings.json: {'UNVERAENDERT' if _vorher == _nachher else '!!! GEAENDERT !!!'}" f" ({_vorher[:8]} -> {_nachher[:8]})", flush=True)README.mdupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
Plain-text copy, no login: /skill-bundles/dev-core-busy-jarvis-deploy-claude-subagent.md