claude-regelwerk/.claude/workflows/pruefung.js

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 }