⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

version unknown

code-delegate

dev-core-busy@dev-core-busy⭐ 5 stars· last commit 3d ago· 1 open issues

>-

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.

—/10

// RATINGS

⭐GitHub Stars
⭐ 5 on GitHubGitHub ↗

New / niche

🟢ProSkills Score
—
📍

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.

Python AI Mouse BSI License Version Platform PRs Welcome OpenClaw Compatible

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


Jarvis portal — role-based hub for chat, support and admin tools


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

1234
Hold the right mouse button over any windowDrag a frame around what you are asking about — a normal right-click still worksPick a question from your list (“read the text”, “explain this error”, “translate” …) or type your ownRead 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.

34measures implemented (3 critical, 13 high, 12 medium, 6 low findings)
34automated 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


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 -1
    
  • deploy/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

// REPO STATS

5 stars
1 open issues
Last commit: 3d ago