Automatischer Push: 46 Datei(en) geändert

- .claude/agents/planer.md - .claude/skills/plan-executer-pruefung/SKILL.md - .claude/workflows/plankritik.js - .claude/workflows/planung.js - .claude/workflows/pruefung.js - .claude/workflows/verbrauch.js - .claude/workflows/welle-mit-pruefung.js - .vault-tools/plan-kopie/LIESMICH.md - .vault-tools/plan-kopie/plan_zeichen.py - .vault-tools/plan-kopie/rot_nachweis.py - .vault-tools/trading-plattform-pruefung/LIESMICH.md - .vault-tools/trading-plattform-pruefung/abendkontrolle.py - … und 34 weitere Erzeugt vom PostToolUse-Hook .vault-tools/auto-push/auto_push.py. Co-Authored-By: Claude Opus 5 <[email protected]>
2026-09-25 04:00:02 +02:00
1 parent 67d674cd0b
commit ea278dc24f
@@ -0,0 +1,139 @@
+---
+type: plan-task
+title: "Task 04 — pruefung.js: Verbrauch vor und nach dem pruefer mitschreiben"
+status: draft
+summary: "Die Prüfung liest vor und nach dem pruefer den Planverbrauch ab, nur zum Messen; verbrauch false schaltet das ab, wenn der Elternworkflow selbst liest."
+tags: [plan-task, vault-tools, codeworkflow]
+created: 2026-09-24
+updated: 2026-09-24
+modell: haiku
+modell_begruendung: "Abschrift: jede Zeile steht wörtlich im Plan, Zieldateien und Verbote sind genannt, kein Codeblock trägt typografische Anführungszeichen, Striche, Auslassungspunkte oder das Zeichen ·."
+---
+
+# Task 04 — pruefung.js: Verbrauch vor und nach dem pruefer mitschreiben
+
+Die globalen Vorgaben stehen in `00-uebersicht.md` (Abschnitt „Globale Vorgaben“). Arbeitsverzeichnis ist der Vault-Wurzelordner `D:/Claude`; alle Pfade gelten von dort.
+
+Was danach anders ist:
+
+- **Zwei Ablesungen um den pruefer**, `wunsch: 0`, also Messung ohne Bremse. Das Ergebnis trägt `verbrauch`.
+- **Als Kind** kann `pruefung` keinen weiteren Workflow aufrufen; ohne `verbrauch: false` stehen die Ablesungen dann als `nicht_gelesen` da, die Prüfung läuft trotzdem.
+
+## Zieldateien
+
+- `.claude/workflows/pruefung.js` (geändert)
+
+## Verbote
+
+- Keine andere Datei, auch nicht die übrigen Workflows unter `.claude/workflows/` und nichts unter `AI/Regelwerk/`, `.claude/agents/` oder `CLAUDE.md`.
+- Kein Commit, kein Push, kein Lauf eines echten Workflows.
+- Kein Umformulieren, auch nicht von Kommentaren oder Sonderzeichen; ein Widerspruch zwischen Plan und Baum wird gemeldet.
+
+## Umsetzung
+
+### `.claude/workflows/pruefung.js`
+
+Die ganze Datei ist neu (sie ersetzt die bisherige Fassung vollständig):
+
+```javascript
+export const meta = {
+  name: 'pruefung',
+  description: 'Lässt eine fertige Welle vom pruefer mit dem vollen Pflichtprogramm gegen Plan und Zielumgebung prüfen; kritische Änderungen mit xhigh; schreibt den Planverbrauch vor und nach der Prüfung mit',
+  whenToUse: 'Schritt 4 der Standardschleife nach einer Welle, zusätzlich zur eigenen Gegenprüfung des Koordinators (AI/Regelwerk/codeworkflow.md). Args: {projekt, plan, tasks?, suite?, version?, kritisch?, abschluss?, schwerpunkt?, effort?, verbrauch?}. kritisch für sicherheits- oder datenrelevante Änderungen; abschluss fragt, ob eine weitere Runde noch Substanz hat; verbrauch: false schaltet die Ablesung ab, welle-mit-pruefung liest dann selbst.',
+  phases: [{ title: 'Prüfung', detail: 'ein pruefer' }],
+}
+
+// Rollenparameter: model wird immer gesetzt (Stamm). Der Effort kommt aus dem Frontmatter
+// von .claude/agents/pruefer.md (high). kritisch hebt auf xhigh: In der Messung vom
+// 2026-09-23 fuhr nur xhigh einen großen eigenen Datenlauf (codeworkflow.md, "Effort je Rolle").
+// Verbrauch: Vor und nach dem pruefer liest verbrauch.js den Planverbrauch ab, nur zum Messen
+// (wunsch 0); gebremst wird hier nicht. Als Kind von welle-mit-pruefung kann dieser Workflow
+// keinen weiteren aufrufen; dort liest der Elternworkflow und gibt verbrauch: false mit.
+const EFFORTS = ['low', 'medium', 'high', 'xhigh', 'max']
+const VERBRAUCH = 'D:/Claude/.claude/workflows/verbrauch.js'
+
+const BERICHT = {
+  type: 'object',
+  properties: {
+    selbst_ausgefuehrt: { type: 'array', items: { type: 'string' } },
+    eigener_lauf: { type: 'array', items: { type: 'string' } },
+    befunde: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          schweregrad: { type: 'string', enum: ['blockierend', 'wichtig', 'klein'] },
+          datei: { type: 'string' },
+          zeile: { type: 'integer' },
+          beschreibung: { type: 'string' },
+          reproduktion: { type: 'string' },
+        },
+        required: ['schweregrad', 'datei', 'zeile', 'beschreibung', 'reproduktion'],
+      },
+    },
+    plan_vs_umsetzung: { type: 'array', items: { type: 'string' } },
+    geprueft_und_in_ordnung: { type: 'array', items: { type: 'string' } },
+    nicht_pruefbar: { type: 'array', items: { type: 'string' } },
+    weitere_runde: { type: 'string', description: 'nur bei Abschlussprüfung: hat eine weitere Runde noch Substanz, und warum' },
+  },
+  required: ['selbst_ausgefuehrt', 'eigener_lauf', 'befunde', 'plan_vs_umsetzung', 'geprueft_und_in_ordnung', 'nicht_pruefbar'],
+}
+
+function pruefeArgs(a) {
+  const fehlt = ['projekt', 'plan'].filter(k => !a || !a[k])
+  if (fehlt.length) throw new Error('pruefung: args fehlen: ' + fehlt.join(', '))
+  if (a.effort !== undefined && !EFFORTS.includes(a.effort)) throw new Error('pruefung: effort "' + a.effort + '" ungültig')
+  if (a.tasks !== undefined && !Array.isArray(a.tasks)) throw new Error('pruefung: tasks muss eine Liste sein')
+  if (a.verbrauch !== undefined && typeof a.verbrauch !== 'boolean') throw new Error('pruefung: verbrauch muss true oder false sein')
+}
+
+function auftrag(a) {
+  const umfang = a.tasks && a.tasks.length ? `Geprüft wird die Umsetzung dieser Tasks: ${a.tasks.join(', ')}.` : 'Geprüft wird die gesamte Umsetzung des Plans.'
+  return `Prüfe die Umsetzung im Projekt ${a.projekt} gegen den Plan ${a.plan}. ${umfang}
+Der Executer-Bericht ist eine Behauptung. Fahre das Pflichtprogramm deiner Agentendefinition: Tests selbst ausführen${a.suite ? ` (${a.suite})` : ''}, die zentralen Artefakte selbst lesen, einen eigenen Lauf mit realistischen Daten und eigenem Prüfcode. Eigenen Prüfcode führst du als python -c oder in einem Wegwerfordner unter dem System-Temp aus; im Projekt änderst du nichts.
+${a.version ? `Aussagen über fremde Software belegst du am tatsächlich eingesetzten Versionsstand: ${a.version}.\n` : ''}${a.schwerpunkt ? `Schwerpunkt: ${a.schwerpunkt}\n` : ''}Melde jeden Befund mit Schweregrad, auch unsichere; der Koordinator filtert.
+${a.abschluss ? 'Das ist die Abschlussprüfung dieser Runde. Sag im Feld weitere_runde, ob eine weitere Runde noch Substanz hat oder nur noch Text umschichtet, und warum.\n' : ''}Übertrage deinen Schlussbericht in die Felder des StructuredOutput-Werkzeugs.`
+}
+
+// Eine messende Hilfsfunktion ablesen() steht auch in welle-mit-pruefung.js; plankritik.js und
+// planung.js haben eine mit Wunsch und Rückgabe. Die Regel (Fenster, Stufen, Rückfall) steht nur
+// in verbrauch.js.
+const ablesungen = []
+async function ablesen(anlass) {
+  if (args.verbrauch === false) return
+  let r = null
+  try {
+    r = await workflow({ scriptPath: VERBRAUCH }, { anlass: 'pruefung:' + anlass, wunsch: 0 })
+  } catch (e) {
+    r = { status: 'nicht_gelesen', grund: 'verbrauch.js nicht ausführbar: ' + (e && e.message) }
+  }
+  ablesungen.push({ anlass, ...(r || { status: 'nicht_gelesen', grund: 'verbrauch.js ohne Ergebnis' }) })
+}
+
+pruefeArgs(args)
+phase('Prüfung')
+const opts = { label: 'pruefung' + (args.kritisch ? ':kritisch' : ''), phase: 'Prüfung', schema: BERICHT, agentType: 'pruefer', model: 'opus' }
+if (args.effort) opts.effort = args.effort
+else if (args.kritisch) opts.effort = 'xhigh'
+await ablesen('vor Prüfung')
+const bericht = await agent(auftrag(args), opts)
+await ablesen('nach Prüfung')
+if (!bericht) throw new Error('pruefung: der pruefer hat keinen Bericht geliefert')
+
+const RANG = { blockierend: 0, wichtig: 1, klein: 2 }
+const zaehlung = { blockierend: 0, wichtig: 0, klein: 0 }
+bericht.befunde.forEach(b => { zaehlung[b.schweregrad]++ })
+return { effort: opts.effort || '(Frontmatter)', zaehlung, ...bericht, befunde: [...bericht.befunde].sort((x, y) => RANG[x.schweregrad] - RANG[y.schweregrad]), verbrauch: ablesungen }
+```
+
+## Verifikation
+
+Im Vault-Wurzelordner:
+
+```bash
+node -e "const t=require('fs').readFileSync(process.argv[1],'utf8').replace(/^export const meta = /m,'const meta = ');new (Object.getPrototypeOf(async function(){}).constructor)('agent','parallel','pipeline','phase','log','workflow','args','budget',t);console.log('PARSE OK')" .claude/workflows/pruefung.js
+```
+
+Erwartet: `PARSE OK`, Exit 0.
+
+Danach `git status --porcelain -- .claude/workflows/pruefung.js` zeigen.