Local code intelligence for developers and AI agents. Connect code, docs and infrastructure in a persistent graph, with CBM Lens, MCP tools, agent integrations and change-aware test selection.
C aiderastclaude-codecode-analysiscode-intelligencecodexcursorcypherdeveloper-toolsgemini-cligraph-visualizationkilocodeknowledge-graphmcpmcp-servermodel-context-protocolopencodesqlitetree-sitterwindsurf
#!/usr/bin/env node
/*
* W6a-Smoke: die GANZE Klickstrecke des Produkts, in einem Lauf, ohne Netz.
*
* Bis W5c hatte jeder Zyklus seinen eigenen Beweislauf, und jeder davon fuhr
* ein Stueck der Oberflaeche. Zusammen decken sie alles ab, und trotzdem fehlt
* eine Aussage: dass die Stuecke NEBENEINANDER funktionieren. Ein Panel, das
* allein gruen ist und neben dem Nachbarn ueberlaeuft, ist in keinem der
* einzelnen Laeufe rot. Dieser Lauf faehrt darum alles hintereinander, in
* einem Browser, auf einem Server, mit einem Index, und stellt an jedem Halt
* dieselben drei Fragen an das Bild.
*
* Ablauf:
* 1. `npm run build`
* 2. isoliertes HOME, eigenes Rendezvous-Verzeichnis
* 3. drei Projekte indizieren: die Fixture (nur gelesen), die grosse Fixture
* fuer die gekappte Datei (nur gelesen), und eine KOPIE der Fixture mit
* eigenem git-Repository und einer echten Aenderung fuer den Blast-Radius
* 4. C-Server auf einem freien Port >= 4340, dist/ auf einem zweiten
* 5. Chromium ohne Aussenwelt, plus Route-Sperre; 127.0.0.1:4141 ist
* ausdruecklich erlaubt und wird mitgezaehlt
* 6. die Strecke, Halt fuer Halt und jeder benannt
* 7. abraeumen, Restprozesse zaehlen, drei JSON und die Bilder schreiben
*
* Das Ganze laeuft unter dem Netz-Deny-Gate (npm run smoke:w6).
*
* ## Fuenf Entscheidungen, die man sonst raten muesste
*
* **Drei Projekte statt eines.** Die Strecke braucht drei verschiedene
* Ausgangslagen: eine unberuehrte Fixture fuer alles Lesende, eine grosse Datei
* fuer die Kappungszeile (die Aussage "hier hoert das Geladene auf" ist an einer
* 42-Zeilen-Datei nicht zu sehen), und eine geaenderte Kopie fuer die
* Aenderungsansicht. fixtures/ bleibt byte-identisch; die Kopie liegt in einem
* mkdtemp-Verzeichnis und verschwindet am Ende.
*
* **Der Lauf misst die Netzstille selbst.** Warum er sie nicht vom Gate
* abschreibt, steht im Kopf von tools/lib/socket-sampler.mjs. Kurz: das Gate
* schreibt sein Ergebnis erst, wenn dieser Lauf schon vorbei ist.
*
* **Das Lesbarkeits-Gate laeuft an JEDEM Halt, nicht an ausgewaehlten.** Die
* Regeln stehen in tools/lib/readability.mjs. Ein Halt, an dem nur ein
* Screenshot faellt, ist ein Halt, an dem niemand hingesehen hat.
*
* **Die warme Twin-Messung nimmt zehn VERSCHIEDENE Symbole.** Dasselbe Symbol
* zweimal zu oeffnen misst den Cache in src/twin/ir-cache.ts und nicht den
* Server. Warm heisst hier: der Server laeuft, sein Index ist gelesen, seine
* Seiten sind im Cache des Betriebssystems. Gemessen wird vom Klick auf den
* Treffer bis zu dem Moment, in dem der Twin das neue Subjekt fertig zeigt; das
* Tippen und die Entprellung davor stehen als `searchOverlayMs` getrennt.
*
* **Der Versions-Chip wird abgelesen, nicht gerechnet.** Er zeigt seit W6a nur
* die Fassung; der Zustand des Arbeitsbaums steht als eigenes Element daneben
* (src/app/build-info.ts). Beides wird gelesen und beides steht im Ergebnis,
* damit ein Bild dieses Laufs einer Fassung UND einem Baumzustand zuzuordnen
* ist.
*/
import { execFile, spawn } from 'node:child_process';
import { existsSync, readdirSync, readFileSync } from 'node:fs';
import { cp, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
import { tmpdir } from 'node:os';
import { dirname, join, resolve } from 'node:path';
import { fileURLToPath } from 'node:url';
import { promisify } from 'node:util';
import {
countListeners,
findFreePort,
indexRepository,
sleep,
startServer,
stopServer,
} from './lib/cbm-server.mjs';
import { startStaticProxy } from './lib/static-proxy.mjs';
import { startSocketSampler } from './lib/socket-sampler.mjs';
import {
DELIBERATE_OVERLAYS,
READABILITY_EXCLUSIONS,
measureReadability,
resetScroll,
scrollRegionsToEnd,
} from './lib/readability.mjs';
const execFileAsync = promisify(execFile);
const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
const BINARY = join(ROOT, 'cbm', 'build', 'c', 'codebase-memory-mcp');
const DIST = join(ROOT, 'dist');
const FIXTURE = join(ROOT, 'fixtures', 'atlas-sample');
const FIXTURE_LARGE = join(ROOT, 'fixtures', 'atlas-sample-large');
const OUT_DIR = join(ROOT, 'verification', 'w6');
const WALK_DIR = join(OUT_DIR, 'walk');
const AIRGAP_JSON = join(OUT_DIR, 'airgap.json');
const BUDGETS_JSON = join(OUT_DIR, 'budgets.json');
const EVAL_JSON = join(ROOT, 'verification', 'w5', 'eval.json');
/**
* Die Fassung, die der Chip zeigen muss, aus der einen Stelle, an der sie steht.
*
* Bis zum 2026-08-29 stand hier `'v1.0.0'` als Zahl in der Bedingung. Das war
* derselbe Fehler, gegen den dieser Zyklus geschrieben ist, nur eine Ebene
* tiefer: eine Behauptung ueber das Produkt an einem zweiten Ort, die falsch
* wird, sobald der erste sich aendert. Als der Eigentuemer die Fassung auf
* 0.0.1 setzte, war die Messung richtig und die Bedingung falsch. Die Zahl hat
* genau einen Ort, und das ist package.json.
*/
const EXPECTED_VERSION_CHIP = `v${JSON.parse(readFileSync(join(ROOT, 'package.json'), 'utf8')).version}`;
const PROJECT = 'codeatlasweb-w6';
const PROJECT_LARGE = 'codeatlasweb-w6-large';
const PROJECT_IMPACT = 'codeatlasweb-w6-impact';
const MIN_PORT = 4340;
const SIDECAR_PORT = 4141;
const SIDECAR_ORIGIN = `http://127.0.0.1:${SIDECAR_PORT}`;
const READY_TIMEOUT_MS = 240000;
const VIEWPORT = { width: 1680, height: 1050 };
/** Das Symbol, an dem Twin, Flow und Pseudocode gezeigt werden. */
const TARGET = 'createUser';
const TARGET_FILE = 'src/services/userService.ts';
const TARGET_QUALIFIED = 'userService\\.createUser';
/** Die grosse Datei, an der die Kappungszeile zu sehen ist. */
const LARGE_FILE = 'src/big.ts';
/** Die zehn verschiedenen Symbole der warmen Messung. */
const WARM_SYMBOLS = [
'listUsers', 'validateUser', 'getOrder', 'hotspotScan', 'insert',
'query', 'walk', 'registerUserRoutes', 'main', 'createUser',
];
/** Der Einstieg, an dem die Hierarchie gezeigt wird. */
const WALK_ENTRY = 'createUser';
/** Der Lauf, unter dem die Aufzeichnung eingespielt wird. Wie in W4b. */
const RUN_LABEL = 'w6-run';
const RUN_COUNT = 3;
/** Die Frage an den Atlas. Sie steht hier woertlich, weil sie der Beweis ist. */
const QUESTION = 'Wer ruft createUser?';
/** Die Modellwahl, mit der llm/start.sh den Klasse-A-Sieger startet. Wie in W5b. */
const CHOICE_OF = {
'Qwen3.5-2B': 'class-a',
'LFM2.5-1.2B': 'class-a-lfm',
'MiniCPM5-1B': 'class-a-minicpm',
'Qwen2.5-Coder-1.5B': 'class-a-coder',
'Qwen3.5-4B': 'class-b',
'gemma-4-E4B': 'class-b-gemma',
};
/**
* Die Aenderung an der Kopie, wortgleich mit tools/smoke-w4b.mjs.
*
* Beide Haelften sind noetig, und der Grund ist eine gemessene Eigenschaft des
* Servers: eine nur angehaengte Funktion, die niemand ruft, hat einen leeren
* Blast-Radius. Erst der Aufruf aus createUser heraus macht createUser zum
* Ausgangspunkt, und dessen Aufrufer sind die Route-Datei und der Server.
*/
const ADDED_FUNCTION = `
export function countUsers(): number {
return listUsers().length;
}
`;
const REWIRED_FROM = 'const entity = new UserEntity(`user-${listUsers().length + 1}`, parsed.email, parsed.name);';
const REWIRED_TO = 'const entity = new UserEntity(`user-${countUsers() + 1}`, parsed.email, parsed.name);';
/** Chromium ohne Aussenwelt, plus die Software-GL-Flags. Wortgleich mit W5c. */
const CHROMIUM_ARGS = [
'--host-resolver-rules=MAP * ~NOTFOUND, EXCLUDE 127.0.0.1, EXCLUDE localhost',
'--disable-background-networking',
'--disable-component-update',
'--disable-domain-reliability',
'--disable-client-side-phishing-detection',
'--disable-sync',
'--disable-default-apps',
'--no-first-run',
'--no-default-browser-check',
'--metrics-recording-only',
'--no-pings',
'--disable-breakpad',
'--disable-features=Translate,OptimizationHints,MediaRouter,AutofillServerCommunication,InterestFeedContentSuggestions,DialMediaRouteProvider,CalculateNativeWinOcclusion',
'--use-angle=swiftshader',
'--enable-unsafe-swiftshader',
'--ignore-gpu-blocklist',
];
const log = (...parts) => console.log('[smoke-w6]', ...parts);
const serverLog = [];
function run(command, args, options = {}) {
return new Promise((done) => {
const child = spawn(command, args, {
cwd: options.cwd ?? ROOT,
env: {
...process.env,
...(options.env ?? {}),
NO_UPDATE_NOTIFIER: '1',
npm_config_update_notifier: 'false',
npm_config_audit: 'false',
npm_config_fund: 'false',
},
stdio: ['pipe', 'pipe', 'pipe'],
});
let out = '';
let err = '';
child.stdout.on('data', (chunk) => {
out += chunk.toString();
});
child.stderr.on('data', (chunk) => {
err += chunk.toString();
});
child.on('error', (error) => done({ code: 127, out, err: err + error.message }));
child.on('close', (code) => done({ code: code ?? 1, out, err }));
if (options.stdin !== undefined) {
child.stdin.end(options.stdin);
} else {
child.stdin.end();
}
});
}
/** Ein Werkzeug ueber die CLI, mit dem HOME dieses Laufs. Wortgleich mit W4b. */
async function cli(tool, payload, home) {
const result = await run(BINARY, ['cli', tool], { env: { HOME: home }, stdin: `${JSON.stringify(payload)}\n` });
const line = result.out.split('\n').map((entry) => entry.trim()).filter(Boolean).pop();
if (result.code !== 0 || line === undefined) {
throw new Error(`cli ${tool} endete mit ${result.code}: ${result.err.trim().slice(-400)}`);
}
return JSON.parse(line);
}
/** Der Percentil-Wert einer Messreihe, nach der Nearest-Rank-Methode. */
function percentile(values, p) {
if (values.length === 0) {
return Number.NaN;
}
const sorted = [...values].sort((a, b) => a - b);
const rank = Math.ceil((p / 100) * sorted.length);
return sorted[Math.min(Math.max(rank, 1), sorted.length) - 1];
}
async function main() {
const totalStarted = Date.now();
let serverChild = null;
let proxy = null;
let browser = null;
let home = null;
let runtimeDir = null;
let workspace = null;
let serverPort = 0;
let uiPort = 0;
let failure = null;
let sidecarStarted = false;
const timings = {};
const result = {
outboundViolations: 0,
samples: 0,
clickSteps: 0,
pageErrors: 0,
consoleErrors: 0,
leftoverProcesses: 0,
chatCitationClicked: false,
/*
* Die zwei Aussagen der Audit-Befunde 12 und 13, als eigene Zahlen im
* Ergebnis. Sie stehen hier oben und nicht nur in `extras`, weil sie
* jetzt zur Strecke gehoeren: ein Halt, dessen Ergebnis man nur im
* Anhang findet, ist ein Halt, den beim naechsten Mal niemand ansieht.
*/
atlasRowShortcutsShown: false,
atlasRowOpenedByKey: false,
tourDiagramOpened: false,
overlapViolations: 0,
clippingViolations: 0,
scrolledRegions: 0,
versionChipShown: '',
versionChipExpected: EXPECTED_VERSION_CHIP,
buildSuffixShown: '',
screenshots: 0,
};
const budgets = {
twinWarmP95Ms: Number.NaN,
twinWarmSamples: 0,
twinColdMs: Number.NaN,
searchOverlayMs: Number.NaN,
galaxyLoadMs: Number.NaN,
};
const extras = {
blockedRequests: [],
consoleErrors: [],
pageErrors: [],
sidecarRequests: [],
failedResponses: [],
steps: [],
overlaps: [],
clipped: [],
scrolledRegionNames: [],
warmSamples: [],
};
const sampler = startSocketSampler({ intervalMs: 1000 });
try {
if (!existsSync(BINARY)) {
throw new Error(`Binary fehlt: ${BINARY} (erst 'make -f Makefile.cbm cbm-with-ui' im cbm-Clone bauen)`);
}
for (const fixture of [FIXTURE, FIXTURE_LARGE]) {
if (!existsSync(fixture)) {
throw new Error(`Fixture fehlt: ${fixture}`);
}
}
if (!existsSync(join(ROOT, 'vendor', 'llama', 'llama-server'))) {
throw new Error('vendor/llama/llama-server fehlt (siehe vendor/llama/HERKUNFT.md)');
}
if (!existsSync(EVAL_JSON)) {
throw new Error(`${EVAL_JSON} fehlt: erst 'npm run eval:llm' fahren.`);
}
const evalReport = JSON.parse(await readFile(EVAL_JSON, 'utf8'));
const winner = evalReport?.winnerClassA?.name ?? '';
const choice = CHOICE_OF[winner];
if (choice === undefined) {
throw new Error(`unbekannter Klasse-A-Sieger in eval.json: "${winner}"`);
}
extras.winner = { name: winner, choice };
log(`Klasse-A-Sieger aus eval.json: ${winner} (llm/start.sh ${choice})`);
// ------------------------------------------------------------ 1. Bau
log('npm run build');
const buildStarted = Date.now();
const build = await run('npm', ['run', 'build']);
timings.buildMs = Date.now() - buildStarted;
if (build.code !== 0) {
throw new Error(`npm run build endete mit ${build.code}: ${(build.out + build.err).trim().slice(-800)}`);
}
if (!existsSync(join(DIST, 'index.html'))) {
throw new Error('dist/index.html fehlt nach dem Build');
}
// ---------------------------------------------- 2. HOME, Rendezvous
home = await mkdtemp(join(tmpdir(), 'codeatlasweb-w6-home-'));
runtimeDir = await mkdtemp('/private/tmp/codeatlasweb-w6-run-');
process.env.CBM_RUNTIME_DIR = runtimeDir;
workspace = await mkdtemp(join(tmpdir(), 'codeatlasweb-w6-fixture-'));
log('isoliertes HOME:', home);
log('Rendezvous:', runtimeDir);
// ------------------------------------ 3. Die drei Projekte im Index
const indexed = await indexRepository(BINARY, { home, repoPath: FIXTURE, project: PROJECT });
extras.indexed = { nodes: indexed.nodes, edges: indexed.edges };
const indexedLarge = await indexRepository(
BINARY, { home, repoPath: FIXTURE_LARGE, project: PROJECT_LARGE },
);
extras.indexedLarge = { nodes: indexedLarge.nodes, edges: indexedLarge.edges };
const repo = join(workspace, 'atlas-sample');
await cp(FIXTURE, repo, { recursive: true });
const git = (...args) =>
execFileAsync('git', args, {
cwd: repo,
env: { ...process.env, GIT_CONFIG_GLOBAL: '/dev/null', GIT_CONFIG_SYSTEM: '/dev/null' },
});
await git('init', '-q', '-b', 'main');
await git('config', 'user.name', 'codeatlasweb-smoke');
await git('config', 'user.email', 'smoke@localhost');
await git('add', '-A');
await git('commit', '-q', '-m', 'the fixture as it stands');
const changedFile = join(repo, TARGET_FILE);
const original = await readFile(changedFile, 'utf8');
if (!original.includes(REWIRED_FROM)) {
throw new Error(`die Fixture-Kopie enthaelt die erwartete Zeile nicht: ${REWIRED_FROM}`);
}
await writeFile(changedFile, original.replace(REWIRED_FROM, REWIRED_TO) + ADDED_FUNCTION, 'utf8');
const indexedImpact = await indexRepository(
BINARY, { home, repoPath: repo, project: PROJECT_IMPACT },
);
extras.indexedImpact = { nodes: indexedImpact.nodes, edges: indexedImpact.edges };
log(`indiziert: ${indexed.nodes}/${indexedLarge.nodes}/${indexedImpact.nodes} Knoten`);
// ------------------------------------------------- 4. Server, Proxy
serverPort = await findFreePort(MIN_PORT);
const started = await startServer(BINARY, { home, port: serverPort, log: serverLog });
serverChild = started.child;
timings.serverStartMs = started.durationMs;
uiPort = await findFreePort(MIN_PORT, [serverPort]);
proxy = await startStaticProxy({ distDir: DIST, upstreamPort: serverPort, port: uiPort });
extras.serverPort = serverPort;
extras.uiPort = uiPort;
log(`C-Server auf ${serverPort}, dist/ auf ${uiPort}`);
const busyBefore = await countListeners(SIDECAR_PORT);
extras.sidecarListenersBefore = busyBefore;
if (busyBefore > 0) {
throw new Error(`auf ${SIDECAR_PORT} lauscht schon etwas (${busyBefore}); erst llm/stop.sh fahren`);
}
// ------------------------------------------------------- 5. Browser
const { chromium } = await import('playwright');
browser = await chromium.launch({ headless: true, args: CHROMIUM_ARGS });
const origin = `http://127.0.0.1:${uiPort}`;
const context = await browser.newContext({ viewport: { ...VIEWPORT } });
await context.route('**/*', async (route) => {
const url = route.request().url();
if (url.startsWith(SIDECAR_ORIGIN)) {
extras.sidecarRequests.push({ url, atMs: Date.now() - totalStarted });
await route.continue();
return;
}
if (url.startsWith(origin) || url.startsWith('data:') || url.startsWith('blob:')) {
await route.continue();
return;
}
extras.blockedRequests.push(url);
await route.abort();
});
const page = await context.newPage();
page.on('console', (message) => {
if (message.type() === 'error') {
// Mit Herkunft: eine Konsolenzeile ohne Fundstelle ist ein
// Befund, den niemand nachsehen kann.
const where = message.location();
extras.consoleErrors.push({
text: message.text(),
url: where?.url ?? '',
line: where?.lineNumber ?? 0,
});
}
});
// Jede Antwort, die kein Erfolg war, mit ihrer Adresse. Der Browser
// schreibt fuer sie eine Konsolenzeile ohne Adresse; diese hier hat eine.
page.on('response', (response) => {
if (response.status() >= 400) {
extras.failedResponses.push({ url: response.url(), status: response.status() });
}
});
page.on('pageerror', (error) => extras.pageErrors.push(String(error)));
// Die Bilder des letzten Laufs weg, bevor die dieses Laufs entstehen:
// eine Zahl, die alte Bilder mitzaehlt, waere keine Zahl ueber diesen Lauf.
await rm(WALK_DIR, { recursive: true, force: true });
await mkdir(WALK_DIR, { recursive: true });
// ------------------------------------------------------ Die Halte --
/**
* Ein benannter Halt: messen, scrollen, wieder messen.
*
* Der zweite Durchgang ist der Punkt: ein Panel, das oben ordentlich
* aussieht und unten kollidiert, kollidiert.
*/
const halt = async (name, options = {}) => {
const before = await measureReadability(page);
const scrolled = options.scroll === false ? [] : await scrollRegionsToEnd(page);
let after = null;
if (scrolled.length > 0) {
await page.waitForTimeout(180);
after = await measureReadability(page);
await resetScroll(page);
await page.waitForTimeout(120);
}
const overlaps = [...before.overlaps, ...(after?.overlaps ?? [])];
const clipped = [...before.clipped, ...(after?.clipped ?? [])];
for (const entry of overlaps) {
extras.overlaps.push({ step: name, ...entry });
}
for (const entry of clipped) {
extras.clipped.push({ step: name, ...entry });
}
for (const region of scrolled) {
if (!extras.scrolledRegionNames.includes(region.name)) {
extras.scrolledRegionNames.push(region.name);
}
}
result.clickSteps += 1;
result.overlapViolations += overlaps.length;
result.clippingViolations += clipped.length;
extras.steps.push({
step: result.clickSteps,
name,
atMs: Date.now() - totalStarted,
candidates: before.candidates,
layers: before.layers,
scrolledRegions: scrolled.map((region) => region.name),
overlaps: overlaps.length,
clipped: clipped.length,
});
log(`Halt ${String(result.clickSteps).padStart(2, '0')} ${name}: `
+ `${before.candidates} Textelemente, ${scrolled.length} Bereiche gescrollt, `
+ `${overlaps.length} Ueberlagerungen, ${clipped.length} Beschneidungen`);
if (options.shot !== undefined) {
await page.screenshot({ path: join(WALK_DIR, options.shot), fullPage: false });
}
};
/** Die Seite laden. Liefert den Zeitpunkt, an dem die Fahrt begann. */
const openApp = async (project) => {
const navigated = Date.now();
await page.goto(`${origin}/?project=${project}`, { waitUntil: 'load' });
await page.waitForSelector('[data-testid="atlas-statusbar"]', { timeout: 30000 });
await page.waitForSelector('[data-testid="atlas-tree-row"]', { timeout: 30000 });
return navigated;
};
const expandAll = async () => {
for (let round = 0; round < 12; round += 1) {
const clicked = await page.evaluate(() => {
const rows = [...document.querySelectorAll(
'[data-testid="atlas-tree-row"][data-kind="dir"][data-expanded="false"]',
)];
for (const row of rows) {
row.click();
}
return rows.length;
});
if (clicked === 0) {
return round;
}
await page.waitForTimeout(400);
}
return 12;
};
/** Tippen bis der Treffer dasteht. Liefert, wie lange das Fenster brauchte. */
const typeQuery = async (name) => {
const input = page.locator('[data-testid="atlas-command-input"]');
await input.click();
await input.fill('');
const typed = Date.now();
await input.pressSequentially(name, { delay: 30 });
await page.waitForSelector(
`[data-testid="atlas-search-row"][data-name="${name}"]`,
{ timeout: 30000 },
);
const shown = Date.now() - typed;
await page.waitForTimeout(500);
return shown;
};
/** Den Treffer waehlen und warten, bis der Twin ihn fertig zeigt. */
const chooseHit = async (name, expectQualified) => {
const clicked = Date.now();
await page.click(`[data-testid="atlas-search-row"][data-name="${name}"]`);
await page.waitForFunction(
(expected) => new RegExp(`${expected}$`).test(globalThis.__atlasTwin?.qualifiedName ?? ''),
expectQualified,
{ timeout: 60000 },
);
/*
* Fertig heisst: das Panel steht auf `ready`, nicht "irgendein
* Element ist da". Die Marke der Faktenliste haengt an der
* gewaehlten Sprachstufe und waere darum eine Bedingung, die je
* nach Leseprofil nie eintritt.
*/
await page.waitForFunction(
() => document.querySelector('[data-testid="atlas-twin"]')
?.getAttribute('data-status') === 'ready',
undefined,
{ timeout: 60000 },
);
return Date.now() - clicked;
};
const setDepth = async (depth) => {
await page.locator('[data-testid="atlas-twin-depth"]').fill(String(depth));
await page.waitForFunction(
(expected) =>
document.querySelector('[data-testid="atlas-twin-depth"]')?.value === String(expected),
depth,
{ timeout: 10000 },
);
await page.waitForTimeout(250);
};
const openWhyAndChoose = async (intent) => {
await page.click('[data-menu="a-why"]');
await page.waitForSelector('[data-testid="atlas-why"]', { timeout: 20000 });
await page.click(`[data-testid="atlas-why-card"][data-intent="${intent}"]`);
};
/*
* Eine Taste druecken, waehrend nirgends getippt wird.
*
* Seit W7a (Nutzerbefund 2026-08-29) tragen die Menuekuerzel
* Alt/Option: ein blanker Buchstabe ist Text und faellt in die
* Kommandozeile, statt im Hintergrund ein Panel zu oeffnen. Die
* Zusicherung dieses Laufs bleibt dieselbe und wird sogar schaerfer:
* geprueft wird weiterhin, dass der Eintrag ueber die TASTE erreichbar
* ist, jetzt aber ueber die Taste, die er laut Menuezeile und Hilfe
* wirklich hat. Bliebe sie wirkungslos, liefe der Lauf in die
* Zeitueberschreitung.
*/
const pressGlobally = async (key) => {
await page.click('.atlas-brand');
await page.keyboard.press(key);
};
/** Ein Menuekuerzel: derselbe Weg, mit dem Modifikator, den es braucht. */
const pressMenuShortcut = async (letter) => {
await pressGlobally(`Alt+${letter}`);
};
// ------------------------------------------- 6a. Baum und Legende
/*
* Die Ladezeit des Graph-Panels: vom Aufruf der Adresse bis das Panel
* wirklich Knoten hat.
*
* Vom Aufruf an und nicht ab dem Moment, in dem der Baum steht: Baum
* und Layout werden nebeneinander geholt, und wer ab dem Baum misst,
* misst die Differenz zweier gleichzeitiger Antworten und nennt sie
* Ladezeit. Die blosse Szene im DOM waere ebenfalls zu frueh; sie steht
* schon da, bevor /api/layout geantwortet hat.
*/
const galaxyStarted = await openApp(PROJECT);
await page.waitForSelector('[data-testid="atlas-galaxy-scene"]', { timeout: 60000 });
await page.waitForFunction(
() => (globalThis.__atlasGalaxy?.nodes ?? 0) > 0,
undefined,
{ timeout: 60000 },
);
budgets.galaxyLoadMs = Date.now() - galaxyStarted;
const version = await page.evaluate(() => ({
chip: document.querySelector('[data-testid="atlas-version"]')?.textContent?.trim() ?? '',
suffix: document.querySelector('[data-testid="atlas-version-suffix"]')?.textContent?.trim() ?? '',
}));
result.versionChipShown = version.chip;
result.buildSuffixShown = version.suffix;
log(`Versions-Chip "${version.chip}" (erwartet ${EXPECTED_VERSION_CHIP}), `
+ `Bau-Zusatz "${version.suffix}"`);
await halt('app-open', { shot: '01-app-open.png' });
const rounds = await expandAll();
extras.expandRounds = rounds;
await halt('explorer-expanded', { shot: '02-explorer-expanded.png' });
const legend = await page.evaluate(() => ({
entries: [...document.querySelectorAll('[data-testid="atlas-tree-legend-entry"]')]
.map((entry) => entry.textContent?.replace(/\s+/g, ' ').trim() ?? ''),
dots: document.querySelectorAll('[data-testid="atlas-tree-dot"]').length,
source: document.querySelector('[data-testid="atlas-tree-legend-source"]')
?.textContent?.trim() ?? '',
}));
extras.legend = legend;
await halt('explorer-coverage-legend', { shot: '03-explorer-coverage-legend.png' });
// ------------------------------------------------------ 6b. Reader
await page.click(`[data-testid="atlas-tree-row"][data-path="${TARGET_FILE}"]`);
await page.waitForFunction(
(expected) => globalThis.__atlasReader?.document?.path === expected,
TARGET_FILE,
{ timeout: 40000 },
);
await halt('reader-open-file', { shot: '04-reader-open-file.png' });
// Die gekappte Datei steht im zweiten Projekt: an 42 Zeilen ist die
// Kappungszeile nicht zu sehen, und ohne sie waere die Strecke um genau
// die Aussage aermer, um die es hier geht.
await openApp(PROJECT_LARGE);
await expandAll();
await page.click(`[data-testid="atlas-tree-row"][data-path="${LARGE_FILE}"]`);
await page.waitForFunction(
() => globalThis.__atlasReader?.status === 'ready',
undefined,
{ timeout: 40000 },
);
const capped = await page.evaluate(() => ({
truncated: globalThis.__atlasReader?.document?.truncated === true,
note: document.querySelector('[data-testid="atlas-truncation"]')?.textContent?.trim() ?? '',
}));
extras.cappedFile = capped;
log(`gekappte Datei: truncated=${capped.truncated}, Zeile "${capped.note.slice(0, 80)}"`);
await halt('reader-capped-file', { shot: '05-reader-capped-file.png' });
// ------------------------------------------- 6c. Twin, alle Tiefen
await openApp(PROJECT);
await expandAll();
budgets.searchOverlayMs = await typeQuery(TARGET);
await halt('search-overlay-open', { shot: '06-search-overlay.png' });
budgets.twinColdMs = await chooseHit(TARGET, TARGET_QUALIFIED);
log(`Twin kalt: ${budgets.twinColdMs} ms, Suchfenster ${budgets.searchOverlayMs} ms`);
for (const depth of [0, 1, 2, 3]) {
await setDepth(depth);
await halt(`twin-depth-${depth}`, depth === 3 ? { shot: '07-twin-depth-3.png' } : {});
}
const evidenceButtons = await page.locator('[data-testid="codeatlas-evidence-btn"]').count();
extras.evidenceButtons = evidenceButtons;
if (evidenceButtons > 0) {
await page.locator('[data-testid="codeatlas-evidence-btn"]').first().click();
await page.waitForSelector('[data-testid="codeatlas-evidence-popover"]', { timeout: 15000 });
extras.evidenceText = await page.evaluate(
() => document.querySelector('[data-testid="codeatlas-evidence-popover"]')
?.textContent?.replace(/\s+/g, ' ').trim() ?? '',
);
}
await halt('twin-evidence', { shot: '08-twin-evidence.png' });
if (evidenceButtons > 0) {
await page.locator('[data-testid="codeatlas-evidence-btn"]').first().click();
await page.waitForTimeout(200);
}
// ------------------------------------------- 6d. Flow und Stepper
await page.click('[data-testid="atlas-twin-subject"]');
await page.waitForSelector('[data-testid="atlas-flow-overlay"]', { timeout: 30000 });
await page.waitForFunction(
() => Number(document.querySelector('[data-testid="atlas-flow"]')
?.getAttribute('data-arrows') ?? '0') > 0,
undefined,
{ timeout: 60000 },
);
extras.flow = await page.evaluate(() => {
const box = document.querySelector('[data-testid="atlas-flow"]');
return {
arrows: Number(box?.getAttribute('data-arrows') ?? '0'),
steps: Number(box?.getAttribute('data-steps') ?? '0'),
lifelines: document.querySelectorAll('[data-testid="atlas-flow-lifeline"]').length,
title: document.querySelector('[data-testid="atlas-flow-overlay-title"]')
?.textContent?.trim() ?? '',
};
});
await halt('flow-overlay-open', { shot: '09-flow-overlay.png' });
await page.click('[data-testid="atlas-flow-next"]');
await page.waitForFunction(
() => document.querySelector('[data-testid="atlas-flow"]')
?.getAttribute('data-active-step') === '0',
undefined,
{ timeout: 15000 },
);
await page.waitForTimeout(400);
await page.click('[data-testid="atlas-flow-next"]');
await page.waitForFunction(
() => document.querySelector('[data-testid="atlas-flow"]')
?.getAttribute('data-active-step') === '1',
undefined,
{ timeout: 15000 },
);
await page.waitForTimeout(400);
extras.flowStepper = await page.evaluate(() => ({
position: document.querySelector('[data-testid="atlas-flow-position"]')?.textContent?.trim() ?? '',
readerLine: globalThis.__atlasReader?.editor?.getPosition?.()?.lineNumber ?? 0,
readerPath: globalThis.__atlasReader?.document?.path ?? '',
}));
await halt('flow-stepper-second-step', { shot: '10-flow-stepper.png' });
await page.keyboard.press('Escape');
await page.waitForSelector('[data-testid="atlas-flow-overlay"]', { state: 'detached', timeout: 15000 })
.catch(() => undefined);
// -------------------------------------------- 6e. Pseudocode-Ansicht
await page.click('[data-testid="atlas-pseudocode-toggle"]');
await page.waitForSelector('[data-testid="atlas-pseudocode"]', { timeout: 20000 });
extras.pseudocode = await page.evaluate(() => ({
lines: document.querySelectorAll('[data-testid="atlas-pseudocode-line"]').length,
imports: document.querySelectorAll('[data-testid="atlas-pseudocode-import"]').length,
title: document.querySelector('[data-testid="atlas-pseudocode-title"]')?.textContent?.trim() ?? '',
}));
await halt('pseudocode-view', { shot: '11-pseudocode.png' });
// ---------------------------------- 6f. Suche mit Enter, und Budgets
await typeQuery('loadConfig');
await page.locator('[data-testid="atlas-command-input"]').press('Enter');
await page.waitForFunction(
() => (globalThis.__atlasReader?.document?.path ?? '').length > 0,
undefined,
{ timeout: 40000 },
);
extras.enterOpened = await page.evaluate(() => ({
path: globalThis.__atlasReader?.document?.path ?? '',
twin: globalThis.__atlasTwin?.qualifiedName ?? '',
}));
await halt('search-enter-opens', { shot: '12-search-enter.png' });
/*
* Zehn warme Wechsel, jeder auf ein anderes Symbol, nach einem Neuladen.
*
* Das Neuladen leert den Cache in src/twin/ir-cache.ts. Ohne es waere
* eine der zehn Messungen ein Cache-Treffer nahe null, und ein p95 mit
* einem geschenkten Wert darin ist kein p95 dieses Servers. Der Server
* bleibt dabei warm: er laeuft seit Minuten und hat den Index gelesen,
* und genau das heisst hier warm.
*/
await openApp(PROJECT);
for (const symbol of WARM_SYMBOLS) {
await typeQuery(symbol);
const ms = await chooseHit(symbol, symbol);
extras.warmSamples.push({ symbol, ms });
}
const warm = extras.warmSamples.map((entry) => entry.ms);
budgets.twinWarmSamples = warm.length;
budgets.twinWarmP95Ms = percentile(warm, 95);
log(`Twin warm: ${warm.length} Messungen, p95 ${budgets.twinWarmP95Ms} ms, `
+ `min ${Math.min(...warm)} ms, max ${Math.max(...warm)} ms`);
await halt('twin-warm-budget', { shot: '13-twin-warm.png' });
// ------------------------------------------------- 6g. Galaxy
await page.waitForSelector('[data-testid="atlas-galaxy-scene"]', { timeout: 60000 });
await page.click('[data-testid="atlas-galaxy-legend-toggle"]');
await page.waitForSelector('[data-testid="atlas-galaxy-legend"]', { timeout: 15000 });
await page.waitForTimeout(400);
extras.galaxyLegend = await page.evaluate(() => ({
entries: [...document.querySelectorAll('[data-testid="atlas-galaxy-legend-entry"]')]
.map((entry) => entry.textContent?.replace(/\s+/g, ' ').trim() ?? ''),
headline: document.querySelector('[data-testid="atlas-galaxy-headline"]')?.textContent?.trim() ?? '',
}));
await halt('galaxy-legend-open', { shot: '14-galaxy-legend.png' });
await page.click('[data-testid="atlas-galaxy-legend-toggle"]');
await page.waitForTimeout(300);
/*
* ------------------------------- 6g-b. Die Buchstaben der Atlas-Zeile
*
* Befund 12 des unabhaengigen Audits: die vier Eintraege der Atlas-Zeile
* trugen keinen Buchstaben, in einer Oberflaeche, deren ganzes Vorbild
* die Tastatur ist. Dieser Halt liest, was auf ihnen STEHT, und oeffnet
* die Frage nach dem Warum danach mit der Taste und nicht mit der Maus.
*
* Beides zusammen ist der Beweis: ein Etikett, das `[w]hy` sagt, waehrend
* `w` nichts tut, waere schlimmer als eines ohne Klammer.
*/
extras.atlasRow = await page.evaluate(() => {
const items = [...document.querySelectorAll('[data-menu^="a-"]')];
return items.map((item) => ({
menu: item.getAttribute('data-menu') ?? '',
label: item.textContent?.replace(/\s+/g, ' ').trim() ?? '',
letter: /\[([a-z])\]/.exec(item.textContent ?? '')?.[1] ?? '',
title: item.getAttribute('title') ?? '',
}));
});
/*
* Gezaehlt wird nicht mehr auf eine feste Zahl.
*
* Bis W8 waren es vier Aktionen, seit W8 sind es fuenf ("[r]eset
* layout" kam dazu, weil ein verstellbares Layout einen Weg zurueck
* braucht). Die Zusicherung war nie die Zahl, sondern: jede Aktion
* traegt ihren eigenen Buchstaben, und keiner kommt doppelt vor. Genau
* das steht jetzt da, und die Zeile darf wachsen, ohne dass dieser
* Beweis dabei etwas anderes behauptet als vorher.
*/
result.atlasRowShortcutsShown = extras.atlasRow.length >= 4
&& extras.atlasRow.every((entry) => entry.letter.length === 1)
&& new Set(extras.atlasRow.map((entry) => entry.letter)).size
=== extras.atlasRow.length;
log(`Atlas-Zeile: ${extras.atlasRow.map((e) => e.label).join(' ')} `
+ `(alle mit eigenem Buchstaben: ${result.atlasRowShortcutsShown})`);
await pressMenuShortcut('w');
await page.waitForSelector('[data-testid="atlas-why"]', { timeout: 20000 });
await page.waitForTimeout(400);
result.atlasRowOpenedByKey = true;
await halt('atlas-row-shortcuts', { shot: '14b-atlas-row-shortcuts.png' });
// Wieder zu, ueber den ehrlichen Ausgang der Karte: die Frage soll die
// Strecke danach nicht verstellen.
await page.click('[data-testid="atlas-why-decline"]');
await page.waitForSelector('[data-testid="atlas-why"]', { state: 'detached', timeout: 15000 })
.catch(() => undefined);
await page.waitForTimeout(300);
// ------------------------------------------------------ 6h. Why
await openWhyAndChoose('understand');
await page.waitForSelector('[data-testid="atlas-tour"]', { timeout: 60000 });
await page.waitForFunction(() => (globalThis.__atlasTour?.steps ?? 0) > 0, undefined, {
timeout: 60000,
});
await page.waitForTimeout(600);
await halt('why-answered-tour-start', { shot: '15-tour-step-1.png' });
for (const step of [1, 2]) {
await pressGlobally('Enter');
await page.waitForFunction(
(expected) => globalThis.__atlasTour?.index === expected,
step,
{ timeout: 40000 },
);
await page.waitForTimeout(900);
await halt(`tour-step-${step + 1}`, step === 2 ? { shot: '16-tour-step-3.png' } : {});
}
extras.tour = await page.evaluate(() => ({
kind: globalThis.__atlasTour?.kind ?? '',
steps: globalThis.__atlasTour?.steps ?? 0,
index: globalThis.__atlasTour?.index ?? -1,
title: globalThis.__atlasTour?.title ?? '',
}));
// ------------------------------------------------- 6i. Entry-Walk
await openWhyAndChoose('entry');
await page.waitForSelector('[data-testid="atlas-entry"]', { timeout: 40000 });
await page.waitForSelector('[data-testid="atlas-entry-row"]', { timeout: 60000 });
await halt('entry-dialog-open', { shot: '17-entry-dialog.png' });
const entryInput = page.locator('[data-testid="atlas-entry-input"]');
await entryInput.click();
await entryInput.fill('');
await entryInput.pressSequentially(WALK_ENTRY, { delay: 30 });
await page.waitForSelector(
`[data-testid="atlas-entry-hit"][data-name="${WALK_ENTRY}"]`,
{ timeout: 30000 },
);
await page.waitForTimeout(600);
await page.click(`[data-testid="atlas-entry-hit"][data-name="${WALK_ENTRY}"]`);
await page.waitForFunction(() => globalThis.__atlasTour?.kind === 'entry', undefined, { timeout: 60000 });
await page.waitForFunction(
() => (globalThis.__atlasGalaxy?.hierarchy?.nodes ?? 0) > 0,
undefined,
{ timeout: 60000 },
);
await page.waitForTimeout(1500);
extras.walk = await page.evaluate(() => ({
mode: globalThis.__atlasGalaxy?.mode ?? '',
nodes: globalThis.__atlasGalaxy?.hierarchy?.nodes ?? 0,
depth: globalThis.__atlasGalaxy?.hierarchy?.depth ?? 0,
}));
await halt('entry-walk-hierarchy', { shot: '18-entry-walk-hierarchy.png' });
/*
* ------------------------- 6i-b. Die Aktion [d] auf der Schrittkarte
*
* Befund 13 des unabhaengigen Audits: PLAN Abschnitt 4 zaehlt
* `[d] diagram` zu den Aktionen der unteren Karte, und der Erklaerer
* hing stattdessen am flow()-Kopf des Twins. Gezeigt wird hier der Weg,
* den ein Leser waehrend einer Fuehrung nimmt: Taste auf der Karte, Bild
* zum Schritt, Escape zurueck.
*
* Am Vorwaerts-Walk und nicht an der Projekt-Fuehrung, und das ist kein
* Zufall: die Schritte eines Vorwaerts-Walks sind Symbole, also hat
* jeder von ihnen einen Flow. Ein Dateischritt haette keinen, und die
* Karte sagt das dort ehrlich statt einen Knopf anzubieten, der nichts
* zeichnen kann; genau diese Lesung steht als `tourDiagram` daneben.
*/
extras.tourDiagram = await page.evaluate(() => {
const button = document.querySelector('[data-testid="atlas-tour-diagram"]');
return {
present: button !== null,
label: button?.textContent?.replace(/\s+/g, ' ').trim() ?? '',
available: button?.getAttribute('data-available') ?? '',
disabled: button?.hasAttribute('disabled') ?? false,
title: button?.getAttribute('title') ?? '',
};
});
log(`Karten-Aktion: "${extras.tourDiagram.label}" `
+ `(bedienbar: ${extras.tourDiagram.available})`);
await pressGlobally('d');
await page.waitForSelector('[data-testid="atlas-flow-overlay"]', { timeout: 30000 });
await page.waitForFunction(
() => Number(document.querySelector('[data-testid="atlas-flow"]')
?.getAttribute('data-arrows') ?? '0') > 0,
undefined,
{ timeout: 60000 },
);
await page.waitForTimeout(400);
extras.tourDiagramFlow = await page.evaluate(() => {
const box = document.querySelector('[data-testid="atlas-flow"]');
return {
arrows: Number(box?.getAttribute('data-arrows') ?? '0'),
steps: Number(box?.getAttribute('data-steps') ?? '0'),
title: document.querySelector('[data-testid="atlas-flow-overlay-title"]')
?.textContent?.trim() ?? '',
/*
* Ob die Fuehrung weiterlaeuft, wird am Zustand gefragt und
* nicht am Bild.
*
* Bis W8 stand die Tour-Karte als eigene Flaeche im Baum, und
* ihre Anwesenheit war ein brauchbarer Ersatz fuer die Frage.
* Seit W8 teilen sich Flow und Fuehrung einen Platz mit
* Reitern, und es haengt immer nur der sichtbare im DOM: die
* Karte ist beim geoeffneten Diagramm also ausgehaengt,
* waehrend die Fuehrung sehr wohl weiterlaeuft. Die Naht sagt,
* was wirklich gilt, und ist damit die genauere Frage, nicht
* die nachsichtigere.
*/
tourStillOpen: (globalThis.__atlasTour?.steps ?? 0) > 0,
tourStepIndex: globalThis.__atlasTour?.index ?? -1,
};
});
result.tourDiagramOpened =
extras.tourDiagram.present === true
&& extras.tourDiagram.available === 'true'
&& extras.tourDiagram.label.includes('[d]')
&& extras.tourDiagramFlow.arrows > 0
&& extras.tourDiagramFlow.tourStillOpen === true;
log(`Bild zum Schritt: ${extras.tourDiagramFlow.arrows} Pfeile, `
+ `Fuehrung laeuft weiter: ${extras.tourDiagramFlow.tourStillOpen}`);
await halt('tour-card-diagram', { shot: '18b-tour-diagram.png' });
await page.keyboard.press('Escape');
await page.waitForSelector('[data-testid="atlas-flow-overlay"]', { state: 'detached', timeout: 15000 })
.catch(() => undefined);
await page.waitForTimeout(300);
await pressGlobally('Enter');
await page.waitForFunction(() => globalThis.__atlasTour?.index === 1, undefined, { timeout: 40000 });
await page.waitForTimeout(900);
await halt('entry-walk-step-2');
// Der Umschalter zwischen den beiden Ansichten des Graph-Panels. Er ist
// erst da, wenn es einen Walk gibt, den man zeigen koennte.
await page.click('[data-testid="atlas-graph-mode-chip"][data-mode="galaxy"]');
await page.waitForFunction(
() => globalThis.__atlasGalaxy?.mode === 'galaxy',
undefined,
{ timeout: 20000 },
);
await page.waitForTimeout(600);
await halt('galaxy-mode-toggle', { shot: '19-graph-mode-galaxy.png' });
await page.click('[data-testid="atlas-graph-mode-chip"][data-mode="hierarchy"]');
await page.waitForFunction(
() => globalThis.__atlasGalaxy?.mode === 'hierarchy',
undefined,
{ timeout: 20000 },
);
await page.waitForTimeout(600);
await halt('hierarchy-mode-toggle');
await pressGlobally('q');
await page.waitForTimeout(400);
// ------------------------------------------------- 6j. BUG-Wizard
await typeQuery(TARGET);
await chooseHit(TARGET, TARGET_QUALIFIED);
await page.click('[data-menu="a-bug"]');
await page.waitForSelector('[data-testid="atlas-bugwizard"]', { timeout: 30000 });
await page.waitForFunction(
() => document.querySelector('[data-testid="atlas-bugwizard"]')
?.getAttribute('data-status') === 'ready',
undefined,
{ timeout: 90000 },
);
extras.wizardBeforeIngest = await page.evaluate(() => {
const panel = document.querySelector('[data-testid="atlas-bugwizard"]');
return {
events: Number(panel?.getAttribute('data-events') ?? '0'),
staticPaths: Number(panel?.getAttribute('data-static-paths') ?? '0'),
noTraces: document.querySelector('[data-testid="atlas-bugwizard-no-traces"]') !== null,
};
});
await halt('bugwizard-without-traces', { shot: '20-bugwizard-no-traces.png' });
const qn = (suffix) => `${PROJECT}.${suffix}`;
const ingest = await cli(
'ingest_traces',
{
project: PROJECT,
label: RUN_LABEL,
traces: [
{
path: [
qn('src.routes.users.registerUserRoutes'),
qn('src.services.userService.createUser'),
qn('src.util.validate.validateUser'),
],
count: RUN_COUNT,
},
{
caller: qn('src.services.userService.listUsers'),
callee: qn('src.util.validate.validateUser'),
},
],
},
home,
);
extras.ingest = ingest;
log(`ingest_traces: ${ingest.pairs_stored} Paare, ${ingest.paths_stored} Pfade`);
await openApp(PROJECT);
await typeQuery(TARGET);
await chooseHit(TARGET, TARGET_QUALIFIED);
// Mit der Taste statt mit der Maus: derselbe Eintrag, der andere Weg
// hinein (Audit-Befund 12). Bliebe die Taste wirkungslos, liefe der
// Lauf hier in die Zeitueberschreitung und nicht an ihr vorbei.
await pressMenuShortcut('b');
await page.waitForSelector('[data-testid="atlas-bugwizard"]', { timeout: 30000 });
await page.waitForFunction(
() => document.querySelector('[data-testid="atlas-bugwizard"]')
?.getAttribute('data-status') === 'ready',
undefined,
{ timeout: 90000 },
);
await page.waitForTimeout(600);
extras.wizardAfterIngest = await page.evaluate(() => {
const panel = document.querySelector('[data-testid="atlas-bugwizard"]');
return {
events: Number(panel?.getAttribute('data-events') ?? '0'),
staticPaths: Number(panel?.getAttribute('data-static-paths') ?? '0'),
observedPaths: Number(panel?.getAttribute('data-observed-paths') ?? '0'),
staticOnly: Number(panel?.getAttribute('data-static-only') ?? '0'),
runtimeOnly: Number(panel?.getAttribute('data-runtime-only') ?? '0'),
};
});
log(`Wizard mit Aufzeichnung: ${JSON.stringify(extras.wizardAfterIngest)}`);
await halt('bugwizard-divergence', { shot: '21-bugwizard-divergence.png' });
await page.click('[data-testid="atlas-bugwizard-close"]');
await page.waitForTimeout(300);
// --------------------------------------------------- 6k. Impact
await openApp(PROJECT_IMPACT);
await pressMenuShortcut('c');
await page.waitForSelector('[data-testid="atlas-impact"]', { timeout: 30000 });
await halt('impact-open');
await page.waitForFunction(
() => document.querySelector('[data-testid="atlas-impact"]')
?.getAttribute('data-status') === 'ready',
undefined,
{ timeout: 120000 },
);
await page.waitForTimeout(500);
extras.impact = await page.evaluate(() => {
const panel = document.querySelector('[data-testid="atlas-impact"]');
return {
badge: panel?.getAttribute('data-badge') ?? '',
direct: Number(panel?.getAttribute('data-direct') ?? '0'),
downstream: Number(panel?.getAttribute('data-downstream') ?? '0'),
endpoints: Number(panel?.getAttribute('data-endpoints') ?? '0'),
tiles: document.querySelectorAll('[data-testid="atlas-impact-tile"]').length,
};
});
log(`Blast-Radius: ${JSON.stringify(extras.impact)}`);
await halt('impact-reading', { shot: '22-impact.png' });
await page.click('[data-testid="atlas-impact-close"]');
await page.waitForTimeout(300);
// ------------------------------------------ 6l. Sidecar und Chat
await openApp(PROJECT);
await page.waitForFunction(
() => (globalThis.__atlasLlm?.policyVerdict ?? '') !== '',
undefined,
{ timeout: 60000 },
);
extras.llmOff = await page.evaluate(() => ({ ...globalThis.__atlasLlm }));
await halt('sidecar-off', { shot: '23-sidecar-off.png' });
const startStarted = Date.now();
const startRun = await run('sh', [join(ROOT, 'llm', 'start.sh'), choice]);
sidecarStarted = true;
extras.startScript = { exit: startRun.code, out: (startRun.out + startRun.err).trim().split('\n').slice(-6) };
if (startRun.code !== 0) {
throw new Error(`llm/start.sh endete mit ${startRun.code}`);
}
/*
* Erst warten, bis der Prozess wirklich antwortet, dann einschalten.
*
* llama-server antwortet auf /health mit 503, solange er das Modell
* laedt. Das ist richtig so und die Anwendung geht richtig damit um (sie
* bleibt auf `starting`), aber der Browser schreibt fuer jede Antwort
* jenseits von 400 eine Zeile in die Konsole, und die Abnahme verlangt
* eine leere Konsole. Der Lauf schaltet darum in derselben Reihenfolge
* ein, die das Panel selbst vorschlaegt: erst llm/start.sh, dann den
* Schalter. Was der Sidecar waehrend des Ladens sagt, steht trotzdem im
* Ergebnis, unter sidecarHealth.
*/
extras.sidecarHealth = [];
const healthDeadline = Date.now() + READY_TIMEOUT_MS;
for (;;) {
let status = 0;
try {
const probe = await fetch(`${SIDECAR_ORIGIN}/health`);
status = probe.status;
await probe.arrayBuffer();
} catch {
status = 0;
}
extras.sidecarHealth.push({ atMs: Date.now() - startStarted, status });
if (status === 200) {
break;
}
if (Date.now() > healthDeadline) {
throw new Error(`der Sidecar auf ${SIDECAR_PORT} war nicht bereit`);
}
await sleep(500);
}
await page.click('[data-menu="a-llm"]');
await page.waitForFunction(
() => globalThis.__atlasLlm?.state === 'ready',
undefined,
{ timeout: READY_TIMEOUT_MS },
);
timings.sidecarReadyMs = Date.now() - startStarted;
log(`Sidecar ready nach ${timings.sidecarReadyMs} ms`);
extras.llmReady = await page.evaluate(() => ({ ...globalThis.__atlasLlm }));
await halt('sidecar-ready', { shot: '24-sidecar-ready.png' });
const askStarted = Date.now();
const commandInput = page.locator('[data-testid="atlas-command-input"]');
await commandInput.click();
await commandInput.fill('');
await commandInput.pressSequentially(QUESTION, { delay: 8 });
await page.waitForTimeout(700);
await commandInput.press('Enter');
await page.waitForFunction(
() => (globalThis.__atlasChat?.turns ?? []).some(
(turn) => turn.question.startsWith('Wer ruft') && turn.status === 'answered',
),
undefined,
{ timeout: 240000 },
);
timings.answerMs = Date.now() - askStarted;
await page.waitForTimeout(600);
extras.answer = await page.evaluate(() => {
const turn = (globalThis.__atlasChat?.turns ?? []).find(
(entry) => entry.question.startsWith('Wer ruft') && entry.status === 'answered',
);
return turn === undefined ? null : {
status: turn.status,
klass: turn.klass,
cards: turn.cards,
citations: turn.citations,
answerLength: turn.answer.length,
tokensPerSecond: turn.tokensPerSecond,
};
});
log(`Antwort nach ${timings.answerMs} ms, Zitate ${JSON.stringify(extras.answer?.citations ?? [])}`);
await halt('chat-answered', { shot: '25-chat-answer.png' });
// Ein [K]-Zitat anklicken: der Reader muss danach woanders stehen.
const before = await page.evaluate(() => ({
path: globalThis.__atlasReader?.document?.path ?? '',
line: globalThis.__atlasReader?.editor?.getPosition?.()?.lineNumber ?? 0,
}));
const citation = page.locator('[data-testid="atlas-chat-citation"]').first();
const citations = await citation.count();
if (citations > 0) {
extras.citedCard = await citation.getAttribute('data-card');
await citation.click();
await page.waitForTimeout(2500);
const after = await page.evaluate(() => ({
path: globalThis.__atlasReader?.document?.path ?? '',
line: globalThis.__atlasReader?.editor?.getPosition?.()?.lineNumber ?? 0,
}));
extras.citationClick = { before, after };
result.chatCitationClicked =
after.path.length > 0 && (after.path !== before.path || after.line !== before.line);
}
log(`Zitat-Klick: ${result.chatCitationClicked}`);
await halt('chat-citation-followed', { shot: '26-chat-citation.png' });
await page.click('[data-testid="atlas-chat-cards-toggle"]');
await page.waitForTimeout(400);
extras.cardsShown = await page.locator('[data-testid="atlas-chat-card"]').count();
await halt('chat-cards-open', { shot: '27-chat-cards.png' });
// Und wieder aus. "Aus" ist eine Lage und keine fehlende Funktion.
await pressMenuShortcut('l');
await page.waitForFunction(
() => globalThis.__atlasLlm?.state === 'off',
undefined,
{ timeout: 30000 },
);
extras.llmOffAgain = await page.evaluate(() => ({ ...globalThis.__atlasLlm }));
await halt('sidecar-off-again', { shot: '28-sidecar-off-again.png' });
extras.apiRoutes = { ...proxy.log.apiRoutes };
extras.rpcTools = { ...proxy.log.rpcTools };
await context.close();
} catch (err) {
failure = err;
console.error('[smoke-w6] FEHLER:', err.message);
if (serverLog.length > 0) {
console.error('[smoke-w6] Server-Log (letzte 20 Zeilen):\n' + serverLog.slice(-20).join('\n'));
}
}
if (browser !== null) {
await browser.close().catch(() => undefined);
}
if (sidecarStarted) {
const rescue = await run('sh', [join(ROOT, 'llm', 'stop.sh')]);
extras.stopScript = { exit: rescue.code, out: (rescue.out + rescue.err).trim().split('\n').slice(-6) };
}
if (proxy !== null) {
await proxy.close();
}
await stopServer(serverChild);
await sleep(900);
/*
* Gezaehlt wird mit Geduld, und die Geduld hat eine Grenze.
*
* llm/stop.sh wartet, bis der Prozess weg ist (`kill -0` schlaegt fehl),
* und meldet dann "beendet". Das Betriebssystem gibt den Port aber erst
* danach frei, und zweimal hintereinander lag genau dieser Moment auf der
* einen Messung: Prozess tot, Port noch belegt, Lauf rot. Ein Beweislauf,
* der gelegentlich ohne Grund rot wird, ist schlimmer als keiner, weil man
* sich an sein Rot gewoehnt und das echte uebersieht.
*
* Es wird darum bis zu fuenf Sekunden lang nachgesehen, ob der Port frei
* wird. Das ist nicht nachsichtiger, sondern genauer: ein Prozess, der
* wirklich weiterlaeuft, laeuft auch nach fuenf Sekunden noch, und dann
* steht seine Zahl hier. Wie lange es wirklich gedauert hat, steht im
* Artefakt, damit ein schleichend langsamer werdender Abbau auffaellt,
* statt sich hinter der Wartezeit zu verstecken.
*/
/*
* Fuenfzehn Sekunden statt fuenf, seit dem 2026-08-30.
*
* Gemessen: der Modellport gibt sich im Normalfall 1557 ms, unter Last
* mehrerer paralleler Laeufe aber mehr als 5128 ms. Beide Male war der
* Prozess laengst beendet und nur der Port noch belegt. Wer hier zu
* frueh aufhoert zu warten, meldet einen Rest, den es nicht gibt, und
* ein Lauf, der gelegentlich grundlos rot wird, ist schlimmer als
* keiner. Ein Prozess, der wirklich weiterlaeuft, laeuft auch nach
* fuenfzehn Sekunden noch; die gewartete Zeit steht im Artefakt.
*/
const FREE_PORT_TIMEOUT_MS = 15000;
const leftovers = [];
for (const port of [serverPort, uiPort, SIDECAR_PORT].filter((value) => value > 0)) {
const startedAt = Date.now();
let listeners = await countListeners(port);
while (listeners > 0 && Date.now() - startedAt < FREE_PORT_TIMEOUT_MS) {
await sleep(250);
listeners = await countListeners(port);
}
leftovers.push({ port, listeners, waitedMs: Date.now() - startedAt });
}
extras.leftovers = leftovers;
result.leftoverProcesses = leftovers.reduce((sum, entry) => sum + entry.listeners, 0);
const netz = await sampler.stop();
result.samples = netz.samples;
result.outboundViolations = netz.outboundViolations;
extras.net = netz;
result.consoleErrors = extras.consoleErrors.length;
result.pageErrors = extras.pageErrors.length;
result.scrolledRegions = extras.scrolledRegionNames.length;
result.screenshots = existsSync(WALK_DIR)
? readdirSync(WALK_DIR).filter((name) => name.endsWith('.png')).length
: 0;
timings.totalMs = Date.now() - totalStarted;
await mkdir(OUT_DIR, { recursive: true });
await writeFile(
AIRGAP_JSON,
JSON.stringify({
...result,
projects: { main: PROJECT, large: PROJECT_LARGE, impact: PROJECT_IMPACT },
fixture: 'fixtures/atlas-sample und fixtures/atlas-sample-large (nur gelesen), '
+ 'plus eine Kopie mit eigenem git-Repository fuer die Aenderungsansicht',
sidecarPort: SIDECAR_PORT,
question: QUESTION,
readability: {
exclusions: READABILITY_EXCLUSIONS,
deliberateOverlays: DELIBERATE_OVERLAYS,
scrolledRegionNames: extras.scrolledRegionNames,
overlaps: extras.overlaps,
clipped: extras.clipped,
},
steps: extras.steps,
timings,
generatedAt: new Date().toISOString(),
error: failure ? failure.message : null,
extras,
}, null, 2) + '\n',
'utf8',
);
await writeFile(
BUDGETS_JSON,
JSON.stringify({
...budgets,
warmSamples: extras.warmSamples,
method: {
warm:
'Zehn verschiedene Symbole, nacheinander ueber die Bedeutungssuche geoeffnet. '
+ 'Gemessen vom Klick auf den Treffer bis der Twin das neue Subjekt fertig zeigt '
+ '(Aufloesung und IR-Bau ueber /rpc, dann das Bild). Das Tippen und die '
+ 'Entprellung davor stehen als searchOverlayMs getrennt. Zehn VERSCHIEDENE '
+ 'Symbole, weil dasselbe zweimal den Cache in src/twin/ir-cache.ts messen '
+ 'wuerde und nicht den Server.',
cold: 'Der erste Symbolwechsel nach dem Laden der Seite, gleich gemessen.',
searchOverlay:
'Vom ersten Tastendruck bis die Trefferzeile mit diesem Namen im Fenster steht, '
+ 'einschliesslich der Entprellung von 200 ms.',
galaxy:
'Vom Aufruf der Adresse bis das Graph-Panel Knoten meldet (Szene im DOM UND '
+ '__atlasGalaxy.nodes > 0). Enthaelt den Seitenaufbau, weil ein Leser ihn '
+ 'ebenfalls abwartet.',
},
generatedAt: new Date().toISOString(),
}, null, 2) + '\n',
'utf8',
);
log('geschrieben:', AIRGAP_JSON, 'und', BUDGETS_JSON);
const ok =
failure === null
&& result.outboundViolations === 0
&& result.samples >= 60
&& result.clickSteps >= 27
&& result.pageErrors === 0
&& result.consoleErrors === 0
&& result.leftoverProcesses === 0
&& result.chatCitationClicked === true
&& result.atlasRowShortcutsShown === true
&& result.atlasRowOpenedByKey === true
&& result.tourDiagramOpened === true
&& result.overlapViolations === 0
&& result.clippingViolations === 0
&& result.scrolledRegions >= 6
&& result.screenshots >= 10
&& result.versionChipShown === EXPECTED_VERSION_CHIP
&& budgets.twinWarmSamples >= 10
&& budgets.twinWarmP95Ms <= 800
&& extras.blockedRequests.length === 0;
log(`Halte ${result.clickSteps}, Bilder ${result.screenshots}, Stichproben ${result.samples}, `
+ `Ueberlagerungen ${result.overlapViolations}, Beschneidungen ${result.clippingViolations}, `
+ `gescrollte Bereiche ${result.scrolledRegions} (${extras.scrolledRegionNames.join(', ')})`);
if (!ok) {
console.error('[smoke-w6] W6a-Smoke NICHT gruen.');
for (const entry of extras.overlaps.slice(0, 10)) {
console.error(` Ueberlagerung @${entry.step} [${entry.layer}] `
+ `"${entry.a.text}" x "${entry.b.text}" (${entry.overlapX}x${entry.overlapY}px)`);
}
for (const entry of extras.clipped.slice(0, 10)) {
console.error(` Beschneidung @${entry.step} ${entry.element.path} "${entry.element.text}" `
+ `ragt ${entry.overflowPx}px aus ${entry.container.path} (${entry.axis})`);
}
for (const entry of extras.consoleErrors.slice(0, 10)) {
console.error(' console:', JSON.stringify(entry));
}
for (const entry of extras.failedResponses.slice(0, 10)) {
console.error(' response:', entry.status, entry.url);
}
for (const entry of extras.pageErrors.slice(0, 10)) {
console.error(' pageerror:', entry);
}
if (home) {
console.error('[smoke-w6] isoliertes HOME bleibt zum Nachsehen liegen:', home);
}
if (workspace) {
console.error('[smoke-w6] Fixture-Kopie bleibt liegen:', workspace);
}
process.exitCode = 1;
return;
}
for (const directory of [home, runtimeDir, workspace]) {
if (directory) {
await rm(directory, { recursive: true, force: true });
}
}
log(`W6a-Smoke gruen nach ${timings.totalMs} ms.`);
}
main().catch((err) => {
console.error('[smoke-w6] unerwarteter Fehler:', err);
process.exitCode = 1;
});