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
/*
* W13-Smoke: der Regler fragt nicht mehr wie viel, sondern fuer wen.
*
* ## Was dieser Lauf beantwortet, und warum keiner davor es konnte
*
* Nutzerbefund vom 2026-08-29, woertlich: "ich seh gar keine Aenderungen". Der
* Befund war weder bestaetigt noch widerlegt, weil die Probe, die ihn messen
* sollte, an den falschen Kennungen hing und vier Nullen meldete. Er wird hier
* nicht geglaubt und nicht wegerklaert, sondern gemessen, und zwar an der
* schaerfsten Stelle: bei AUSGESCHALTETEM Modell.
*
* Fuenf Stufen, ein Symbol, fuenf Messungen. Fuer jede Stufe die Zeichenzahl
* des gerenderten Koerpers, seine erste Zeile, die Zahl der Abschnitte und die
* Menge der Testmarken, die im DOM stehen. Daraus zwei Zahlen, die keine
* Behauptung sind: `allLevelsDiffer` (keine zwei Stufen ergeben denselben Text)
* und je Stufe ein `uniqueElement`, ausgerechnet als die Marke, die genau auf
* dieser einen Stufe vorkommt. Eine Anwendung, die ohne Modell vollstaendig
* sein soll, darf keinen Regler haben, der ohne Modell nichts tut.
*
* ## Die vier Kunstgriffe dieses Laufs
*
* 1. **Das eigene Element wird ausgerechnet, nicht aufgezaehlt.** Der Lauf
* sammelt je Stufe alle `data-testid` des Twin-Koerpers und schneidet die
* fuenf Mengen gegeneinander. Eine Liste im Quelltext dieses Laufs waere
* eine Erwartung, die gruen bleibt, wenn das Produkt sie nicht mehr
* erfuellt.
*
* 2. **Der Sidecar wird IM BROWSER beantwortet und nie angefasst.** Port 4141
* gehoert dem Nutzer; dieser Lauf startet dort nichts, beendet dort nichts
* und verbindet sich dorthin nicht. Jede Anfrage, die die Anwendung dorthin
* richtet, faengt der Route-Griff von Playwright ab und beantwortet sie aus
* einem Skript, bevor eine Verbindung entsteht. Was dabei angefragt wurde,
* steht vollstaendig im Artefakt (`extras.sidecar.requests`).
*
* 3. **Der Waechter wird durch die echte Funktion gefuehrt.** Die sieben
* gefaelschten Umformulierungen laufen durch `applyReaderRewrite`, an
* derselben Stelle, an der der Knopf sie hindurchschickt
* (`__atlasTwin.validateRewrite`). Ein Lauf, der die Regel nachbaut und
* gegen den Nachbau prueft, prueft den Nachbau.
*
* 4. **Der leere Fall wird gesucht und nicht angenommen.** Fuer AC7 geht der
* Lauf mehrere Symbole durch, bis er eins findet, dessen Senior-Stufe
* keinen einzigen Fehlerpfad hat, und misst dort, ob die Flaeche trotzdem
* etwas sagt. Welches Symbol es war, steht im Artefakt.
*
* ## Was hier NICHT gemessen wird, und das ist wichtig
*
* Die Schreibqualitaet eines echten Modells. Der Modellport des Nutzers ist
* tabu, und ein zweites llama-server auf einem eigenen Port waere in diesem
* Lauf kein Beweis ueber das Produkt, sondern ein zweiter Prozess mit eigener
* Ladezeit. Gemessen wird die LEITUNG und der WAECHTER: dass die Anwendung mit
* dem Modell an genau diese Saetze verschickt, dass eine treue Antwort
* angewendet und mit ihrem Herkunftsvermerk gezeichnet wird, und dass eine
* Antwort mit einem erfundenen Namen verworfen wird und der Leser den Grund
* liest. Was der Stub zurueckgibt, ist eine deterministische, faktentreue
* Umschreibung und keine Modellprosa; das steht auch im Artefakt.
*
* ## Ablauf
*
* 1. `npm run build`
* 2. isoliertes HOME, eigenes Rendezvous-Verzeichnis (CBM_RUNTIME_DIR)
* 3. fixtures/atlas-sample indizieren (die Fixture wird nur gelesen)
* 4. C-Server auf einem freien Port >= 4600, dist/ auf einem zweiten
* 5. Chromium ohne Aussenwelt, plus Route-Sperre und der Sidecar-Stub
* a. createUser oeffnen, die fuenf Stufen durchfahren und vermessen
* b. Reload und Symbolwechsel: haelt die Wahl?
* c. der leere Fall auf der Senior-Stufe
* d. der Waechter, sieben Faelschungen und eine treue Antwort
* e. Modell an: anwenden, zeichnen, verwerfen, Grund lesen
* 6. abraeumen, Restprozesse mehrfach zaehlen, JSON und fuenf Bilder
*
* Das Ganze laeuft unter dem Netz-Deny-Gate (npm run smoke:w13).
*
* ## Ports
*
* Ab 4600. 4141 gehoert dem Modell-Sidecar des Nutzers, 4142 seiner
* Agenten-Bruecke, 4390/4391 und 4392/4393 seinen zwei Vorschauen; alles bis
* 4600 gehoert den Laeufen davor. Dieser Lauf fasst keinen davon an.
*/
import { spawn } from 'node:child_process';
import { existsSync } from 'node:fs';
import { mkdir, mkdtemp, rm, stat, writeFile } from 'node:fs/promises';
import { tmpdir } from 'node:os';
import { dirname, join, resolve } from 'node:path';
import { fileURLToPath } from 'node:url';
import {
countListeners,
findFreePort,
indexRepository,
sleep,
startServer,
stopServer,
} from './lib/cbm-server.mjs';
import {
READABILITY_EXCLUSIONS,
closeTooltips,
measureReadability,
resetScroll,
scrollRegionsToEnd,
} from './lib/readability.mjs';
import { startStaticProxy } from './lib/static-proxy.mjs';
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 PROJECT = 'codeatlasweb-w13';
const OUT_DIR = join(ROOT, 'verification', 'w13');
const OUT_JSON = join(OUT_DIR, 'reader.json');
/** Contract: alles darunter gehoert dem Nutzer oder frueheren Laeufen. */
const MIN_PORT = 4600;
const VIEWPORT = { width: 1680, height: 1050 };
/** Der Modellport des Nutzers. Wird beantwortet, nie verbunden, nie gestartet. */
const SIDECAR_ORIGIN = 'http://127.0.0.1:4141';
/**
* Die fuenf Leser, in der Reihenfolge des Reglers, mit dem Dateinamen ihres
* Beweisbildes.
*/
const LEVELS = [
/*
* `wants` ist die Marke, von der dieser Lauf ERWARTET, dass sie nur auf
* dieser Stufe steht. Sie ist keine Zusicherung: was im Artefakt landet,
* ist die ausgerechnete Schnittmenge, und `wants` waehlt daraus nur aus,
* welche der eigenen Marken genannt wird. Steht sie nicht in der
* Schnittmenge, faellt der Lauf auf die erste ausgerechnete zurueck und die
* Abweichung ist im Artefakt zu sehen (uniqueElements neben uniqueElement).
*/
{ level: 0, name: 'vibe coder', shot: 'level-vibe-coder.png', wants: 'codeatlas-twin-chip' },
{ level: 1, name: 'junior', shot: 'level-junior.png', wants: 'codeatlas-twin-term' },
{ level: 2, name: 'medior', shot: 'level-medior.png', wants: 'codeatlas-twin-section-steps' },
{ level: 3, name: 'senior', shot: 'level-senior.png', wants: 'codeatlas-twin-reader-fails' },
{ level: 4, name: 'architect', shot: 'level-architect.png', wants: 'codeatlas-twin-limit' },
];
/**
* Das Symbol, an dem alle fuenf Stufen fotografiert werden.
*
* `createUser` und kein anderes: es ist das eine Symbol der Fixture, an dem
* jede Faktenfamilie gefuellt ist (sechs Aufrufe, zwei Aufrufer, ein erhobener
* Fehlertyp, eine Umgebungslesung, ein Testaufrufer). An einem leereren Symbol
* waeren zwei Stufen aus Mangel an Fakten aehnlich, und der Unterschied im Bild
* waere eine Aussage ueber die Fixture statt ueber den Regler.
*/
const MAIN = { name: 'createUser', file: 'src/services/userService.ts' };
/** Das zweite Symbol, fuer den Symbolwechsel aus AC6. */
const OTHER = { name: 'getOrder', file: 'src/services/orderService.ts' };
/**
* Wo der Lauf nach einem Symbol OHNE Fehlerpfad sucht (AC7).
*
* Eine Liste und keine feste Wahl: welches Symbol der Index ohne erhobenen
* Fehlertyp fuehrt, ist eine Eigenschaft des Index und nicht dieses Laufs, und
* eine feste Wahl waere rot, sobald jemand die Fixture ergaenzt.
*/
const EMPTY_CANDIDATES = [
{ name: 'getOrder', file: 'src/services/orderService.ts' },
{ name: 'listUsers', file: 'src/services/userService.ts' },
{ name: 'toUser', file: 'src/services/userService.ts' },
{ name: 'insert', file: 'src/repo/db.ts' },
{ name: 'query', file: 'src/repo/db.ts' },
];
/** Chromium ohne Aussenwelt, wortgleich mit smoke-w8b und smoke-w8c. */
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-w13]', ...parts);
const serverLog = [];
function run(command, args) {
return new Promise((done) => {
const child = spawn(command, args, {
cwd: ROOT,
env: {
...process.env,
NO_UPDATE_NOTIFIER: '1',
npm_config_update_notifier: 'false',
npm_config_audit: 'false',
npm_config_fund: 'false',
},
stdio: ['ignore', 'pipe', 'pipe'],
});
let out = '';
child.stdout.on('data', (d) => { out += d.toString(); });
child.stderr.on('data', (d) => { out += d.toString(); });
child.on('error', (error) => done({ code: 127, out: out + error.message }));
child.on('close', (code) => done({ code: code ?? 1, out }));
});
}
// ------------------------------------------------- Faelschungen des Modells ---
/**
* Dieselbe Fakten-Zerlegung wie `src/twin/reader-rewrite.ts`, hier noch einmal.
*
* Bewusst kopiert und nicht importiert: sie steht in TypeScript, dieser Lauf
* ist ein Skript, und ein Import ueber den Bau hinweg waere eine Abhaengigkeit
* dieses Laufs auf das Ergebnis desselben Baus, den er pruefen soll. Sie wird
* hier NUR benutzt, um Faelschungen zu bauen; geprueft wird ausschliesslich
* durch die echte Funktion in der Seite.
*/
const FACT_TOKEN =
/[A-Za-z_$][A-Za-z0-9_$]*(?:[./\\][A-Za-z0-9_$]+)+|[A-Za-z_$][A-Za-z0-9_$]*[A-Z][A-Za-z0-9_$]*|\d+(?:\.\d+)?/g;
const factsOf = (text) => text.match(FACT_TOKEN) ?? [];
/**
* Eine treue Umschreibung: jeder Fakt bleibt, wo er ist.
*
* Ein vorangestellter Halbsatz aus lauter kleingeschriebenen Woertern. Er
* traegt keinen Fakt, verschiebt keinen und bleibt weit unter der Laengendecke,
* und er ist als Umschreibung erkennbar: der Text ist danach ein anderer.
*/
const faithful = (lines) => lines.map((line) => `put plainly, ${line.text}`).join('\n');
/** Die sieben Faelschungen, jede mit ihrem Namen und ihrem Grund. */
function forgeries(lines) {
const texts = lines.map((line) => line.text);
const firstWithFact = lines.findIndex((line) => line.facts.length > 0);
const withNumber = lines.findIndex((line) => line.facts.some((fact) => /^\d+$/.test(fact)));
const withFile = lines.findIndex((line) => line.facts.some((fact) => /\.[a-z]+$/.test(fact)));
const withName = lines.findIndex((line) =>
line.facts.some((fact) => /^[a-z][A-Za-z0-9_$]*[A-Z]/.test(fact)));
const out = [];
const swap = (index, from, to, label, why) => {
if (index < 0) {
return;
}
const copy = [...texts];
copy[index] = copy[index].replace(from, to);
if (copy[index] === texts[index]) {
return;
}
out.push({ label, why, answer: copy.join('\n') });
};
if (withName >= 0) {
const name = lines[withName].facts.find((fact) => /^[a-z][A-Za-z0-9_$]*[A-Z]/.test(fact));
swap(withName, name, `${name}s`, 'renamed',
'ein Name, der um einen Buchstaben abweicht, zeigt auf ein Symbol, das es nicht gibt');
}
if (withNumber >= 0) {
const number = lines[withNumber].facts.find((fact) => /^\d+$/.test(fact));
swap(withNumber, number, String(Number(number) + 1), 'renumbered',
'eine Zahl, die um eins abweicht, ist eine falsche Zeile oder eine falsche Zaehlung');
}
if (withFile >= 0) {
const file = lines[withFile].facts.find((fact) => /\.[a-z]+$/.test(fact));
swap(withFile, file, file.replace(/\.[a-z]+$/, '.js'), 'refiled',
'eine andere Datei ist ein anderer Ort');
}
if (firstWithFact >= 0) {
const copy = [...texts];
copy[firstWithFact] = `${copy[firstWithFact]} It also calls saveUserProfile.`;
out.push({
label: 'invented',
why: 'ein dazuerfundener Name ist die teuerste Abweichung: die Zeile sieht danach genauso '
+ 'vertrauenswuerdig aus wie vorher',
answer: copy.join('\n'),
});
}
if (texts.length > 1) {
const copy = [...texts];
[copy[0], copy[1]] = [copy[1], copy[0]];
out.push({
label: 'reordered',
why: 'dieselben Saetze in anderer Reihenfolge sind eine andere Aussage ueber den Ablauf',
answer: copy.join('\n'),
});
}
out.push({
label: 'shortened',
why: 'weniger Saetze als gegeben heisst, dass einer verschwunden ist',
answer: texts.slice(0, 1).join('\n'),
});
out.push({
label: 'padded',
why: 'jeder Fakt behalten und die Seite gesprengt ist trotzdem keine Umformulierung',
answer: texts
.map((text, index) => (index === 0
? `${text} ${'and here is a great deal of prose that nobody asked for, '.repeat(6)}`
: text))
.join('\n'),
});
return out;
}
// ------------------------------------------------------------- Testgriffe ---
/** Was auf der Stufe wirklich dasteht, gelesen am gerenderten Koerper. */
const bodySeam = (page) =>
page.evaluate(() => {
const body = document.querySelector('.atlas-twin-body');
if (body === null) {
return null;
}
const clean = (value) => (value ?? '').replace(/\s+/g, ' ').trim();
const marks = [...body.querySelectorAll('[data-testid]')]
.map((node) => node.getAttribute('data-testid') ?? '')
.filter((mark) => mark.length > 0);
return {
mode: body.getAttribute('data-mode') ?? '',
levelName: body.getAttribute('data-level') ?? '',
text: clean(body.textContent),
question: clean(body.querySelector('[data-testid="codeatlas-twin-question"]')?.textContent),
sections: body.querySelectorAll(
'[data-testid^="codeatlas-twin-section-"], [data-testid^="codeatlas-twin-reader-"]:not('
+ '[data-testid="codeatlas-twin-reader-lead"]):not('
+ '[data-testid="codeatlas-twin-reader-weight"])',
).length,
marks: [...new Set(marks)].sort(),
voiced: body.querySelectorAll('[data-testid="codeatlas-twin-voiced"]').length,
voiceNote: clean(body.querySelector('[data-testid="codeatlas-twin-voice-note"]')?.textContent),
voiceRefused: body.querySelector('[data-testid="codeatlas-twin-voice-note"]')
?.getAttribute('data-refused') === 'true',
voiceButton: body.querySelector('[data-testid="codeatlas-twin-voice-btn"]') !== null,
emptyBlocks: [...body.querySelectorAll('[data-testid^="codeatlas-twin-reader-"]')]
.filter((node) => node.getAttribute('data-populated') === 'false')
.map((node) => ({
name: node.getAttribute('data-block-name') ?? '',
text: clean(node.textContent),
})),
seam: JSON.parse(JSON.stringify(globalThis.__atlasTwin ?? null, (key, value) =>
(typeof value === 'function' ? undefined : value))),
};
});
/** Was der Regler sagt: die Beschriftung, der Wertebereich und der Name daneben. */
const sliderSeam = (page) =>
page.evaluate(() => {
const input = document.querySelector('[data-testid="atlas-twin-depth"]');
const label = document.querySelector('.atlas-twin-depth-label');
const name = document.querySelector('[data-testid="atlas-twin-depth-name"]');
return {
present: input !== null,
label: (label?.textContent ?? '').trim(),
ariaLabel: input?.getAttribute('aria-label') ?? '',
ariaValueText: input?.getAttribute('aria-valuetext') ?? '',
min: input?.getAttribute('min') ?? '',
max: input?.getAttribute('max') ?? '',
value: input?.value ?? '',
name: (name?.textContent ?? '').trim(),
};
});
/** Wo jeder scrollbare Bereich steht. Wortgleich mit smoke-w8b und smoke-w8c. */
const scrollState = (page) =>
page.evaluate(() => {
const regions = [];
for (const node of document.body.querySelectorAll('*')) {
if (node.closest('.monaco-editor') !== null) {
continue;
}
const style = globalThis.getComputedStyle(node);
const scrollsY = (style.overflowY === 'auto' || style.overflowY === 'scroll')
&& node.scrollHeight > node.clientHeight + 1;
const scrollsX = (style.overflowX === 'auto' || style.overflowX === 'scroll')
&& node.scrollWidth > node.clientWidth + 1;
if (!scrollsY && !scrollsX) {
continue;
}
regions.push({
name: node.getAttribute('data-testid')
?? (node.getAttribute('class') ?? '').split(/\s+/).filter(Boolean)[0]
?? node.tagName.toLowerCase(),
top: Math.round(node.scrollTop),
left: Math.round(node.scrollLeft),
hidden: Math.round(node.scrollHeight - node.clientHeight),
});
}
return { regions, atRest: regions.every((region) => region.top <= 1 && region.left <= 1) };
});
// ------------------------------------------------------------ Klickstrecke ---
async function openApp(page, origin) {
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 });
await page.waitForFunction(
() => globalThis.__atlasTwin !== undefined,
undefined,
{ timeout: 30000 },
);
}
/** Zu einem Symbol navigieren, ueber dieselbe Suche, die die Kommandozeile fuehrt. */
async function openSymbol(page, target) {
const input = page.locator('[data-testid="atlas-command-input"]');
await input.click();
await input.fill('');
await input.pressSequentially(target.name, { delay: 30 });
await page.waitForSelector(
`[data-testid="atlas-search-row"][data-name="${target.name}"]`,
{ timeout: 30000 },
);
await page.waitForTimeout(500);
await page.click(`[data-testid="atlas-search-row"][data-name="${target.name}"]`);
await page.waitForFunction(
(expected) => (globalThis.__atlasTwin?.symbol ?? '') === expected,
target.name,
{ timeout: 40000 },
);
await page.waitForFunction(
() => document.querySelector('[data-testid="atlas-twin"]')
?.getAttribute('data-status') === 'ready',
undefined,
{ timeout: 40000 },
);
await page.waitForTimeout(400);
}
/** Den Regler auf eine Stufe stellen, so wie ein Leser ihn zieht. */
async function setLevel(page, level) {
await page.locator('[data-testid="atlas-twin-depth"]').fill(String(level));
await page.waitForFunction(
(expected) => (globalThis.__atlasTwin?.level ?? -1) === expected,
level,
{ timeout: 15000 },
);
await page.waitForTimeout(260);
}
async function shootAtRest(page, file, name) {
await closeTooltips(page);
await resetScroll(page, READABILITY_EXCLUSIONS);
await page.waitForTimeout(320);
const state = await scrollState(page);
await page.screenshot({ path: file, fullPage: false });
const bytes = (await stat(file)).size;
log(`${name}: aufgenommen (atRest=${state.atRest}, ${Math.round(bytes / 1024)} KB)`);
return { name, atRest: state.atRest, bytes, regions: state.regions };
}
// ------------------------------------------------------------------- Lauf ----
async function main() {
const totalStarted = Date.now();
const timings = {};
let home = null;
let runtimeDir = null;
let serverChild = null;
let proxy = null;
let browser = null;
let serverPort = 0;
let uiPort = 0;
let failure = null;
const report = {
// AC1
levels: [],
allLevelsDiffer: false,
measuredWithModelOff: false,
// AC2
sliderNamesReader: false,
levelNameShown: false,
// AC3, AC4
modelRephrasesOnly: false,
rejectedRewrites: 0,
rejectionShownToReader: false,
provenanceVisible: false,
// AC5, AC6, AC7
noRequestsWhileOff: 0,
levelSurvivesReload: false,
levelSurvivesSymbolChange: false,
emptyLevelExplainsItself: false,
// AC8
overlapViolations: 0,
clippingViolations: 0,
cutWithoutHint: 0,
screenshotsAtRest: false,
port: 0,
leftoverProcesses: 0,
};
const extras = {
blockedRequests: [],
consoleErrors: [],
pageErrors: [],
readability: [],
shots: [],
levelBodies: [],
guard: { forgeries: [], faithful: null },
sidecar: { requests: [], answers: [] },
emptyCase: null,
hold: null,
};
// Was der Stub als naechstes antwortet. Wird vor jedem Klick gesetzt.
let nextAnswer = '';
try {
if (!existsSync(BINARY)) {
throw new Error(`Binary fehlt: ${BINARY} (erst 'make -f Makefile.cbm cbm-with-ui' im cbm-Clone bauen)`);
}
if (!existsSync(FIXTURE)) {
throw new Error(`Fixture fehlt: ${FIXTURE}`);
}
// ------------------------------------------------------------ 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.trim().slice(-600)}`);
}
// ---------------------------------------------- 2. HOME, Rendezvous
home = await mkdtemp(join(tmpdir(), 'codeatlasweb-w13-home-'));
runtimeDir = await mkdtemp('/private/tmp/codeatlasweb-w13-run-');
process.env.CBM_RUNTIME_DIR = runtimeDir;
log('isoliertes HOME:', home);
// -------------------------------------------------------- 3. Index
const indexed = await indexRepository(BINARY, { home, repoPath: FIXTURE, project: PROJECT });
extras.indexed = { nodes: indexed.nodes, edges: indexed.edges };
log(`indiziert: ${indexed.nodes} Knoten, ${indexed.edges} Kanten`);
// ------------------------------------------------- 4. Server, Proxy
serverPort = await findFreePort(MIN_PORT);
const started = await startServer(BINARY, { home, port: serverPort, log: serverLog });
serverChild = started.child;
uiPort = await findFreePort(MIN_PORT, [serverPort]);
proxy = await startStaticProxy({ distDir: DIST, upstreamPort: serverPort, port: uiPort });
report.port = uiPort;
extras.ports = { serverPort, uiPort };
log(`C-Server auf ${serverPort}, dist/ auf ${uiPort}`);
// ------------------------------------------------------- 5. Browser
const { chromium } = await import('playwright');
browser = await chromium.launch({ headless: true, args: CHROMIUM_ARGS });
const context = await browser.newContext({ viewport: { ...VIEWPORT } });
const origin = `http://127.0.0.1:${uiPort}`;
/*
* Die Sperre zuerst, der Stub danach, und die Reihenfolge ist kein
* Geschmack: Playwright prueft die ZULETZT gehaengte Route zuerst. Ein
* Stub, der vor der Sperre haengt, kommt nie an die Reihe, und die
* Anfrage an 4141 wird abgebrochen statt beantwortet. Gemessen: im
* ersten Lauf standen elf abgebrochene /health in blockedRequests.
*/
await context.route('**/*', async (route) => {
const url = route.request().url();
if (url.startsWith(origin) || url.startsWith('data:') || url.startsWith('blob:')) {
await route.continue();
return;
}
extras.blockedRequests.push(url);
await route.abort();
});
/*
* Der Sidecar-Stub. Verbunden wird dabei nichts: `route.fulfill`
* beantwortet aus dem Griff heraus, bevor eine Verbindung entsteht.
*/
await context.route(`${SIDECAR_ORIGIN}/**`, async (route) => {
const url = route.request().url();
const path = url.slice(SIDECAR_ORIGIN.length);
extras.sidecar.requests.push({ path, at: Date.now() - totalStarted });
const json = (body) => route.fulfill({
status: 200,
contentType: 'application/json',
body: JSON.stringify(body),
});
if (path.startsWith('/health')) {
return json({ status: 'ok' });
}
if (path.startsWith('/props')) {
return json({
model_path: 'models/stub-for-w13.gguf',
n_ctx: 4096,
total_slots: 1,
default_generation_settings: { n_ctx: 4096 },
});
}
if (path.startsWith('/v1/models')) {
return json({ data: [{ id: 'models/stub-for-w13.gguf', object: 'model' }] });
}
if (path.startsWith('/v1/chat/completions')) {
extras.sidecar.answers.push({ chars: nextAnswer.length });
return json({
choices: [{ message: { content: nextAnswer }, finish_reason: 'stop' }],
usage: { prompt_tokens: 1, completion_tokens: 1 },
});
}
return route.fulfill({ status: 404, contentType: 'text/plain', body: 'not answered' });
});
const page = await context.newPage();
const sidecarRequests = [];
page.on('request', (request) => {
if (request.url().startsWith(SIDECAR_ORIGIN)) {
sidecarRequests.push({ url: request.url(), at: Date.now() - totalStarted });
}
});
page.on('console', (message) => {
if (message.type() === 'error') {
extras.consoleErrors.push(message.text());
}
});
page.on('pageerror', (error) => extras.pageErrors.push(String(error)));
await mkdir(OUT_DIR, { recursive: true });
const readability = async (name) => {
await closeTooltips(page);
const top = await measureReadability(page, READABILITY_EXCLUSIONS);
const scrolled = await scrollRegionsToEnd(page, READABILITY_EXCLUSIONS);
await page.waitForTimeout(200);
const bottom = await measureReadability(page, READABILITY_EXCLUSIONS);
await resetScroll(page, READABILITY_EXCLUSIONS);
extras.readability.push({
name,
scrolledRegions: scrolled.length,
top: { candidates: top.candidates, overlaps: top.overlaps, clipped: top.clipped },
bottom: { candidates: bottom.candidates, overlaps: bottom.overlaps, clipped: bottom.clipped },
});
report.overlapViolations += top.overlaps.length + bottom.overlaps.length;
report.clippingViolations += top.clipped.length + bottom.clipped.length;
report.cutWithoutHint += [...top.clipped, ...bottom.clipped]
.filter((entry) => entry.kind === 'cut-without-hint').length;
};
// ------------------------------- 5a. Die fuenf Stufen, ein Symbol
await openApp(page, origin);
await openSymbol(page, MAIN);
/*
* Die Galaxie einklappen, bevor fotografiert wird.
*
* Kein Aufhuebschen: der Twin teilt sich die rechte Spalte mit dem
* Modell-Panel und dem Graphen, und mit allen dreien uebereinander sind
* von jeder Stufe die ersten fuenf Zeilen zu sehen. Der Auftrag lautet,
* dass der Unterschied IM BILD steht, und fuenf Bilder, auf denen
* jeweils dieselben fuenf Zeilen abgeschnitten werden, erfuellen ihn
* nicht. Eingeklappt wird ueber genau den Knopf, den ein Leser dafuer
* hat; gemessen (Zeichen, Marken, Ueberschneidungen) wird an demselben
* Zustand, in dem fotografiert wird.
*/
await page.click('[data-testid="atlas-galaxy-collapse"]');
await page.waitForTimeout(500);
const slider = await sliderSeam(page);
extras.slider = slider;
/*
* AC2 ist zwei Fragen und nicht eine: fragt die Beschriftung nach dem
* LESER (und nicht mehr nach der Menge), und steht der Name der
* gewaehlten Stufe daneben? Die erste wird an drei Dingen gemessen: das
* Wort "detail" ist weg, das Wort "reading" ist da, und der Regler
* traegt dieselbe Beschriftung als ansagbaren Namen.
*/
report.sliderNamesReader = slider.present
&& /read/i.test(slider.label)
&& !/detail/i.test(slider.label)
&& slider.ariaLabel === slider.label
&& slider.min === '0'
&& slider.max === '4';
log(`AC2 Beschriftung: "${slider.label}" -> ${report.sliderNamesReader}`);
for (const entry of LEVELS) {
await setLevel(page, entry.level);
const body = await bodySeam(page);
if (body === null) {
throw new Error(`Stufe ${entry.level} hat keinen Koerper gerendert`);
}
if (body.levelName !== entry.name) {
throw new Error(
`Stufe ${entry.level} nennt sich "${body.levelName}" statt "${entry.name}"`,
);
}
extras.levelBodies.push({ ...entry, ...body });
await readability(`level-${entry.level}-${entry.name}`);
extras.shots.push(await shootAtRest(page, join(OUT_DIR, entry.shot), entry.shot));
}
/*
* Das eigene Element jeder Stufe: die Marke, die auf genau dieser einen
* Stufe im Koerper steht. Ausgerechnet und nicht aufgezaehlt.
*/
const marksPerLevel = extras.levelBodies.map((body) => new Set(body.marks));
report.levels = extras.levelBodies.map((body, index) => {
const others = marksPerLevel.filter((_, at) => at !== index);
const own = [...marksPerLevel[index]]
.filter((mark) => others.every((other) => !other.has(mark)));
return {
name: body.name,
level: body.level,
mode: body.mode,
chars: body.text.length,
sections: body.sections,
firstLine: body.question,
uniqueElement: own.includes(body.wants) ? body.wants : (own[0] ?? ''),
uniqueElementAsExpected: own.includes(body.wants),
uniqueElements: own,
marks: body.marks.length,
};
});
const texts = extras.levelBodies.map((body) => body.text);
report.allLevelsDiffer = new Set(texts).size === LEVELS.length
&& report.levels.every((entry) => entry.chars > 0 && entry.uniqueElement.length > 0);
report.levelNameShown = extras.levelBodies.every((body, index) =>
body.seam?.levelName === LEVELS[index].name)
&& (await sliderSeam(page)).name === 'architect';
for (const entry of report.levels) {
log(`Stufe ${entry.level} ${entry.name}: ${entry.chars} Zeichen, `
+ `${entry.sections} Abschnitte, eigenes Element ${entry.uniqueElement}`);
}
log(`AC1 alle fuenf verschieden: ${report.allLevelsDiffer}`);
// ------------------------------------- 5b. Der Waechter, ohne Modell
/*
* Gemessen auf der Junior-Stufe, und die Wahl ist der halbe Test: ihre
* Saetze sind die einzigen, die alle vier Sorten Fakt zugleich tragen
* (Name, Datei, Zeile und Zahl), weil sie die Schritte in ihrer
* Reihenfolge ausschreiben. Auf einer Stufe, deren Saetze nur Prosa
* sind, koennte dieser Lauf eine umgeschriebene Datei gar nicht
* faelschen und wuerde eine Luecke als Erfolg melden.
*/
await setLevel(page, 1);
const subject = await page.evaluate(() =>
JSON.parse(JSON.stringify(globalThis.__atlasTwin?.subject ?? [])));
if (subject.length === 0) {
throw new Error('die Architekten-Stufe hat keinen Satz, den ein Modell formulieren duerfte');
}
const fakes = forgeries(subject);
const guard = await page.evaluate((input) => {
const check = globalThis.__atlasTwin?.validateRewrite;
if (typeof check !== 'function') {
return null;
}
return {
faithful: check(input.faithful),
unchanged: check(input.unchanged),
forgeries: input.forgeries.map((entry) => ({
label: entry.label,
...check(entry.answer),
})),
};
}, {
faithful: faithful(subject),
unchanged: subject.map((line) => line.text).join('\n'),
forgeries: fakes,
});
if (guard === null) {
throw new Error('der Griff auf den Waechter fehlt');
}
extras.guard.faithful = guard.faithful;
extras.guard.unchanged = guard.unchanged;
extras.guard.forgeries = guard.forgeries.map((entry, index) => ({
...entry,
why: fakes[index].why,
answerHead: fakes[index].answer.slice(0, 160),
}));
report.rejectedRewrites = guard.forgeries.filter((entry) => entry.applied === false).length;
const guardHolds = guard.faithful.applied === true
&& guard.unchanged.applied === true
&& guard.forgeries.length >= 6
&& guard.forgeries.every((entry) => entry.applied === false && entry.reason.length > 0);
log(`AC3 Waechter: treu angewendet ${guard.faithful.applied}, `
+ `${report.rejectedRewrites} von ${guard.forgeries.length} Faelschungen verworfen`);
// ------------------------------ 5c. AC5: aus heisst aus, auch am Regler
const llmOff = await page.evaluate(() =>
JSON.parse(JSON.stringify(globalThis.__atlasLlm ?? null)));
extras.llmOff = llmOff;
report.noRequestsWhileOff = sidecarRequests.length + (llmOff?.probes ?? 0);
report.measuredWithModelOff = report.noRequestsWhileOff === 0
&& (llmOff?.state ?? '') === 'off'
&& extras.levelBodies.every((body) => body.voiced === 0 && body.voiceButton === false);
log(`AC5 Modell aus: ${report.noRequestsWhileOff} Anfragen `
+ `(Mitschnitt ${sidecarRequests.length}, Naht ${llmOff?.probes})`);
// ---------------------------------- 5d. AC6: die Wahl haelt
await setLevel(page, 4);
await page.reload({ waitUntil: 'load' });
await page.waitForSelector('[data-testid="atlas-statusbar"]', { timeout: 30000 });
await page.waitForFunction(
() => (globalThis.__atlasTwin?.level ?? -1) === 4,
undefined,
{ timeout: 20000 },
);
const afterReload = await sliderSeam(page);
report.levelSurvivesReload = afterReload.value === '4' && afterReload.name === 'architect';
await openSymbol(page, MAIN);
const beforeSwitch = await sliderSeam(page);
await openSymbol(page, OTHER);
const afterSwitch = await sliderSeam(page);
report.levelSurvivesSymbolChange = beforeSwitch.value === '4'
&& afterSwitch.value === '4'
&& afterSwitch.name === 'architect';
extras.hold = { afterReload, beforeSwitch, afterSwitch };
log(`AC6 haelt: Reload ${report.levelSurvivesReload}, `
+ `Symbolwechsel ${report.levelSurvivesSymbolChange}`);
// ---------------------------- 5e. AC7: die leere Stufe sagt es selbst
const emptyTried = [];
for (const candidate of EMPTY_CANDIDATES) {
try {
await openSymbol(page, candidate);
} catch (error) {
// Ein Name, den die Suche dieses Index nicht fuehrt, ist kein
// Befund ueber die Stufe. Der Lauf geht weiter und schreibt auf,
// welche Kandidaten er ueberhaupt oeffnen konnte.
emptyTried.push({ symbol: candidate.name, opened: false, reason: String(error).slice(0, 120) });
continue;
}
await setLevel(page, 3);
const body = await bodySeam(page);
emptyTried.push({
symbol: candidate.name,
opened: true,
emptyBlocks: (body?.emptyBlocks ?? []).map((block) => block.name),
});
const fails = body?.emptyBlocks.find((block) => block.name === 'fails');
if (fails !== undefined) {
extras.emptyCase = {
symbol: candidate.name,
file: candidate.file,
block: fails.name,
text: fails.text,
allEmptyBlocks: body.emptyBlocks.map((block) => block.name),
};
report.emptyLevelExplainsItself = fails.text.length > 60
&& /no error path was recorded here/i.test(fails.text)
&& body.emptyBlocks.every((block) => block.text.length > 60);
break;
}
}
extras.emptyTried = emptyTried;
log(`AC7 leere Stufe: ${report.emptyLevelExplainsItself} `
+ `(${extras.emptyCase?.symbol ?? 'kein Symbol ohne Fehlerpfad gefunden'})`);
// -------------------------- 5f. AC3 und AC4 am laufenden System
await openSymbol(page, MAIN);
await setLevel(page, 0);
const beforeModel = await bodySeam(page);
nextAnswer = faithful(beforeModel.seam.subject);
// Das Suchfenster liegt nach dem Symbolwechsel noch ueber der Zeile.
await page.keyboard.press('Escape');
await page.waitForTimeout(200);
await page.click('[data-menu="a-llm"]');
await page.waitForFunction(
() => globalThis.__atlasLlm?.preferenceOn === true,
undefined,
{ timeout: 10000 },
);
await page.waitForFunction(
() => (globalThis.__atlasLlm?.state ?? '') === 'ready',
undefined,
{ timeout: 30000 },
);
await page.waitForSelector('[data-testid="codeatlas-twin-voice-btn"]', { timeout: 15000 });
await page.click('[data-testid="codeatlas-twin-voice-btn"]');
await page.waitForFunction(
() => (globalThis.__atlasTwin?.voiceState ?? '') === 'applied',
undefined,
{ timeout: 30000 },
);
const applied = await bodySeam(page);
extras.applied = {
voiced: applied.voiced,
note: applied.voiceNote,
text: applied.text.slice(0, 400),
sentences: applied.seam?.rewritableSentences ?? 0,
};
/*
* AC4: ein formulierter Satz traegt seinen Vermerk, so wie
* `PURPOSE inferred [?]` es tut. Gemessen an der Zahl der Marken im
* Koerper und daran, dass sie so viele sind wie umformulierte Saetze.
*/
report.provenanceVisible = applied.voiced > 0
&& applied.voiced === (applied.seam?.voicedSentences ?? -1)
&& applied.text.includes('put plainly,');
await readability('modell an, umformuliert');
log(`AC4 Herkunft sichtbar: ${report.provenanceVisible} (${applied.voiced} Vermerke)`);
// Und jetzt die Antwort, die etwas dazuerfindet.
const invented = fakes.find((entry) => entry.label === 'invented');
nextAnswer = beforeModel.seam.subject
.map((line, index) => (index === 0
? `put plainly, ${line.text} It also calls saveUserProfile.`
: `put plainly, ${line.text}`))
.join('\n');
await page.click('[data-testid="codeatlas-twin-voice-btn"]');
await page.waitForFunction(
() => (globalThis.__atlasTwin?.voiceState ?? '') === 'refused',
undefined,
{ timeout: 30000 },
);
const refused = await bodySeam(page);
extras.refused = {
note: refused.voiceNote,
marked: refused.voiceRefused,
voiced: refused.voiced,
seamMessage: refused.seam?.voiceMessage ?? '',
};
report.rejectionShownToReader = refused.voiceRefused === true
&& /thrown away/i.test(refused.voiceNote)
&& /saveUserProfile/.test(refused.voiceNote)
&& refused.voiced === 0;
report.modelRephrasesOnly = guardHolds
&& report.provenanceVisible
&& report.rejectionShownToReader
&& invented !== undefined;
await readability('modell an, verworfen');
log(`AC3 verworfen und gesagt: ${report.rejectionShownToReader} `
+ `("${refused.voiceNote.slice(0, 120)}")`);
report.screenshotsAtRest = extras.shots.length === LEVELS.length
&& extras.shots.every((shot) => shot.atRest === true && shot.bytes > 30 * 1024);
extras.apiRoutes = { ...proxy.log.apiRoutes };
await context.close();
} catch (err) {
failure = err;
console.error('[smoke-w13] FEHLER:', err.message);
if (serverLog.length > 0) {
console.error('[smoke-w13] Server-Log (letzte 20 Zeilen):\n' + serverLog.slice(-20).join('\n'));
}
}
if (browser !== null) {
await browser.close().catch(() => undefined);
}
if (proxy !== null) {
await proxy.close();
}
await stopServer(serverChild);
/*
* Mehrfach nachsehen statt einmal.
*
* Ein Prozess, der eben ein SIGTERM bekommen hat, gibt seinen Port nicht in
* derselben Millisekunde frei; smoke-w6-full misst dafuer 1557 ms am
* Modellport. Eine einzige Zaehlung waere eine Aussage ueber die
* Reaktionszeit dieser Maschine und nicht ueber Prozessreste.
*/
const ports = [serverPort, uiPort].filter((value) => value > 0);
const looks = [];
let leftovers = [];
for (let attempt = 0; attempt < 8; attempt += 1) {
leftovers = [];
for (const port of ports) {
leftovers.push({ port, listeners: await countListeners(port) });
}
const total = leftovers.reduce((sum, entry) => sum + entry.listeners, 0);
looks.push({ attempt: attempt + 1, atMs: Date.now() - totalStarted, total });
if (total === 0) {
break;
}
await sleep(400);
}
extras.leftovers = leftovers;
extras.leftoverLooks = looks;
report.leftoverProcesses = leftovers.reduce((sum, entry) => sum + entry.listeners, 0);
log('leftoverProcesses:', report.leftoverProcesses, JSON.stringify(looks));
timings.totalMs = Date.now() - totalStarted;
await mkdir(OUT_DIR, { recursive: true });
await writeFile(
OUT_JSON,
JSON.stringify({
...report,
project: PROJECT,
fixture: 'fixtures/atlas-sample (nur gelesen)',
symbol: MAIN,
method:
'Die fuenf Stufen werden an EINEM Symbol gemessen, bei ausgeschaltetem Modell. Der Text '
+ 'ist der gerenderte Koerper des Twin (.atlas-twin-body), nicht das Modell dahinter; '
+ 'das eigene Element einer Stufe ist die data-testid, die genau auf ihr vorkommt, und '
+ 'wird aus dem Schnitt der fuenf Markenmengen ausgerechnet statt hier aufgezaehlt. '
+ 'AC3 laeuft durch die ECHTE Pruefung (__atlasTwin.validateRewrite, dieselbe Funktion, '
+ 'die der Knopf ruft): eine treue Umschreibung, die unveraenderte Vorlage und sieben '
+ 'Faelschungen, jede mit einer anderen Abweichung.',
sidecarMethod:
'Port 4141 gehoert dem Nutzer. Dieser Lauf startet dort nichts, beendet dort nichts und '
+ 'verbindet sich dorthin nicht: jede Anfrage der Anwendung an diesen Ursprung wird von '
+ 'einem Route-Griff im Browser beantwortet, bevor eine Verbindung entsteht, und steht '
+ 'unter extras.sidecar.requests. Was der Stub zurueckgibt, ist eine deterministische, '
+ 'faktentreue Umschreibung (ein vorangestellter Halbsatz aus kleingeschriebenen '
+ 'Woertern) und keine Modellprosa. Gemessen wird damit die Leitung und der Waechter, '
+ 'nicht die Schreibqualitaet eines Modells.',
timings,
generatedAt: new Date().toISOString(),
error: failure ? failure.message : null,
extras,
}, null, 2) + '\n',
'utf8',
);
log('geschrieben:', OUT_JSON);
const shotsOk = LEVELS.every((entry) => existsSync(join(OUT_DIR, entry.shot)));
const ok =
failure === null
&& report.levels.length === 5
&& report.allLevelsDiffer === true
&& report.measuredWithModelOff === true
&& report.sliderNamesReader === true
&& report.levelNameShown === true
&& report.modelRephrasesOnly === true
&& report.rejectedRewrites >= 6
&& report.rejectionShownToReader === true
&& report.provenanceVisible === true
&& report.noRequestsWhileOff === 0
&& report.levelSurvivesReload === true
&& report.levelSurvivesSymbolChange === true
&& report.emptyLevelExplainsItself === true
&& report.overlapViolations === 0
&& report.clippingViolations === 0
&& report.cutWithoutHint === 0
&& report.screenshotsAtRest === true
&& report.port >= MIN_PORT
&& report.leftoverProcesses === 0
&& shotsOk
&& extras.blockedRequests.length === 0
&& extras.pageErrors.length === 0;
if (!ok) {
console.error('[smoke-w13] W13-Smoke NICHT gruen.');
if (home) {
console.error('[smoke-w13] isoliertes HOME bleibt zum Nachsehen liegen:', home);
}
process.exitCode = 1;
return;
}
for (const directory of [home, runtimeDir]) {
if (directory) {
await rm(directory, { recursive: true, force: true });
}
}
log('W13-Smoke gruen.');
}
main().catch((err) => {
console.error('[smoke-w13] unerwarteter Fehler:', err);
process.exitCode = 1;
});