# code-delegate

Adopt this skill: https://proskills.md/skills/other/dev-core-busy-jarvis-deploy-claude-subagent

Page: https://proskills.md/skills/other/dev-core-busy-jarvis-deploy-claude-subagent
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: deploy/claude_subagent/SKILL.md
size: 5490
sha: 0c9da2245ec0366c86ec8c4d9e11b073ec1f4bc0
upstream: https://github.com/dev-core-busy/jarvis/blob/master/deploy/claude_subagent/SKILL.md

````text
---
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.
````

## File: deploy/claude_subagent/arbeitsbereich.sh
size: 1811
sha: aebe6730adbe72699f9a46763b79d22767299d3c
upstream: https://github.com/dev-core-busy/jarvis/blob/master/deploy/claude_subagent/arbeitsbereich.sh

```text
#!/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 -1
```

## File: deploy/claude_subagent/aufgaben/t1_gegenprobe.txt
size: 1207
sha: 2e3db29c4ea20f2d2048be45d985c480f78c9c83
upstream: https://github.com/dev-core-busy/jarvis/blob/master/deploy/claude_subagent/aufgaben/t1_gegenprobe.txt

```text
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.
```

## File: deploy/claude_subagent/aufgaben/t2_inventur.txt
size: 693
sha: c7f378fbb87043030a29fb317f871df644e11a59
upstream: https://github.com/dev-core-busy/jarvis/blob/master/deploy/claude_subagent/aufgaben/t2_inventur.txt

```text
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.
```

## File: deploy/claude_subagent/aufgaben/t3_edit.txt
size: 1183
sha: 1646835b92aee2c476758a3dbb41a4db1d05e196
upstream: https://github.com/dev-core-busy/jarvis/blob/master/deploy/claude_subagent/aufgaben/t3_edit.txt

```text
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.
```

## File: deploy/claude_subagent/claude-md-diaet.md
size: 7285
sha: 15fa8d412502f09d0fc5c7bbc0ce8ad42e0c1d32
upstream: https://github.com/dev-core-busy/jarvis/blob/master/deploy/claude_subagent/claude-md-diaet.md

````text
# 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.
````

## File: deploy/claude_subagent/delegiere.py
size: 16828
sha: acb0175e20418db4cffa9e052eaf5435e3cdb4ec
upstream: https://github.com/dev-core-busy/jarvis/blob/master/deploy/claude_subagent/delegiere.py

```text
#!/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()
```

## File: deploy/claude_subagent/probelauf.py
size: 2495
sha: 9d7ddb35cffe435d045c6d83da4e7d88fb91aab0
upstream: https://github.com/dev-core-busy/jarvis/blob/master/deploy/claude_subagent/probelauf.py

```text
#!/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)
```

## File: README.md
upstream: https://github.com/dev-core-busy/jarvis/blob/master/README.md

````text
<div align="center">

# 🤖 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.**

[![Python](https://img.shields.io/badge/Python-3.13-blue?logo=python&logoColor=white)](https://www.python.org/)
[![AI Mouse](https://img.shields.io/badge/NEW-AI_Mouse_for_Windows-06b6d4)](#ai-mouse)
[![BSI](https://img.shields.io/badge/Security-hardened_to_BSI_requirements-10b981)](#bsi)
[![License](https://img.shields.io/badge/License-Elastic_2.0-blue)](LICENSE)
[![Version](https://img.shields.io/badge/Version-1.0.0-orange)](https://github.com/dev-core-busy/jarvis/releases)
[![Platform](https://img.shields.io/badge/Platform-Linux-lightgrey?logo=linux)](https://www.linux.org/)
[![PRs Welcome](https://img.shields.io/badge/PRs-Welcome-brightgreen)](https://github.com/dev-core-busy/jarvis/pulls)
[![OpenClaw Compatible](https://img.shields.io/badge/OpenClaw-Compatible-6366f1)](https://github.com/dev-core-busy/jarvis#openclaw-skill-ecosystem)

*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](#ai-mouse)

### 🛡️ 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](#bsi)

[**Live Demo**](https://jarvis-ai.info) · [**Report Bug**](https://github.com/dev-core-busy/jarvis/issues) · [**Request Feature**](https://github.com/dev-core-busy/jarvis/issues) · [**Contribute**](#contributing)

---

![Jarvis portal — role-based hub for chat, support and admin tools](docs/screenshots/portal.png)

</div>

---

<a id="ai-mouse"></a>

## 🖱️ 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.

<sub>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).</sub>

---

<a id="bsi"></a>

## 🛡️ 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.

<sub>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`.</sub>

---

## 📋 Table of Contents

- [AI Mouse — ask your screen](#ai-mouse)
- [Security hardened to BSI requirements](#bsi)
- [Overview](#overview)
- [Screenshots](#screenshots)
- [Key Features](#key-features)
- [Architecture](#architecture)
- [Tech Stack](#tech-stack)
- [Installation](#installation)
- [Configuration](#configuration)
- [Multi-User Chat](#multi-user-chat)
- [Multi-Agent System](#multi-agent-system)
- [Skill System](#skill-system)
- [Email Automation & Outlook Add-in](#email-automation--outlook-add-in)
- [SAP Analysis Area](#sap-analysis-area)
- [Short Tracks](#short-tracks)
- [WhatsApp Integration](#whatsapp-integration)
- [Knowledge Base](#knowledge-base)
- [Vision & Face Recognition](#vision--face-recognition)
- [AD/LDAP & Security](#adldap--security)
- [Multimedia Attachments](#multimedia-attachments)
- [Feedback & Self-Improvement](#feedback--self-improvement)
- [Cognitive Evolution](#cognitive-evolution)
- [Client Apps](#client-apps)
- [API Reference](#api-reference)
- [Contributing](#contributing)
- [Third-Party Licenses](#third-party-licenses)
- [License](#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
````
