Mutantenstufe der Plankritik nach der Pruefung vom 2026-09-28: Netzsperre per unshare, ungepufferte Ausgabe, Zeitlimit je Mutant 120 s, Aufraeumen bei SIGTERM, Modus-Zeile, mutanten_status, Faelle und Treiberfall 35

Co-Authored-By: Claude Opus 5.5 <[email protected]>

.vault-tools/workflow-pruefung/faelle_workflows.mjs

@@ -542,6 +542,97 @@ fall('plankritik', 'ZEITGRENZE im Mutantenlauf: Linse erfährt es, Hilfsagent f
   return fehler
 })
 
+// Fälle für die Nachbesserung vom 2026-09-28 (N5, N7, N8, N10): fünf Mutanten aus
+// eigene_mutanten.py töten, dazu Modus muster, Exit 2/124 und mutanten_status/mutanten_modus.
+
+fall('plankritik', 'Modus muster wird als muster an den Wrapper übergeben, nicht als voll', async () => {
+  const { fehler, soll } = pruefe()
+  const { protokoll: p } = await PK({ ...PK_ARGS, mutanten: 'muster' }, {})
+  const hilfe = mitLabel(p, 'werkzeug:mutanten')[0]
+  const zeile = (hilfe ? hilfe.prompt.split('\n').find(z => z.includes('mutanten_lauf_kopie.sh')) : '') || ''
+  soll(/ muster$/.test(zeile), 'Befehl endet nicht auf muster: ' + zeile)
+  return fehler
+})
+
+fall('plankritik', 'Mutantenstufe läuft auch mit materialisierter Kopie ohne args.kopie', async () => {
+  const { fehler, soll } = pruefe()
+  const args = { projekt: 'D:/x', planordner: 'D:/x/plan', materialisieren: { ohne: ['config/secrets.toml'] } }
+  const { protokoll: p } = await PK(args, {})
+  soll(mitLabel(p, 'werkzeug:mutanten').length === 1, 'Mutantenlauf lief nicht mit materialisierter Kopie')
+  return fehler
+})
+
+fall('plankritik', 'arithmetik bekommt mehr als die letzten fünf Zeilen des Mutantenlaufs', async () => {
+  const { fehler, soll } = pruefe()
+  const marke = 'MARKE-VOR-DEM-ENDE'
+  const fuellzeilen = Array.from({ length: 50 }, (_, i) => 'zeile ' + i).join('\n')
+  const ausgabe = `wurzel: /tmp/x\n${marke}\n${fuellzeilen}\nEXIT mutanten_lauf: 0`
+  const { protokoll: p } = await PK(PK_ARGS, { mutantenAusgabe: ausgabe })
+  const arith = mitLabel(p, 'plankritik:arithmetik')[0]
+  soll(arith && arith.prompt.includes(marke), 'Marke außerhalb der letzten fünf Zeilen fehlt im Auftrag')
+  return fehler
+})
+
+fall('plankritik', 'mutanten_lauf in der Rückgabe ist bei einem Lauf nicht null', async () => {
+  const { fehler, soll } = pruefe()
+  const { ergebnis: e } = await PK(PK_ARGS, {})
+  soll(e && e.mutanten_lauf !== null && /EXIT mutanten_lauf/.test(e.mutanten_lauf), 'mutanten_lauf: ' + JSON.stringify(e && e.mutanten_lauf))
+  return fehler
+})
+
+fall('plankritik', 'Wurzel im Mutanten-Befehl ist ctx.kopie, nie args.projekt', async () => {
+  const { fehler, soll } = pruefe()
+  const { protokoll: p } = await PK({ ...PK_ARGS, projekt: 'D:/anderes-projekt' }, {})
+  const hilfe = mitLabel(p, 'werkzeug:mutanten')[0]
+  soll(hilfe && hilfe.prompt.includes(PK_ARGS.kopie) && !hilfe.prompt.includes('anderes-projekt'), 'Befehl nennt args.projekt statt ctx.kopie: ' + (hilfe && hilfe.prompt))
+  return fehler
+})
+
+fall('plankritik', 'modus muster: Linse erfährt, dass kein Mutant gefahren ist', async () => {
+  const { fehler, soll } = pruefe()
+  const ausgabe = 'wurzel: /tmp/x\nmodus: muster (nur Musterpruefung, kein Mutant gefahren)\nM1 OK Trefferzahl=1\nEXIT mutanten_lauf: 0'
+  const { protokoll: p } = await PK({ ...PK_ARGS, mutanten: 'muster' }, { mutantenAusgabe: ausgabe })
+  const arith = mitLabel(p, 'plankritik:arithmetik')[0]
+  soll(arith && /Kein Mutant ist gefahren/.test(arith.prompt), 'Hinweis auf Musterlauf fehlt')
+  soll(arith && !/prüfe bei OK an der Fehlermeldung/.test(arith.prompt), 'Satz "prüfe bei OK" steht trotz Modus muster noch da')
+  return fehler
+})
+
+fall('plankritik', 'Exit 2 des Mutantenlaufs: Linse erfährt, dass er vor oder während der Mutanten gescheitert ist', async () => {
+  const { fehler, soll } = pruefe()
+  const ausgabe = 'wurzel: /tmp/x\nbefunde:\n  - x\nEXIT mutanten_lauf: 2'
+  const { protokoll: p } = await PK(PK_ARGS, { mutantenAusgabe: ausgabe })
+  const arith = mitLabel(p, 'plankritik:arithmetik')[0]
+  soll(arith && /vor oder während der Mutanten gescheitert \(Exit 2\)/.test(arith.prompt) && /Schwere wichtig/.test(arith.prompt), 'Hinweis auf Exit 2 fehlt: ' + (arith && arith.prompt.slice(-400)))
+  return fehler
+})
+
+fall('plankritik', 'mutanten_status und mutanten_modus in allen Zuständen', async () => {
+  const { fehler, soll } = pruefe()
+  const { ergebnis: eAus } = await PK({ ...PK_ARGS, mutanten: 'aus' }, {})
+  soll(eAus && eAus.mutanten_status === 'aus' && eAus.mutanten_modus === 'aus', 'aus: ' + JSON.stringify(eAus && [eAus.mutanten_status, eAus.mutanten_modus]))
+
+  const { ergebnis: eOhneKopie } = await PK({ projekt: 'D:/x', planordner: 'D:/x/plan' }, {})
+  soll(eOhneKopie && eOhneKopie.mutanten_status === 'ohne_kopie' && eOhneKopie.mutanten_modus === 'voll', 'ohne_kopie: ' + JSON.stringify(eOhneKopie && [eOhneKopie.mutanten_status, eOhneKopie.mutanten_modus]))
+
+  const { ergebnis: eKeineToml } = await PK(PK_ARGS, { mutantenAusgabe: 'KEINE_MUTANTEN_TOML' })
+  soll(eKeineToml && eKeineToml.mutanten_status === 'keine_toml', 'keine_toml: ' + JSON.stringify(eKeineToml && eKeineToml.mutanten_status))
+
+  const { ergebnis: eOhneErgebnis } = await PK(PK_ARGS, { mutantenAusgabe: 'irgendeine unbrauchbare Ausgabe ohne Marker' })
+  soll(eOhneErgebnis && eOhneErgebnis.mutanten_status === 'ohne_ergebnis', 'ohne_ergebnis: ' + JSON.stringify(eOhneErgebnis && eOhneErgebnis.mutanten_status))
+
+  const { ergebnis: eExit2 } = await PK(PK_ARGS, { mutantenAusgabe: 'EXIT mutanten_lauf: 2' })
+  soll(eExit2 && eExit2.mutanten_status === 'exit_2', 'exit_2: ' + JSON.stringify(eExit2 && eExit2.mutanten_status))
+
+  const { ergebnis: eExitDefault } = await PK(PK_ARGS, {})
+  soll(eExitDefault && eExitDefault.mutanten_status === 'exit_0' && eExitDefault.mutanten_modus === 'voll', 'exit_0: ' + JSON.stringify(eExitDefault && [eExitDefault.mutanten_status, eExitDefault.mutanten_modus]))
+
+  const { ergebnis: eMuster } = await PK({ ...PK_ARGS, mutanten: 'muster' }, {})
+  soll(eMuster && eMuster.mutanten_modus === 'muster', 'muster: ' + JSON.stringify(eMuster && eMuster.mutanten_modus))
+
+  return fehler
+})
+
 // ---------------------------------------------------------------- pruefung
 const PR_ARGS = { projekt: 'D:/x', plan: 'D:/x/plan' }
 const PR = (a, k, o = {}) => fuehreAus(WF('pruefung'), a, antworten(k), { ordner: ORDNER, ...o })