Skip to content

armgit / SOMA

Public Imported from GitHub
0

Desktop app for designing parametric 3D models in CadQuery together with the coding agent of your choice

45.3 KB
Raw Blame
// Smoke-Test der echten Electron-App: Projekt, Viewer, Terminal, Auto-Build, Fehlerfall, Projektwechsel.
// Aufruf: npm run test:smoke (baut vorher). SMOKE_VISIBLE=1 zeigt das Fenster und macht einen Screenshot.
import fs from 'node:fs';
import os from 'node:os';
import path from 'node:path';
import { APP, checker, cleanup, sleep, startApp } from './harness.mjs';

const t = checker();
const { check } = t;
let app;

try {
  app = await startApp({ name: 'smoke' });
  const { ev, waitFor, domClick, ud, page } = app;
  const status = () => ev(() => window.__t.status());
  // SMOKE_SHOTS=1 (zusammen mit SMOKE_VISIBLE=offscreen): Bilder der wichtigsten Zustände nach test/shots/ zum Ansehen
  const shot = async (name) => {
    if (!process.env.SMOKE_SHOTS) return;
    fs.mkdirSync(path.join(APP, 'test', 'shots'), { recursive: true });
    await sleep(900);
    await app.screenshot(path.join(APP, 'test', 'shots', `${name}.png`)).catch((e) => console.log('Screenshot:', e.message));
  };
  check('App gestartet, Fenster verbunden', true);

  // 1) Start: Projekt angelegt, automatischer erster Build, Bauteile im Viewer
  await waitFor('window.__t', () => !!window.__t && !!window.__t.project());
  await waitFor('Build ok', () => window.__t.status().state === 'ok' && window.__t.partCount() === 2);
  const proj = await ev(() => window.__t.project());
  check('Projekt liegt unter <App-Daten>/workspaces/<uuid>', proj.dir.startsWith(path.join(ud, 'workspaces')) && /[0-9a-f-]{36}$/.test(proj.dir), proj.dir.slice(-45));
  check('Vorlagen-Dateien vorhanden (AGENTS.md, CLAUDE.md, NOTES.md, model.py …)',
    ['AGENTS.md', 'CLAUDE.md', 'NOTES.md', 'model.py', '.gitignore', '.soma/project.json', '.git/HEAD'].every((f) => fs.existsSync(path.join(proj.dir, f))));
  const appVersion = JSON.parse(fs.readFileSync(path.join(APP, 'package.json'), 'utf8')).version;
  const versionUi = await ev(() => ({ start: document.getElementById('start-version').textContent, logo: document.getElementById('btn-home').title }));
  check('Version (E68): in project.json, auf der Startseite und am Logo', JSON.parse(fs.readFileSync(path.join(proj.dir, '.soma', 'project.json'), 'utf8')).app_version === appVersion
    && versionUi.start === appVersion && versionUi.logo === `Start page · SOMA ${appVersion}`, `${appVersion} ${JSON.stringify(versionUi)}`);
  check('Erster Build automatisch, 2 Bauteile im Strukturbaum', JSON.stringify(await ev(() => window.__t.treeNames())) === '["Body","Lid"]');
  check('Nach dem Build kein Fehlerhinweis', (await status()).viewerMsg === '', (await status()).text);
  const okStatus = await status();
  check('Build-Anzeige oben: „Built · 2 parts"', okStatus.text === 'Built' && okStatus.detail.startsWith('2 parts'), `${okStatus.text} ${okStatus.detail}`);

  // 2) Klick im Viewer -> Bauteil, Fläche, Code
  const lidFace = await ev(() => {
    const v = window.__t.viewer; const id = window.__t.parts().find((p) => p.name === 'Lid').id;
    const f = v.facesOf(id).filter((x) => x.surface === 'PLANE').sort((a, b) => b.center[2] - a.center[2])[0];
    return { id, face: f.id, pos: v.screenOf(id, f.id) };
  });
  await page.click(lidFace.pos.x, lidFace.pos.y);
  await waitFor('Info nach Klick', () => window.__t.info().includes('Lid'));
  const info = await ev(() => window.__t.info());
  const hl = await ev(() => window.__t.codeHighlight());
  check('Klick auf Deckel-Oberseite: Auswahlkarte mit Bauteil, Fläche, Codezeile', info.startsWith('Lid') && info.includes('Face · plane') && /model\.py\s*Line \d+/.test(info), info.replace(/\s+/g, ' ').slice(0, 60));
  check('Codeausschnitt: add_part("Lid") ist markiert', hl.some((l) => l.includes('add_part("Lid"')), String(hl[0]).trim().slice(0, 40));
  const selText = await ev(() => window.__t.selectionText());
  check('Text für den Agenten nennt Bauteil, Datei, Zeile und Fläche', /^\[Selection: part "Lid", model\.py line \d+.*clicked face: plane/.test(selText), selText.slice(0, 70));

  await shot('1-arbeitsbereich');

  check('Seitenleiste beim ersten Start zu, Code zu: Die Bauteile stehen im Baum im Viewer (E82)', JSON.stringify(await ev(() => window.__t.layout())) === '{"side":null,"code":false,"agent":true}',
    JSON.stringify(await ev(() => window.__t.layout())));
  const rail = await ev(() => [...document.querySelectorAll('#rail > *')].map((x) => (x.classList.contains('rail-sep') ? '|' : x.dataset?.panel ?? '')).filter(Boolean).join(' '));
  check('Leiste in drei Gruppen: Parameters, Files | Analysis, Animation | Skills, kein Reiter Parts', rail === 'params files | analysis anim | skills', rail);
  let tree = await ev(() => window.__t.tree());
  check('Strukturbaum oben links: eingeklappt nur der Name des Modells', !tree.open && tree.head === proj.name && tree.rows.length === 0, JSON.stringify(tree.head));
  await ev(() => window.__t.treeOpen(true));
  tree = await ev(() => window.__t.tree());
  check('Aufgeklappt: Body und Lid, Lid als Auswahl orange, Auge und Halbkreis je Zeile', tree.rows.map((x) => x.name).join() === 'Body,Lid'
    && tree.rows.find((x) => x.name === 'Lid')?.sel && await ev(() => document.querySelectorAll('#tree .tr-row .tg').length === 4), JSON.stringify(tree.rows));
  await shot('1b-baum');
  await ev(() => window.__t.treeOpen(false));

  // Code als eigene Spalte und Dateien gleichzeitig (Entwurf 2)
  await domClick('btn-sel-code');
  await waitFor('Code-Spalte', () => window.__t.codeText().includes('add_part("Lid"'), 10000).catch(() => {});
  check('„Code" in der Auswahlkarte zeigt model.py in der Code-Spalte, die Seitenleiste bleibt zu', (await ev(() => window.__t.codeText())).includes('add_part("Lid"')
    && JSON.stringify(await ev(() => window.__t.layout())) === '{"side":null,"code":true,"agent":true}');
  await shot('2-code');
  await ev(() => window.__t.showPanel('files'));
  await waitFor('Dateiliste', () => window.__t.fileRows().includes('model.py'), 10000).catch(() => {});
  const rows = await ev(() => window.__t.fileRows());
  check('Dateien: model.py sichtbar, AGENTS.md eingeklappt unter „Managed by the app"', rows.includes('model.py') && rows.includes('Managed by the app') && !rows.includes('AGENTS.md'), rows.slice(0, 6).join(','));
  check('Dateien und Code gleichzeitig offen, die offene Datei ist im Baum hervorgehoben', await ev(() => !document.getElementById('editor').hidden && !document.getElementById('panel-files').hidden
    && document.querySelector('#tab-files .frow.sel')?.dataset.path === 'model.py'));
  await shot('3-dateien');
  await domClick('btn-lay-code');
  await domClick('btn-lay-side');
  const lay = await ev(() => window.__t.layout());
  await ev(() => document.dispatchEvent(new KeyboardEvent('keydown', { key: '1', ctrlKey: true, bubbles: true })));
  const lay2 = await ev(() => window.__t.layout());
  check('Spalten-Schalter oben: Code und Seitenleiste zu, Strg 1 bringt die letzte Ansicht (Dateien) wieder', !lay.code && lay.side === null && lay2.side === 'files', `${JSON.stringify(lay)} ${JSON.stringify(lay2)}`);
  await ev(() => window.__t.showPanel(null));

  // Export mit Dateidialog (statt nach exports/): ein Bauteil aus der Auswahlkarte, alle Bauteile in einen Ordner
  const expDir = fs.mkdtempSync(path.join(os.tmpdir(), 'soma-export-test-'));
  await domClick('btn-sel-export');
  const expMenu = await ev(() => ({ open: !document.getElementById('menu-export').hidden, sel: document.getElementById('exp-sel').classList.contains('on') ? document.getElementById('exp-sel').textContent : '' }));
  // Netz-Einstellungen (Issue #8): zugeklappt, ein Klick klappt auf, ohne das Menü zu schließen, die Zeile fasst zusammen
  const meshClosed = await ev(() => ({ hidden: document.getElementById('exp-mesh').hidden, sum: document.getElementById('exp-mesh-sum').textContent }));
  await domClick('exp-mesh-toggle');
  await ev(() => document.querySelector('#exp-up [data-v="y"]').click());
  const meshOpen = await ev(() => ({ menu: !document.getElementById('menu-export').hidden, hidden: document.getElementById('exp-mesh').hidden, sum: document.getElementById('exp-mesh-sum').textContent }));
  await ev(() => document.querySelector('#exp-up [data-v=""]').click());
  check('Export-Menü: Netz-Einstellungen zugeklappt, aufklappbar, Zusammenfassung „Y up“', meshClosed.hidden && meshClosed.sum === 'Auto' && meshOpen.menu && !meshOpen.hidden && meshOpen.sum === 'Y up'
    && await ev(() => document.getElementById('exp-mesh-sum').textContent) === 'Auto', JSON.stringify([meshClosed, meshOpen]));
  await ev(() => document.body.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true })));
  await app.answers([path.join(expDir, 'Deckel.step')]);
  const one = await ev(() => window.__t.exportAs('step', 'sel'));
  const deckel = path.join(expDir, 'Deckel.step');
  check('„Export" in der Auswahlkarte: Menü mit „Only Lid“, STEP am gewählten Ort, nichts in exports/', expMenu.open && expMenu.sel === 'Only Lid' && one.ok
    && fs.existsSync(deckel) && fs.readFileSync(deckel, 'utf8').startsWith('ISO-10303-21') && !fs.existsSync(path.join(proj.dir, 'exports')), JSON.stringify(one).slice(0, 120));
  fs.writeFileSync(path.join(expDir, 'Body.stl'), 'alt');
  await app.answers([expDir, 1]);
  const keptExp = await ev(() => window.__t.exportAs('stl', 'all'));
  check('Alle Bauteile in einen Ordner: vorhandene Datei nur nach Rückfrage, „Cancel“ schreibt nichts', keptExp.cancelled && fs.readFileSync(path.join(expDir, 'Body.stl'), 'utf8') === 'alt'
    && !fs.existsSync(path.join(expDir, 'Lid.stl')), JSON.stringify(keptExp).slice(0, 100));
  await app.answers([expDir, 0]);
  const all = await ev(() => window.__t.exportAs('stl', 'all'));
  check('„Replace“: beide Bauteile als STL im Ordner, Meldung nennt den Ordner', all.ok && all.files.length === 2 && fs.statSync(path.join(expDir, 'Body.stl')).size > 200
    && fs.existsSync(path.join(expDir, 'Lid.stl')) && (await ev(() => window.__t.toast())).text.includes(expDir), JSON.stringify(all).slice(0, 120));
  await app.answers([null]);
  const none = await ev(() => window.__t.exportAs('step', 'all'));
  check('Dialog abgebrochen: nichts passiert', none.cancelled && !none.ok);
  cleanup(expDir);

  // 3) Terminal: echte Shell im Projektordner, soma im PATH
  const tid = await ev(() => window.__t.terminals.activeId);
  check('Ein Terminal wurde automatisch geöffnet', await ev(() => window.__t.terminals.count) === 1);
  // Ohne echten fetten Schnitt rechnet Chromium das Fett nach, runde Zeichen sitzen dann einen Pixel tiefer
  check('Terminalschrift: fett ist der echte Schnitt 700, vor dem Terminal geladen', await ev((id) => window.__t.terminals.tabs.get(id).term.options.fontWeightBold === '700'
    && [...document.fonts].some((f) => f.family.includes('IBM Plex Mono') && f.weight === '700' && f.status === 'loaded'), tid));
  await ev((id) => window.soma.term.write(id, 'soma --version\r'), tid);
  const gotVersion = await waitFor('soma --version im Terminal', (id) => /^soma \d/m.test(window.__t.termText(id)), 20000, tid).catch(() => false);
  check('Im Terminal läuft `soma` (PATH der Basisumgebung)', !!gotVersion);
  // pwd gibt es in PowerShell (Alias von Get-Location) und in den Shells von macOS und Linux
  await ev((id) => window.soma.term.write(id, 'pwd\r'), tid);
  await waitFor('pwd', (id) => window.__t.termText(id).includes('workspaces'), 20000, tid).catch(() => {});
  check('Terminal startet im Projektordner', (await ev((id) => window.__t.termText(id), tid)).includes('workspaces'));
  // Übergabe an den Agenten: Text landet in der Eingabezeile, abgeschickt wird nicht (E11)
  await ev((t) => window.__t.insert(t), selText);
  await waitFor('eingefügter Text', (id) => window.__t.termText(id).includes('[Selection: part "Lid"'), 10000, tid).catch(() => {});
  const afterInsert = await ev((id) => window.__t.termText(id), tid);
  check('„Send to agent" fügt den Text in die Eingabezeile ein, ohne abzuschicken', afterInsert.includes('[Selection: part "Lid"') && !/Selection:.*\n.*(nicht erkannt|not recognized)/.test(afterInsert));
  check('Bestätigung „Added to the input of Terminal"', (await ev(() => window.__t.toast())).text.includes('Added to the input of Terminal'));
  check('… und derselbe Text in der Zwischenablage (für Agenten-Apps außerhalb der App)', (await ev(() => window.soma.test.clipboard())) === selText);
  await ev((id) => window.soma.term.write(id, '\x03'), tid); // Zeile verwerfen

  // Markierung (E16): Viewer-Bild einfrieren, zeichnen, als PNG nach .soma/feedback/, Pfad in die Eingabe
  const dirtyBefore = (await ev(() => window.soma.project.saveState())).dirtyFiles;
  const lidPos = await ev((l) => { const v = window.__t.viewer, r = document.getElementById('viewer').getBoundingClientRect(), p = v.screenOf(l.id, l.face); return [p.x - r.left, p.y - r.top]; }, lidFace);
  await domClick('btn-mark');
  await waitFor('Zeichenfläche offen', () => window.__t.markup().active, 5000).catch(() => {});
  const hiddenUi = await ev(() => ['vtop', 'cube', 'cards'].every((id) => getComputedStyle(document.getElementById(id)).display === 'none'));
  const mk0 = await ev(() => window.__t.markup());
  check('„Mark up": Zeichenfläche offen, Werkzeuge, Würfel und Karten treten zurück', mk0.active && !mk0.blank && hiddenUi && mk0.pixels[0] > 0, `${mk0.pixels.join('x')} px`);
  const [bgPx, lidPx] = await ev((p) => [window.__t.markPixel(3, 3), window.__t.markPixel(p[0], p[1])], lidPos);
  // Die angeklickte Fläche leuchtet im Viewer orange. Im Bild fehlt die Auswahl, sonst verschluckt sie die orange Markierung.
  check('Das eingefrorene Bild zeigt das Modell ohne Auswahlfarbe', bgPx[3] === 255 && lidPx.slice(0, 3).reduce((s, v, i) => s + Math.abs(v - bgPx[i]), 0) > 40
    && !(lidPx[0] > 200 && lidPx[2] < 120), `${bgPx.slice(0, 3)} / ${lidPx.slice(0, 3)}`);
  check('Die Auswahl im Viewer selbst bleibt bestehen', await ev(() => window.__t.viewer.selection) === lidFace.id);
  const drag = (pts) => ev((pts) => {
    const c = document.getElementById('mark-canvas'), r = c.getBoundingClientRect();
    const fire = (type, [x, y]) => c.dispatchEvent(new PointerEvent(type, { clientX: r.left + x, clientY: r.top + y, bubbles: true, cancelable: true, button: 0, pointerId: 1, isPrimary: true }));
    fire('pointerdown', pts[0]); for (const p of pts.slice(1)) fire('pointermove', p); fire('pointerup', pts[pts.length - 1]);
  }, pts);
  const tool = (name) => ev((n) => document.querySelector(`#mark-tools [data-tool="${n}"]`).click(), name);
  await drag([[60, 300], [100, 302], [140, 300], [180, 301]]);
  await tool('arrow'); await drag([[420, 140], [lidPos[0], lidPos[1]]]);
  await tool('rect'); await drag([[40, 380], [200, 460]]);
  await tool('ellipse'); await drag([[250, 380], [252, 381]]); // bloßer Klick: keine Form
  await tool('text'); await drag([[430, 110]]);
  await sleep(100);
  await ev(() => { document.getElementById('mark-text').value = 'vorne spitz, etwa 1 mm'; });
  await shot('7a-markieren-text');
  await ev(() => document.getElementById('mark-text').dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true })));
  const mk1 = await ev(() => window.__t.markup());
  const penPx = await ev(() => window.__t.markPixel(120, 301));
  check('Zeichnen: Stift, Pfeil, Rechteck, Text (Klick ohne Ziehen ergibt keine Form)', JSON.stringify(mk1.shapes) === '["pen","arrow","rect","text"]', mk1.shapes.join(','));
  check('Stiftstrich im Bild in Orange', penPx[0] > 200 && penPx[1] > 110 && penPx[1] < 190 && penPx[2] < 110, penPx.slice(0, 3).join(','));
  await shot('7-markieren');
  await tool('ellipse'); await drag([[250, 380], [330, 440]]);
  await domClick('btn-mark-undo');
  check('Rückgängig nimmt die letzte Form zurück', JSON.stringify((await ev(() => window.__t.markup())).shapes) === '["pen","arrow","rect","text"]');
  await domClick('btn-mark-blank');
  const blankPx = await ev((p) => window.__t.markPixel(p[0] + 30, p[1] + 30), lidPos);
  await shot('7c-markieren-leer');
  check('„Blank canvas": Hintergrund ohne Modell, Zeichnung bleibt', (await ev(() => window.__t.markup())).blank && blankPx.slice(0, 3).join() === '27,30,35'
    && (await ev(() => window.__t.markup())).shapes.length === 4, blankPx.slice(0, 3).join(','));
  await domClick('btn-mark-blank');

  // Gezeichnetes bleibt bearbeitbar: auswählen, verschieben, drehen, skalieren, umfärben, löschen
  const mk = () => ev(() => window.__t.markup());
  const key = (k, o = {}) => ev(([k, o]) => document.body.dispatchEvent(new KeyboardEvent('keydown', { key: k, bubbles: true, ...o })), [k, o]);
  await tool('select');
  const rect0 = (await mk()).items[2];
  await drag([[40, 420], [60, 410], [80, 400]]); // Klick auf den linken Rand, dann ziehen
  let st = await mk();
  check('Auswählen: Klick auf den Rand wählt das Rechteck, Ziehen verschiebt es', st.selected === 2 && st.items[2].x === rect0.x + 40 && st.items[2].y === rect0.y - 20, `${st.selected}: ${st.items[2].x},${st.items[2].y}`);
  let hd = await ev(() => window.__t.markHandles());
  await drag([hd.rotate, [hd.center[0] + 50, hd.rotate[1] + 20], [hd.center[0] + 100, hd.center[1]]]);
  st = await mk();
  check('Drehgriff dreht um die Mitte (hier um 90°)', Math.abs(st.items[2].rot - Math.PI / 2) < 0.01 && st.items[2].x === rect0.x + 40, `${st.items[2].rot} rad`);
  hd = await ev(() => window.__t.markHandles());
  const [cx2, cy2] = hd.corners[2];
  await drag([[cx2, cy2], [cx2 + (cx2 - hd.center[0]) * 0.5, cy2 + (cy2 - hd.center[1]) * 0.5]]);
  st = await mk();
  const hd2 = await ev(() => window.__t.markHandles());
  check('Eckgriff skaliert, die gegenüberliegende Ecke bleibt stehen', st.items[2].sx > 1.2 && st.items[2].sy > 1.2 && Math.hypot(hd2.corners[0][0] - hd.corners[0][0], hd2.corners[0][1] - hd.corners[0][1]) < 0.5,
    `${st.items[2].sx} × ${st.items[2].sy}`);
  await domClick('btn-mark-color');
  const swatches = await ev(() => document.querySelectorAll('#menu-mark-color [data-color]').length);
  await shot('7e-markieren-farben');
  await ev(() => document.querySelector('#menu-mark-color [data-color="blue"]').click());
  st = await mk();
  check('Farbmenü: 10 Farben und eigene Farbe, die ausgewählte Form wird umgefärbt', swatches === 10 && await ev(() => !!document.getElementById('mark-color-custom'))
    && st.items[2].color === '#5ea8ff' && st.color === '#5ea8ff' && await ev(() => document.getElementById('menu-mark-color').hidden), `${swatches} Farben, ${st.items[2].color}`);
  await shot('7d-markieren-auswahl');
  await key('Delete');
  st = await mk();
  check('Del löscht die ausgewählte Form', JSON.stringify(st.shapes) === '["pen","arrow","text"]' && st.selected === -1, st.shapes.join(','));
  await domClick('btn-mark-undo');
  st = await mk();
  check('Rückgängig holt sie zurück, mit Drehung, Größe und Farbe', st.shapes.length === 4 && st.items[2].color === '#5ea8ff' && Math.abs(st.items[2].rot - Math.PI / 2) < 0.01 && st.items[2].sx > 1.2);
  await key('y', { ctrlKey: true });
  check('Ctrl+Y wiederholt das Löschen', (await mk()).shapes.length === 3);
  await domClick('btn-mark-undo');
  const tx = (await mk()).items[3];
  await drag([[tx.x, tx.y]]); await drag([[tx.x, tx.y]]);
  await sleep(50);
  const ed = await ev(() => ({ open: !document.getElementById('mark-text').hidden, value: document.getElementById('mark-text').value }));
  await ev(() => { const t = document.getElementById('mark-text'); t.value = 'Spitze etwa 1 mm'; t.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true })); });
  st = await mk();
  check('Doppelklick auf einen Text öffnet ihn zum Bearbeiten, Enter übernimmt', ed.open && ed.value === 'vorne spitz, etwa 1 mm' && st.items[3].text === 'Spitze etwa 1 mm' && st.shapes.length === 4, ed.value);
  await key('Escape');
  check('Escape hebt zuerst nur die Auswahl auf', (await mk()).selected === -1 && (await mk()).active);

  // Linie und Raster: Das Raster steht im Bild, Linien rasten an den Kreuzungen ein
  const gridOff = await ev(() => window.__t.markPixel(600, 10));
  await domClick('btn-mark-grid');
  const gridOn = await ev(() => window.__t.markPixel(600, 10));
  await tool('line'); await drag([[101, 203], [150, 205], [189, 207]]);
  st = await mk();
  const ln = st.items[st.items.length - 1];
  await shot('7f-markieren-raster');
  check('Raster an: im Bild zu sehen, Knopf gedrückt', st.grid && gridOn.slice(0, 3).join() !== gridOff.slice(0, 3).join()
    && await ev(() => document.getElementById('btn-mark-grid').getAttribute('aria-pressed')) === 'true', `${gridOff.slice(0, 3)} → ${gridOn.slice(0, 3)}`);
  check('Linie: gerade, Endpunkte am Raster (100,200 bis 180,200)', st.shapes.length === 5 && ln.tool === 'line' && ln.x === 140 && ln.y === 200, `${ln.tool} ${ln.x},${ln.y}`);
  await domClick('btn-mark-grid');
  check('Raster wieder aus: Bild ohne Raster', !(await mk()).grid && (await ev(() => window.__t.markPixel(600, 10))).slice(0, 3).join() === gridOff.slice(0, 3).join());

  // Ansicht: Die Fläche passt sich dem Viewer an (z. B. wenn die PDF daneben schließt), Mausrad zoomt um den Zeiger, Ctrl+0 passt ein
  const layerSize = () => ev(() => { const l = document.getElementById('markup'); return [l.clientWidth, l.clientHeight]; });
  const [lw] = await layerSize();
  await ev(() => { document.getElementById('markup').style.right = '50%'; window.__t.markRelayout(); });
  await sleep(150);
  const half = await mk();
  await ev(() => { document.getElementById('markup').style.right = ''; window.__t.markRelayout(); });
  await sleep(150);
  check('Kleinerer Viewer: Zeichenfläche wird eingepasst und mittig gestellt, größerer wieder voll', Math.abs(half.view[0] - 0.5) < 0.02 && (await mk()).view[0] === 1,
    `${half.view.join(',')} bei ${lw}px`);
  const fireWheel = (x, y, dy) => ev(([x, y, dy]) => {
    const l = document.getElementById('markup'), r = l.getBoundingClientRect();
    l.dispatchEvent(new WheelEvent('wheel', { clientX: r.left + x, clientY: r.top + y, deltaY: dy, bubbles: true, cancelable: true }));
  }, [x, y, dy]);
  await fireWheel(140, 200, -462); // Faktor 2
  st = await mk();
  const zoomed = st.view;
  await tool('pen');
  await ev(() => {
    const c = document.getElementById('mark-canvas'), l = document.getElementById('markup').getBoundingClientRect();
    const fire = (type) => c.dispatchEvent(new PointerEvent(type, { clientX: l.left + 140, clientY: l.top + 200, bubbles: true, cancelable: true, button: 0, pointerId: 1, isPrimary: true }));
    fire('pointerdown'); fire('pointerup');
  });
  st = await mk();
  const dot = st.items[st.items.length - 1];
  check('Mausrad zoomt um den Zeiger, gezeichnet wird an der richtigen Stelle der Fläche', Math.abs(zoomed[0] - 2) < 0.01 && Math.abs(dot.x - 140) < 0.6 && Math.abs(dot.y - 200) < 0.6,
    `k ${zoomed[0]}, Punkt ${dot.x},${dot.y}`);
  await domClick('btn-mark-undo');
  await key('0', { ctrlKey: true });
  check('Ctrl+0 passt wieder ein', JSON.stringify((await mk()).view) === '[1,0,0]', (await mk()).view.join(','));

  await ev(() => document.body.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true })));
  check('Escape mit Zeichnung verwirft nicht sofort (erst beim zweiten Mal)', (await ev(() => window.__t.markup())).active && (await ev(() => window.__t.toast())).text.includes('Press Escape again'));
  const px = (await ev(() => window.__t.markup())).pixels;
  await domClick('btn-mark-send');
  await waitFor('Markierung gespeichert', () => !window.__t.markup().active, 10000).catch(() => {});
  const fbDir = path.join(proj.dir, '.soma', 'feedback');
  const fbFiles = fs.existsSync(fbDir) ? fs.readdirSync(fbDir) : [];
  const png = fbFiles.length === 1 ? fs.readFileSync(path.join(fbDir, fbFiles[0])) : Buffer.alloc(0);
  if (process.env.SMOKE_SHOTS && png.length) fs.writeFileSync(path.join(APP, 'test', 'shots', '7b-markierung-bild.png'), png); // so sieht der Agent es
  check('„Send to agent": PNG in .soma/feedback/, so groß wie der Viewer in Gerätepixeln', /^markup-\d{8}-\d{4}\.png$/.test(fbFiles[0] ?? '') && png.length > 2000
    && png.readUInt32BE(16) === px[0] && png.readUInt32BE(20) === px[1], `${fbFiles.join(',')} ${png.length > 24 ? `${png.readUInt32BE(16)}x${png.readUInt32BE(20)}` : ''}`);
  await waitFor('Pfad im Terminal', (id) => window.__t.termText(id).includes('[Markup: .soma/feedback/markup-'), 10000, tid).catch(() => {});
  check('Pfad steht in der Eingabe des Terminals, nicht abgeschickt', (await ev((id) => window.__t.termText(id), tid)).includes(`[Markup: .soma/feedback/${fbFiles[0]}]`));
  const tst = await ev(() => window.__t.toast());
  check('Meldung nennt Datei und Ziel, die Werkzeuge sind zurück', tst.text.includes(`Markup saved: .soma/feedback/${fbFiles[0]}`) && tst.text.includes('Added to the input of Terminal')
    && await ev(() => getComputedStyle(document.getElementById('vtop')).display !== 'none'), tst.text.replace(/\s+/g, ' ').slice(0, 70));
  await ev((id) => window.soma.term.write(id, '\x03'), tid);
  check('Markierung zählt nicht als ungespeicherte Änderung (nicht in Git, E11)', (await ev(() => window.soma.project.saveState())).dirtyFiles === dirtyBefore);
  await domClick('btn-mark');
  await waitFor('Zeichenfläche erneut', () => window.__t.markup().active, 5000).catch(() => {});
  const again = await ev(() => window.__t.markup().active);
  await ev(() => document.body.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true })));
  check('Escape ohne Zeichnung schließt die Zeichenfläche, es entsteht keine Datei', again && !(await ev(() => window.__t.markup().active)) && fs.readdirSync(fbDir).length === 1);

  // Bauteile gehen über „Send to agent“ in der Auswahlkarte an den Agenten, die Zeilen des Baums lassen sich nicht mehr ziehen (E82)
  await ev(() => window.__t.treeOpen(true));
  check('Zeilen des Strukturbaums sind nicht ziehbar, keine Übergabeleiste', await ev(() => [...document.querySelectorAll('#tree .tr-row')].every((r) => !r.draggable))
    && !(await ev(() => document.getElementById('handoff'))));
  await ev(() => window.__t.treeOpen(false));

  // Dateibaum: Markierungen sichtbar, anlegen, umbenennen, löschen über Menü und Tasten
  await ev(() => window.__t.showPanel('files'));
  await waitFor('Gruppe Markups im Dateibaum', () => window.__t.fileRows().includes('Markups'), 10000).catch(() => {});
  const rows1 = await ev(() => window.__t.fileRows());
  check('Dateibaum: Ordner und Gruppen anfangs eingeklappt', rows1.includes('Markups') && !rows1.includes(fbFiles[0]), rows1.slice(-6).join(','));
  await ev((f) => window.__t.revealFile(f), `.soma/feedback/${fbFiles[0]}`);
  await waitFor('Markierungen im Dateibaum', (f) => window.__t.fileRows().includes(f), 10000, fbFiles[0]).catch(() => {});
  const rows2 = await ev(() => window.__t.fileRows());
  check('Dateibaum: Gruppe „Markups“ mit dem Bild aus .soma/feedback/, sonst nichts aus .soma', rows2.includes('Markups') && rows2.includes(fbFiles[0]) && !rows2.includes('project.json'), rows2.slice(-6).join(','));
  const ctx = (rel) => ev((rel) => {
    const row = document.querySelector(`#tab-files .frow[data-path="${CSS.escape(rel)}"]`);
    if (!row) return null;
    const r = row.getBoundingClientRect();
    row.dispatchEvent(new MouseEvent('contextmenu', { bubbles: true, cancelable: true, clientX: r.left + 20, clientY: r.top + 5 }));
    return [...document.querySelectorAll('#menu-ctx .mi')].map((b) => (b.disabled ? '-' : '') + b.textContent.replace(/(F2|Del)$/, ''));
  }, rel);
  const menuItemClick = (label) => ev((l) => [...document.querySelectorAll('#menu-ctx .mi')].find((b) => b.textContent.startsWith(l))?.click(), label);
  const typeName = (name) => ev((n) => { const t = document.querySelector('#tab-files .fedit'); if (!t) return false; t.value = n; t.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true })); return true; }, name);
  const fbRel = `.soma/feedback/${fbFiles[0]}`;
  const imgMenu = await ctx(fbRel);
  await menuItemClick('Mark up');
  await waitFor('Bild als Zeichenfläche', () => window.__t.markup().active, 5000).catch(() => {});
  const mkImg = await ev(() => ({ ...window.__t.markup(), hint: document.getElementById('mark-hint').textContent }));
  await shot('7g-markieren-bild');
  check('Bild im Dateibaum: „Mark up“ öffnet es als Hintergrund der Zeichenfläche', imgMenu?.includes('Mark up') && mkImg.active && mkImg.source === fbRel && !mkImg.blank
    && mkImg.hint.includes(fbRel) && mkImg.pixels[0] >= px[0], `${imgMenu?.join(',')} ${mkImg.source} ${mkImg.pixels}`);
  await ev(() => document.body.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true })));
  check('Escape ohne Zeichnung schließt das Bild wieder, keine neue Datei', !(await ev(() => window.__t.markup().active)) && fs.readdirSync(fbDir).length === 1);
  await ev((rel) => document.querySelector(`#tab-files .frow[data-path="${CSS.escape(rel)}"]`).click(), fbRel);
  await waitFor('Bild per Klick', () => window.__t.markup().active, 5000).catch(() => {});
  check('Klick auf das Bild öffnet es ebenfalls zum Markieren (E52)', (await ev(() => window.__t.markup())).source === fbRel);
  // Von Bild zu Bild: ohne Zeichnung direkt und ohne Meldung, mit Zeichnung erst nach Rückfrage
  const imgB = path.join(proj.dir, 'skizze-b.png');
  fs.copyFileSync(path.join(fbDir, fbFiles[0]), imgB);
  await waitFor('zweites Bild im Baum', () => window.__t.fileRows().includes('skizze-b.png'), 10000).catch(() => {});
  const clickRow = (rel) => ev((rel) => document.querySelector(`#tab-files .frow[data-path="${CSS.escape(rel)}"]`).click(), rel);
  const toastBefore = (await ev(() => window.__t.toast())).text;
  await clickRow('skizze-b.png');
  await waitFor('Wechsel', () => window.__t.markup().source === 'skizze-b.png', 5000).catch(() => {});
  const sw = await ev(() => ({ ...window.__t.markup(), toast: window.__t.toast() }));
  check('Wechsel zu einem anderen Bild ohne Zeichnung: direkt, ohne Meldung', sw.active && sw.source === 'skizze-b.png' && (sw.toast.hidden || sw.toast.text === toastBefore), sw.toast.text.slice(0, 60));
  await tool('pen'); await drag([[60, 300], [140, 300]]);
  await app.answers([1]);
  await clickRow(fbRel);
  await sleep(500);
  const kept = await ev(() => window.__t.markup());
  await app.answers([0]);
  await clickRow(fbRel);
  await waitFor('Wechsel nach Verwerfen', (r) => window.__t.markup().source === r, 5000, fbRel).catch(() => {});
  const swapped = await ev(() => window.__t.markup());
  check('Mit Zeichnung: Rückfrage, „Cancel“ behält sie, „Discard and switch“ öffnet das andere Bild', kept.source === 'skizze-b.png' && kept.shapes.length === 1
    && swapped.source === fbRel && swapped.shapes.length === 0, `${kept.source}/${kept.shapes.length} → ${swapped.source}/${swapped.shapes.length}`);
  await ev(() => document.body.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true })));
  fs.rmSync(imgB);
  const modelMenu = await ctx('model.py');
  check('Menü auf model.py: kein „Mark up“ (kein Bild)', !modelMenu?.includes('Mark up'));
  check('Menü auf model.py: Öffnen, Explorer, Pfad, Anlegen; Umbenennen und Löschen gesperrt', ['Open', 'Show in Explorer', 'Send path to agent', 'Copy path', 'New file', '-Rename', '-Delete'].every((x) => modelMenu?.includes(x)), modelMenu?.join(','));
  await ev(() => document.body.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true })));
  await domClick('btn-file-new');
  await sleep(50);
  const typed = await typeName('notiz.txt');
  const notiz = path.join(proj.dir, 'notiz.txt');
  await waitFor('Datei angelegt und offen', () => window.__t.editor.state().file === 'notiz.txt', 5000).catch(() => {});
  check('„New file“: Namensfeld im Baum, Enter legt sie an und öffnet sie im Editor', typed && fs.existsSync(notiz) && (await ev(() => window.__t.editor.state())).file === 'notiz.txt');
  await ev(() => window.__t.showPanel('files'));
  await waitFor('notiz.txt im Baum', () => window.__t.fileRows().includes('notiz.txt'), 5000).catch(() => {});
  await ctx('notiz.txt'); await menuItemClick('Rename'); await sleep(50);
  await typeName('model.py'); await sleep(300);
  const dupErr = await ev(() => ({ toast: window.__t.toast().text, open: !!document.querySelector('#tab-files .fedit') }));
  check('Umbenennen auf vorhandenen Namen: Meldung, Feld bleibt offen, nichts überschrieben', dupErr.open && dupErr.toast.includes('already exists there') && fs.existsSync(notiz)
    && fs.readFileSync(path.join(proj.dir, 'model.py'), 'utf8').includes('add_part'), dupErr.toast.slice(0, 60));
  await typeName('skizze.txt');
  const skizze = path.join(proj.dir, 'skizze.txt');
  await waitFor('umbenannt', () => window.__t.editor.state().files.includes('skizze.txt'), 5000).catch(() => {});
  const es = await ev(() => window.__t.editor.state());
  check('Umbenennen: Datei heißt neu, der offene Reiter zieht mit', fs.existsSync(skizze) && !fs.existsSync(notiz) && es.files.includes('skizze.txt') && !es.files.includes('notiz.txt'), es.files.join(','));
  await waitFor('skizze.txt im Baum', () => window.__t.fileRows().includes('skizze.txt'), 5000).catch(() => {});
  await app.answers([0]);
  await ev(() => { const r = document.querySelector('#tab-files .frow[data-path="skizze.txt"]'); r.focus(); r.dispatchEvent(new KeyboardEvent('keydown', { key: 'Delete', bubbles: true })); });
  await waitFor('gelöscht', () => !window.__t.fileRows().includes('skizze.txt'), 5000).catch(() => {});
  const bin = path.join(ud, 'test-papierkorb');
  check('Del mit Rückfrage: in den Papierkorb, Reiter zu', !fs.existsSync(skizze) && fs.existsSync(bin) && fs.readdirSync(bin).some((f) => f.endsWith('skizze.txt'))
    && !(await ev(() => window.__t.editor.state())).files.includes('skizze.txt'), fs.existsSync(bin) ? fs.readdirSync(bin).join(',') : 'kein Papierkorb');
  // Suche im Dateibaum: nur Treffer mit ihren Ordnern (aufgeklappt), Treffer hervorgehoben, Escape leert und klappt wieder zu
  const search = (q) => ev((v) => { const i = document.getElementById('files-filter'); i.value = v; i.dispatchEvent(new Event('input', { bubbles: true })); }, q);
  await search('MODEL');
  const found = await ev(() => ({ rows: window.__t.fileRows(), hits: [...document.querySelectorAll('#tab-files .fn .hit')].map((x) => x.textContent) }));
  check('Suche „MODEL“: model.py und output/model.step, sonst nichts, Treffer hervorgehoben', JSON.stringify(found.rows) === '["output","model.step","model.py"]'
    && found.hits.length === 2 && found.hits.every((x) => x === 'model'), JSON.stringify(found));
  await search('gibtsnicht');
  check('Suche ohne Treffer: Hinweis', (await ev(() => document.querySelector('#tab-files .hint')?.textContent ?? '')).startsWith('No file name contains'));
  await search('model');
  await ev(() => document.getElementById('files-filter').dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true })));
  const cleared = await ev(() => ({ value: document.getElementById('files-filter').value, rows: window.__t.fileRows() }));
  check('Escape: Suche leer, output/ wieder eingeklappt', cleared.value === '' && cleared.rows.includes('output') && !cleared.rows.includes('model.step') && cleared.rows.includes('Markups'), JSON.stringify(cleared.rows));
  await ctx(`.soma/feedback/${fbFiles[0]}`); await menuItemClick('Send path to agent');
  await waitFor('Pfad der Markierung im Terminal', (f) => window.__t.termText(f[0]).includes(`[File: .soma/feedback/${f[1]}]`), 5000, [tid, fbFiles[0]]).catch(() => {});
  check('Markierung: Rechtsklick „Send path to agent“ fügt den Pfad ein', (await ev((id) => window.__t.termText(id), tid)).includes(`[File: .soma/feedback/${fbFiles[0]}]`));
  await ev((id) => window.soma.term.write(id, '\x03'), tid);
  await shot('3b-dateien-menue');
  await ev(() => window.__t.showPanel(null));

  // 4) Auto-Build: Änderung an model.py -> neuer Build -> drittes Bauteil
  const modelPy = path.join(proj.dir, 'model.py');
  const original = fs.readFileSync(modelPy, 'utf8');
  const third = '\nadd_part("Third", cq.Workplane("XY").box(6, 6, 6).translate((60, 0, 0)))\n';
  fs.writeFileSync(modelPy, original + third);
  await waitFor('drittes Bauteil', () => window.__t.partCount() === 3 && window.__t.status().state === 'ok');
  check('Auto-Build: Änderung an model.py erscheint im Viewer', (await ev(() => window.__t.treeNames())).includes('Third'));

  // 5) Fehlerfall: kaputtes model.py -> Fehler mit Ort, alter Stand bleibt sichtbar
  fs.writeFileSync(modelPy, original + third + 'def kaputt(:\n');
  await waitFor('Fehlerstatus', () => window.__t.status().state === 'error');
  const err = await status();
  check('Syntaxfehler: Anzeige oben „Build failed" mit Datei und Zeile', err.text === 'Build failed' && /model\.py, line \d+/.test(err.detail), err.detail.slice(0, 70));
  check('Fehlerkarte im Viewer, letzter guter Stand (3 Bauteile) bleibt', err.viewerMsg.includes('Build failed') && await ev(() => window.__t.partCount()) === 3);
  const errText = await ev(() => window.__t.errorText());
  check('Fehlertext für den Agenten nennt Datei und Zeile', /^\[Build error: model\.py line \d+: /.test(errText), errText.slice(0, 60));
  await shot('4-fehler');
  await sleep(300);
  check('App reagiert weiter (Terminal aktiv, kein Absturz)', await ev(() => window.__t.terminals.count) === 1);

  // 6) Repariert -> wieder ok
  fs.writeFileSync(modelPy, original);
  await waitFor('Build ok nach Reparatur', () => window.__t.status().state === 'ok' && window.__t.partCount() === 2);
  check('Nach der Reparatur wieder ok, Fehlermeldung weg, 2 Bauteile', (await status()).viewerMsg === '');

  // 7) Auto-Build aus: Änderung bleibt liegen, erst der Knopf baut
  await domClick('chk-auto');
  fs.writeFileSync(modelPy, original + third);
  await sleep(3500);
  check('Auto-Build aus: keine Änderung im Viewer nach 3,5 s', await ev(() => window.__t.partCount()) === 2);
  await domClick('btn-build');
  await waitFor('Knopf-Build', () => window.__t.partCount() === 3 && window.__t.status().state === 'ok');
  check('Knopf „Build now" baut trotzdem (3 Bauteile)', true);
  fs.writeFileSync(modelPy, original);
  await waitFor('veraltet gemeldet', () => window.__t.status().text === 'Code changed', 10000).catch(() => {});
  check('Auto-Build aus: Anzeige meldet „Code changed"', (await status()).text === 'Code changed', (await status()).text);
  await domClick('chk-auto');
  await waitFor('Auto an baut nach', () => window.__t.partCount() === 2 && window.__t.status().state === 'ok', 60000).catch(() => {});
  check('Auto-Build wieder an: veralteter Stand wird gleich gebaut', await ev(() => window.__t.partCount()) === 2);

  // 7b) Ansicht: Würfel (Seite, Ecke, Ziehen), Drehpunkt per Doppelklick, Zoom zur Maus, Ansichten im Menü
  const vs = () => ev(() => window.__t.viewer.viewState());
  const settle = () => waitFor('Ansicht steht', () => !window.__t.viewer.viewState().animating, 5000).catch(() => {});
  const near = (a, b, tol = 1e-3) => a.every((v, i) => Math.abs(v - b[i]) < tol);
  const unit = (v) => { const l = Math.hypot(...v); return v.map((x) => x / l); };
  await ev(() => window.__t.viewer.setView('iso'));
  const v0 = await vs();
  check('Ansichtswürfel ist da (3D, eigene Zeichenfläche)', await ev(() => { const c = document.querySelector('#cube-view canvas'); return !!c && c.width > 0; }));
  await page.click(...Object.values(await ev(() => window.__t.viewer.cubeScreen([0, -1, 0]))));
  await settle();
  let v1 = await vs();
  check('Würfel „FRONT" anklicken: Ansicht von vorne, Drehpunkt und Abstand bleiben', near(v1.dir, [0, -1, 0]) && near(v1.target, v0.target) && Math.abs(v1.dist - v0.dist) < 1e-6, v1.dir.map((x) => x.toFixed(3)).join(','));
  await page.click(...Object.values(await ev(() => window.__t.viewer.cubeScreen([0.85, -1, 0.85]))));
  await settle();
  v1 = await vs();
  check('Ecke „oben vorne rechts" anklicken: Blick schräg von dort', near(v1.dir, unit([1, -1, 1])), v1.dir.map((x) => x.toFixed(3)).join(','));
  await ev((p) => {
    const c = document.querySelector('#cube-view canvas'), f = (type, x) => c.dispatchEvent(new PointerEvent(type, { clientX: x, clientY: p.y, bubbles: true, button: 0, buttons: 1, pointerId: 1 }));
    f('pointerdown', p.x); f('pointermove', p.x + 20); f('pointermove', p.x + 40); f('pointerup', p.x + 40);
  }, await ev(() => window.__t.viewer.cubeScreen([0, -1, 0])));
  const v2 = await vs();
  check('Würfel ziehen dreht die Ansicht um den Drehpunkt', !near(v2.dir, v1.dir, 1e-2) && near(v2.target, v1.target) && Math.abs(v2.dir[2] - v1.dir[2]) < 1e-6, v2.dir.map((x) => x.toFixed(3)).join(','));
  await ev(() => window.__t.viewer.setView('iso'));
  const corner = await ev(() => {
    const v = window.__t.viewer, id = window.__t.parts().find((p) => p.name === 'Lid').id;
    const f = v.facesOf(id).filter((x) => x.surface === 'PLANE').sort((a, b) => b.center[2] - a.center[2])[0];
    return { s: v.screenOf(id, f.id), c: f.center };
  });
  const before = await vs();
  await ev((p) => document.querySelector('#viewer > canvas').dispatchEvent(new MouseEvent('dblclick', { clientX: p.x, clientY: p.y, bubbles: true })), corner.s);
  await settle();
  const v3 = await vs();
  check('Doppelklick ins Modell: Drehpunkt dorthin, die Ansicht verschiebt sich nur (dreht nicht)', near(v3.target, corner.c, 0.2) && near(v3.dir, before.dir, 1e-6),
    `${v3.target.map((x) => x.toFixed(2)).join(',')} statt ${corner.c.join(',')}`);
  check('Zoom zur Mausposition an, vordere Schnittebene folgt dem Abstand', v3.zoomToCursor && Math.abs(v3.near - v3.dist / 200) < 1e-9 && v3.far > v3.dist, `near ${v3.near.toFixed(3)}, Abstand ${v3.dist.toFixed(1)}`);
  await ev(() => document.querySelector('#menu-display [data-view="back"]').click());
  check('Ansicht „Back" im Menü Display', near((await vs()).dir, [0, 1, 0]));
  await domClick(await ev(() => { const b = document.querySelector('.vbtns [data-view="iso"]'); b.id ||= 'btn-view-iso'; return b.id; }));
  check('Standardansicht setzt den Drehpunkt zurück in die Mitte des Modells', near((await vs()).target, v0.target, 1e-6));
  // Zum Ansehen: Zeiger über der Ecke oben vorne rechts (Felder in Orange)
  await ev((p) => document.querySelector('#cube-view canvas').dispatchEvent(new PointerEvent('pointermove', { clientX: p.x, clientY: p.y, bubbles: true, pointerId: 1 })),
    await ev(() => window.__t.viewer.cubeScreen([0.85, -0.85, 1])));
  await shot('8-ansichtswuerfel');
  await ev(() => document.querySelector('#cube-view canvas').dispatchEvent(new PointerEvent('pointerleave', { bubbles: true })));

  // 8) Neues Projekt: anderer Ordner, Terminals des alten sind zu, frischer erster Build
  await domClick('btn-new');
  await waitFor('neues Projekt', (oldId) => window.__t.project().id !== oldId && window.__t.status().state === 'ok' && window.__t.partCount() === 2, 90000, proj.id).catch(() => {});
  const p2 = await ev(() => window.__t.project());
  check('„Neu" legt ein zweites Projekt mit eigener UUID an', p2.id !== proj.id, p2.id.slice(0, 8));
  await sleep(600);
  check('Projektwechsel: genau ein frisches Terminal', await ev(() => window.__t.terminals.count) === 1);
  // Die alte Shell meldet ihr Ende erst nach dem Wechsel. Das darf das neue Terminal nicht als beendet markieren,
  // sonst lässt sich nichts mehr einfügen („Das Terminal ist beendet“), obwohl darin ein Agent läuft.
  await sleep(2500);
  await ev(() => window.__t.insert('[Test nach Wechsel] '));
  const afterSwitch = await ev(() => window.__t.toast());
  check('Nach dem Wechsel: Einfügen ins neue Terminal geht', !afterSwitch.error && afterSwitch.text.includes('Added to the input of Terminal'), afterSwitch.text.slice(0, 60));
  await ev(() => window.soma.term.write(window.__t.terminals.activeId, '\x03'));
  // Aktives Terminal beendet, ein anderes läuft noch: Der Text geht dorthin, und dieses kommt nach vorn
  const firstTid = await ev(() => window.__t.terminals.activeId);
  const secondTid = await ev(() => window.__t.terminals.add({ title: 'Zweites' }));
  await sleep(1500);
  await ev((id) => window.soma.term.write(id, 'exit\r'), secondTid);
  await waitFor('zweites Terminal beendet', (id) => window.__t.termText(id).includes('Process ended'), 10000, secondTid).catch(() => {});
  await ev(() => window.__t.insert('[Test Ersatzterminal] '));
  const fallback = await ev(() => window.__t.toast());
  await waitFor('Text im ersten Terminal', (id) => window.__t.termText(id).includes('[Test Ersatzterminal]'), 5000, firstTid).catch(() => {});
  check('Aktives Terminal beendet: Text geht ins zuletzt benutzte laufende, das nach vorn kommt', !fallback.error && await ev(() => window.__t.terminals.activeId) === firstTid
    && (await ev((id) => window.__t.termText(id), firstTid)).includes('[Test Ersatzterminal]'), fallback.text.slice(0, 60));
  await ev((id) => window.soma.term.write(id, '\x03'), firstTid);
  await ev((id) => window.__t.terminals.close(id), secondTid);
  check('Beide Arbeitsordner existieren getrennt', fs.existsSync(proj.dir) && fs.existsSync(p2.dir) && proj.dir !== p2.dir);

  if (app.visible) { await sleep(500); await page.screenshot(path.join(APP, 'test', 'smoke.png')); }
  if (process.env.SMOKE_SHOTS) {
    await ev(() => window.__t.showStart(true));
    await shot('5-startseite');
    await ev(() => window.__t.showStart(false));
    await ev(() => window.__t.setAgentCollapsed(true));
    await shot('6-agent-eingeklappt');
    await ev(() => window.__t.setAgentCollapsed(false));
  }
  const relevant = page.errors.filter((e) => !/favicon/i.test(e));
  check('Keine Konsolenfehler im Renderer', relevant.length === 0, relevant.slice(0, 2).join(' | ').slice(0, 100));
} catch (e) {
  console.log('ABBRUCH:', e.message);
  // Für Läufe, die man nur aus dem Protokoll kennt (CI): was Renderer und Hauptprozess bis dahin gemeldet haben
  if (app) {
    console.log('Fehler im Renderer:', app.page.errors.slice(0, 10).join('\n  ') || '(keine)');
    console.log('Ausgabe der App (Ende):\n' + app.log().slice(-4000));
  }
  t.fail();
}
if (app) { await app.stop(); cleanup(app.ud); }
console.log(t.fails ? `\n${t.fails} Prüfung(en) fehlgeschlagen` : '\nALLE PRÜFUNGEN BESTANDEN');
process.exit(t.fails ? 1 : 0);