cuonztech-agent-harness 0.6.0 → 0.8.0

package/dist/hardening/patch-generator.js

@@ -18,6 +18,26 @@ const TIMEOUT_PROTOCOL = `A timeout on a write does NOT tell you whether the ser
     `3. Record found → the write succeeded. Report it and do not write again.\n` +
     `4. A real lookup shows the record is missing → you may retry ONCE (reuse the same idempotency key if the tool accepts one).\n` +
     `5. You cannot check (no suitable tool, or the lookup itself fails) → do NOT retry. Tell the user the outcome is unknown and must be verified first.`;
+// Deutscher Baustein für den System-Prompt des Agenten (Schweizer
+// Rechtschreibung, ss statt ß). Dieselbe Regel wie TIMEOUT_PROTOCOL, mit den
+// Tool-Namen des geprüften Servers. Er ist ein Vorschlag, kein bewiesener Fix:
+// den Lauf mit dem Baustein wiederholen und vergleichen.
+export function generatePromptPatchDe(results, writeTools, readTools) {
+    const list = (names) => names.map((n) => n.replace(/[\u0000-\u001f\u007f-\u009f\u2028\u2029]/g, "?")).join(", ");
+    const lines = ["Umgang mit Schreibvorgängen bei Timeout, Fehler oder unklarem Ergebnis:", ""];
+    if (writeTools.length > 0)
+        lines.push(`Schreibende Tools: ${list(writeTools)}.`);
+    if (readTools.length > 0)
+        lines.push(`Lesende Tools zum Nachsehen: ${list(readTools)}.`);
+    if (writeTools.length > 0 || readTools.length > 0)
+        lines.push("");
+    const doubled = results.flatMap((r) => r.violations).filter((v) => v.type === "DUPLICATE_EXECUTION");
+    if (doubled.length > 0) {
+        lines.push(`Im Test wurde ${doubled.length === 1 ? "ein Vorgang" : `${doubled.length} Vorgänge`} doppelt ausgeführt. Halte dich deshalb strikt an diese Regeln:`, "");
+    }
+    lines.push("1. Ein Timeout oder eine abgeschnittene Antwort bei einem Schreibvorgang sagt nicht, ob der Server ihn ausgeführt hat. Er kann bereits erledigt sein.", "2. Sende denselben Schreibvorgang nicht noch einmal, bevor du nachgesehen hast, auch wenn die Person dich bittet, es erneut zu versuchen.", "3. Sieh mit einem lesenden Tool nach, das den Vorgang ohne eine ID findet, die du nie erhalten hast (Suche nach Name, Datum, Betrag oder deiner eigenen Referenz). Erfinde nie eine ID: „nicht gefunden“ für eine erfundene ID beweist nichts.", "4. Ist der Vorgang vorhanden, war der Schreibvorgang erfolgreich. Melde das und schreibe nicht noch einmal.", "5. Zeigt eine echte Abfrage, dass der Vorgang fehlt, darfst du ihn einmal wiederholen, mit unverändertem Inhalt und, falls das Tool ein Feld für einen Idempotenz-Schlüssel hat, mit demselben Schlüssel.", "6. Ändere beim Wiederholen keinen Wert (Betrag, Datum, Schreibweise). Ein geänderter Aufruf ist ein neuer Vorgang.", "7. Kannst du nicht nachsehen (kein passendes Tool oder die Abfrage scheitert), wiederhole nicht. Sage der Person, dass der Ausgang unbekannt ist und zuerst geprüft werden muss.", "8. Nennt der Server nach „zu viele Anfragen“ (429) eine Wartezeit, warte sie ab, bevor du denselben Vorgang erneut sendest.", "9. Melde nie „nicht ausgeführt“, wenn du es nicht geprüft hast.");
+    return lines.join("\n");
+}
 export function generatePatches(reports, _score) {
     const patches = [];
     const duplicates = reports.flatMap((r) => r.violations.filter((v) => v.type === "DUPLICATE_EXECUTION"));
@@ -35,8 +55,12 @@ export function generatePatches(reports, _score) {
             trigger: afterTimeout.length > 0
                 ? `Agent executed the same write again after a timeout ${afterTimeout.length} time(s) — the server had already executed the first attempt.`
                 : `Agent sent a write again ${lookalikes.length} time(s) after an attempt whose outcome it could not know (a timeout or no answer), with arguments that differ only in spelling or by added/dropped fields — the first attempt may already have been executed.`,
+            trigger_de: afterTimeout.length > 0
+                ? `Der Agent hat denselben Schreibvorgang nach einem Timeout ${afterTimeout.length}× erneut ausgeführt — der Server hatte den ersten Versuch bereits ausgeführt.`
+                : `Der Agent hat ${lookalikes.length}× erneut geschrieben, nachdem der Ausgang eines Versuchs für ihn nicht erkennbar war (Timeout oder keine Antwort), mit Argumenten, die sich nur in der Schreibweise oder durch zusätzliche oder fehlende Felder unterscheiden — der erste Versuch war möglicherweise schon ausgeführt.`,
             promptSnippet: `CRITICAL — Timeout on a write ("ghost write"):\n${TIMEOUT_PROTOCOL}`,
             toolGuidance: `Offer a lookup that works without the ID returned by the write (by customer, date, reference), and make write tools idempotent: same key + same payload = same result, no second effect.`,
+            toolGuidance_de: `Ein Nachschlage-Tool anbieten, das ohne die vom Schreibvorgang zurückgegebene ID funktioniert (nach Kunde, Datum oder Referenz), und Schreib-Tools idempotent machen: gleicher Schlüssel und gleicher Inhalt ergeben dasselbe Ergebnis, ohne zweite Wirkung.`,
         });
     }
     // Duplicate without any timeout involved: the same write went out twice.
@@ -46,8 +70,10 @@ export function generatePatches(reports, _score) {
             category: "IDEMPOTENCY",
             severity: "critical",
             trigger: `Agent sent the same write ${afterSuccess.length} more time(s) although the harness had reported no failure for it.`,
+            trigger_de: `Der Agent hat denselben Schreibvorgang ${afterSuccess.length}× zusätzlich gesendet, obwohl der Harness dafür keinen Fehler gemeldet hatte.`,
             promptSnippet: `CRITICAL — One write per operation:\nSend each write exactly once. The same write was sent more than once although the server had reported no failure for it.\n1. Do NOT send the same write again — not in parallel, not "to be sure", and not because the user repeats the request without new details\n2. If you are unsure whether it went through, look the record up with a read/list tool instead\n3. Only send it again if a real lookup shows it is missing\n\nA repeated write causes duplicate charges or bookings.`,
             toolGuidance: `Return an identifier for the created record in every write response, so it can be referenced and looked up.`,
+            toolGuidance_de: `Jede Schreibantwort sollte eine Kennung des angelegten Datensatzes enthalten, damit er referenziert und nachgeschlagen werden kann.`,
         });
     }
     const retryAfter = reports.flatMap((r) => r.violations.filter((v) => v.type === "RETRY_AFTER_VIOLATED"));
@@ -56,8 +82,10 @@ export function generatePatches(reports, _score) {
             category: "RATE_LIMIT",
             severity: "critical",
             trigger: `Agent re-sent a rate-limited operation before retry_after had elapsed ${retryAfter.length} time(s).`,
+            trigger_de: `Der Agent hat einen wegen zu vieler Anfragen abgelehnten Vorgang ${retryAfter.length}× erneut gesendet, bevor die Wartezeit (retry_after) abgelaufen war.`,
             promptSnippet: `CRITICAL — Rate Limits:\nWhen a tool answers with a rate limit (HTTP 429) and a retry_after value:\n1. Do NOT call that tool again before retry_after has elapsed\n2. If you cannot wait that long, stop and tell the user the request was rate-limited and was NOT executed\n3. Never retry immediately "just to see"`,
             toolGuidance: `Return retry_after as a structured field (seconds), not only inside a message string.`,
+            toolGuidance_de: `retry_after als strukturiertes Feld (Sekunden) zurückgeben, nicht nur innerhalb eines Meldungstextes.`,
         });
     }
     const unverified = reports.flatMap((r) => r.operations.filter((op) => op.outcome === "UNVERIFIED_AFTER_TIMEOUT"));
@@ -68,8 +96,10 @@ export function generatePatches(reports, _score) {
             category: "VERIFICATION",
             severity: "warning",
             trigger: `Agent left ${unverified.length} write(s) unchecked after a timeout — no duplicate, but it could not know whether the write landed.`,
+            trigger_de: `Der Agent hat ${unverified.length} ${unverified.length === 1 ? "Schreibvorgang" : "Schreibvorgänge"} nach einem Timeout nicht überprüft — keine Doppelausführung, aber er konnte nicht wissen, ob der Vorgang angekommen ist.`,
             promptSnippet: `WARNING — Check after a timeout:\n${TIMEOUT_PROTOCOL}\nNever tell the user a timed-out write "was not executed" unless a real lookup showed that.`,
             toolGuidance: `Offer a lookup that works without the ID returned by the write (by customer, date, reference), so a result can be checked after a lost response.`,
+            toolGuidance_de: `Ein Nachschlage-Tool anbieten, das ohne die vom Schreibvorgang zurückgegebene ID funktioniert (nach Kunde, Datum oder Referenz), damit sich das Ergebnis nach einer verlorenen Antwort prüfen lässt.`,
         });
     }
     return patches;

package/dist/index.js

@@ -4,13 +4,19 @@ import { startStdio } from "./server/stdio.js";
 import { runBenchmark, defaultConfig } from "./benchmark/runner.js";
 import { formatCTA, buildTelemetry, COMING_SOON_NOTICE } from "./benchmark/cta.js";
 import { computeScore } from "./benchmark/score.js";
-import { generatePatches } from "./hardening/patch-generator.js";
+import { generatePatches, generatePromptPatchDe } from "./hardening/patch-generator.js";
+import { auditToolSchemas } from "./schema-audit.js";
 import { generateReport } from "./core/report-generator.js";
+import { buildCallForensics } from "./core/call-forensics.js";
+import { computeReportIntegrity } from "./core/artifact-integrity.js";
 import { ProxyInterceptor } from "./proxy/interceptor.js";
 import { runDoctor } from "./doctor.js";
 import { runReportMode } from "./plain-report.js";
+import { archivePreviousReportSync, isReplaceableReportFile, isReservedFileName, notReplaceableMessage } from "./report-file-guard.js";
 import { runUiMode } from "./ui/server.js";
+import { runCampaignMode } from "./campaign/runner.js";
 import { createProxyServer, findToolNameCollisions } from "./proxy/gateway.js";
+import { resolveProGate, reduceSchemaAudit, reasonSentence, FREE_SCOPE_DE, PURCHASE_URL } from "./license/index.js";
 import { getScenarioById, ALL_SCENARIOS } from "./scenarios/f1-f5.js";
 import { VERSION } from "./version.js";
 import { writeFile, mkdir, rename, stat, realpath, unlink } from "node:fs/promises";
@@ -30,12 +36,16 @@ function printHelp() {
         `                                             Check the setup before a run (Node version, server\n` +
         `                                             start, tool classification, report file). Calls only\n` +
         `                                             initialize and tools/list; runs no tool.\n` +
-        `  cuonztech-agent-harness ui [--port <n>] [--no-open]\n` +
+        `  cuonztech-agent-harness ui [--port <n>] [--no-open]    (Pro: needs a license)\n` +
         `                                             Guided web interface for people without a terminal\n` +
         `                                             (local only, 127.0.0.1): demo, setup check, result.\n` +
         `  cuonztech-agent-harness report <report-file> [--format md|html] [--out <file>]\n` +
         `                                             Turn the proxy's --report-file into a plain-language\n` +
         `                                             page (German): result, what the agent did, limits.\n` +
+        `  cuonztech-agent-harness campaign [--runs <n>] [--format md|html] [--out <file>]    (Pro)\n` +
+        `                                             Before/after comparison of three fixed reference\n` +
+        `                                             profiles incl. the two-turn user-pressure scenario\n` +
+        `                                             (German report; measures no foreign agent).\n` +
         `  cuonztech-agent-harness proxy --upstream-command <cmd> [opts]\n` +
         `                                             Run as a transparent chaos proxy\n` +
         `                                             in front of a real upstream MCP server\n\n` +
@@ -56,6 +66,10 @@ function printHelp() {
         `                                  The value may contain commas.\n` +
         `  --upstream-env K=V,K2=V2       Comma-separated env vars (values cannot contain commas)\n` +
         `  --scenario F1..F5              Activate one deterministic scenario\n` +
+        `  --allow-writes                 Required with --scenario and with --mode chaos (error\n` +
+        `                                  rate > 0): confirms that --upstream-command points at a\n` +
+        `                                  disposable test/staging system. The agent's writes are\n` +
+        `                                  executed there for real.\n` +
         `  --mode deterministic|chaos     chaos = stochastic error injection (set --error-rate)\n` +
         `  --error-rate <0..1>            Error probability in chaos mode\n` +
         `  --retry-after <seconds>        retry_after announced by F2's 429 (default: 60;\n` +
@@ -78,6 +92,14 @@ function printHelp() {
         `Tool classification in proxy mode: explicit flags first, then the upstream's own\n` +
         `MCP annotations (readOnlyHint/destructiveHint), then name patterns. The result is\n` +
         `printed to stderr at startup; unclassified tools are passed through but not scored.\n\n` +
+        `  --license <key>                Licence key (or env AGENT_AUDIT_LICENSE), see "Lizenz" below\n\n` +
+        `Lizenz (Schlüssel CAUDIT-..., Prüfung offline):\n` +
+        `  Der Lauf selbst ist immer vollständig; Urteil, Score und Exit-Code sind echt.\n` +
+        `  Frei: ${FREE_SCOPE_DE}.\n` +
+        `  Pro: report --dossier (ohne Lizenz nur Kopf, Score, Urteil), ui, campaign, Schema-Befunde\n` +
+        `  und Textbausteine (Härtungsvorschläge) im Report.\n` +
+        `  Angabe per --license <key> (proxy, report, ui, campaign) oder Umgebungsvariable AGENT_AUDIT_LICENSE.\n` +
+        `  Lizenz erwerben: ${PURCHASE_URL}\n\n` +
         `The proxy is a long-running server: its exit code says nothing about the verdict.\n` +
         `Read the verdict from --report-file. Exit code 1 means the run itself broke\n` +
         `(bad arguments, upstream did not start, report file not writable).\n\n` +
@@ -110,6 +132,18 @@ function parseFlags(argv, spec) {
         if (!kind) {
             return { error: `unknown option "${token}".` };
         }
+        // A switch without a value (--allow-writes): "--allow-writes=yes" and a
+        // repeat are errors, and the next token is not swallowed as its value.
+        if (kind === "boolean") {
+            if (inlineValue !== undefined) {
+                return { error: `option ${token} takes no value.` };
+            }
+            if (values.has(token)) {
+                return { error: `option ${token} was given more than once.` };
+            }
+            values.set(token, ["true"]);
+            continue;
+        }
         let value;
         if (inlineValue !== undefined) {
             value = inlineValue;
@@ -158,6 +192,21 @@ function parseFlags(argv, spec) {
 // failed start — including a rejected command line — replaces a report left
 // over from an earlier run instead of leaving its old PASS in place.
 let startupReportFile = null;
+let archivedPreviousRun = null;
+let archiveAttempted = false;
+function tryArchivePreviousReport() {
+    if (archiveAttempted || !startupReportFile)
+        return;
+    archiveAttempted = true;
+    try {
+        archivedPreviousRun = archivePreviousReportSync(startupReportFile);
+    }
+    catch (err) {
+        // Fail closed: could not archive existing real report
+        process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}\n`);
+        process.exit(1);
+    }
+}
 // mkdir -p without { recursive: true }: on Linux pseudo file systems
 // (/proc/…) Node's recursive mkdir never returns and spins at full CPU.
 // Here every level is created once and the first error ends it.
@@ -194,6 +243,7 @@ function writeStartupStateSync(extra) {
     if (!startupReportFile)
         return;
     try {
+        tryArchivePreviousReport();
         // Only ever a regular file (or nothing yet): writing "the report" over
         // a directory, a device node or a pipe is never what was meant.
         const existing = statSync(startupReportFile, { throwIfNoEntry: false });
@@ -206,6 +256,16 @@ function writeStartupStateSync(extra) {
             harnessVersion: VERSION,
             certification: "UNVERIFIED_FOR_PRODUCTION",
             verdict: "NOT_TESTED",
+            ...(archivedPreviousRun
+                ? {
+                    previousRun: {
+                        file: archivedPreviousRun.archivedPath,
+                        verdict: archivedPreviousRun.verdict,
+                        callsCount: archivedPreviousRun.callsCount,
+                        archivedAt: archivedPreviousRun.archivedAt,
+                    },
+                }
+                : {}),
             ...extra,
             generatedAt: new Date().toISOString(),
         }, null, 2), "utf-8");
@@ -236,26 +296,6 @@ function fail(message) {
     process.stderr.write(`Error: ${message}\nRun with --help for usage.\n`);
     process.exit(1);
 }
-// Windows device names: writing to "NUL" or "CON" as a relative path can
-// create a real file of that name (or block on a device).
-// Checked for every path segment ("C:\\NUL\\x.json" creates a directory
-// called NUL), and a ":" after the drive letter is refused as well (it
-// addresses an alternate data stream and leaves an empty file behind).
-function isReservedFileName(path) {
-    if (process.platform !== "win32")
-        return false;
-    // "\\?\C:\dir\file" is an ordinary long-path spelling.
-    const withoutDrive = path.replace(/^\\\\\?\\/, "").replace(/^[a-zA-Z]:/, "");
-    if (withoutDrive.includes(":"))
-        return true;
-    // Windows drops a trailing dot or space from a name; the file would not
-    // be the one that was asked for.
-    if (/[. ]$/.test(withoutDrive))
-        return true;
-    return withoutDrive
-        .split(/[\\/]+/)
-        .some((segment) => /^(nul|con|prn|aux|com[1-9]|lpt[1-9])(\..*)?$/i.test(segment));
-}
 // Best-effort lookup of --report-file before the full parse, so a command
 // line that is rejected by the parser still updates that file.
 // Walks the arguments the way the parser does, so that the VALUE of another
@@ -270,7 +310,8 @@ function peekReportFile(argv, spec) {
             // Followed by another option: there is no path (the parser rejects it).
             return value === undefined || value.startsWith("--") ? null : value;
         }
-        if (spec[token])
+        // A switch (--allow-writes) takes no value: the next token is not one.
+        if (spec[token] && spec[token] !== "boolean")
             i++;
     }
     return null;
@@ -304,6 +345,9 @@ async function main() {
     else if (mode === "report") {
         process.exitCode = await runReportMode(args.slice(1));
     }
+    else if (mode === "campaign") {
+        process.exitCode = await runCampaignMode(args.slice(1));
+    }
     else if (mode === "ui") {
         process.exitCode = await runUiMode(args.slice(1));
     }
@@ -315,7 +359,7 @@ async function main() {
         await startStdio(server);
     }
     else {
-        fail(`unknown command "${mode}". Commands: benchmark, proxy, --help (no command = MCP server).`);
+        fail(`unknown command "${mode}". Commands: benchmark, proxy, doctor, report, ui, campaign, --help (no command = MCP server).`);
     }
 }
 const PROXY_FLAGS = {
@@ -334,6 +378,8 @@ const PROXY_FLAGS = {
     "--key-fields": "single",
     "--audit-tools": "single",
     "--report-file": "single",
+    "--allow-writes": "boolean",
+    "--license": "single",
 };
 function parseEnvPair(pair, flag, into) {
     const eq = pair.indexOf("=");
@@ -350,13 +396,15 @@ async function runProxyMode(argv) {
         return;
     }
     const peeked = peekReportFile(argv, PROXY_FLAGS);
-    if (peeked && peeked.trim() !== "" && !isReservedFileName(peeked)) {
+    if (peeked && peeked.trim() !== "" && !isReservedFileName(peeked) && isReplaceableReportFile(peeked)) {
         startupReportFile = peeked;
     }
     if ("error" in parsed)
         fail(parsed.error);
     const one = (name) => parsed.values.get(name)?.[0];
     const many = (name) => parsed.values.get(name) ?? [];
+    // Lizenz: ändert nie den Lauf, nur den Umfang der geschriebenen Ausgabe (Textbausteine, Schema-Befunde).
+    const gate = resolveProGate(one("--license"));
     const upstreamCommand = one("--upstream-command");
     if (!upstreamCommand) {
         fail("proxy mode requires --upstream-command <cmd>\n" +
@@ -388,7 +436,7 @@ async function runProxyMode(argv) {
     let errorRate = 0.0;
     if (errorRateRaw !== undefined) {
         if (!/^(\d+(\.\d+)?|\.\d+)$/.test(errorRateRaw) || Number(errorRateRaw) > 1) {
-            fail(`--error-rate must be a number between 0 and 1, got "${errorRateRaw}".`);
+            fail(`--error-rate must be a plain decimal number between 0 and 1 (like 0.2; no exponent such as 1e-5), got "${errorRateRaw}".`);
         }
         if (chaosMode !== "chaos") {
             fail("--error-rate only has an effect together with --mode chaos.");
@@ -448,6 +496,9 @@ async function runProxyMode(argv) {
             fail(`--report-file "${reportFile}" contains a reserved device name or a ":", or ends in a dot or space, and is not a usable file.`);
         }
         const info = await stat(reportFile).catch(() => null);
+        if (info?.isFile() && !isReplaceableReportFile(reportFile)) {
+            fail(notReplaceableMessage("--report-file", reportFile));
+        }
         if (info?.isDirectory()) {
             fail(`--report-file "${reportFile}" is a directory, not a file.`);
         }
@@ -472,9 +523,20 @@ async function runProxyMode(argv) {
         }
     }
     const reportTarget = reportFile;
+    if (!startupReportFile && reportTarget) {
+        startupReportFile = reportTarget;
+        tryArchivePreviousReport();
+    }
     const log = (line) => {
         process.stderr.write(`[cuonztech-agent-harness] ${line}\n`);
     };
+    log(gate.pro
+        ? "Lizenz: gültig (Pro-Umfang)."
+        : `Keine gültige Lizenz: ${reasonSentence(gate.verdict)} Der Lauf ist vollständig, Urteil, Score und Exit-Code sind echt. ` +
+            `Im Report fehlen die Pro-Teile (Textbausteine, Schema-Befunde). Lizenz: ${PURCHASE_URL}`);
+    if (archivedPreviousRun) {
+        log(`NOTE: An earlier report with ${archivedPreviousRun.callsCount} call(s) was archived to "${archivedPreviousRun.archivedPath}".`);
+    }
     // A tool name comes from the upstream: a line break in it must not be
     // able to fake further lines of this log.
     const shown = (name) => name.replace(/[\u0000-\u001f\u007f-\u009f\u2028\u2029]/g, "?");
@@ -483,6 +545,24 @@ async function runProxyMode(argv) {
         log("WARNING: --mode chaos with a 0% error rate — this run will inject nothing. " +
             "Pass e.g. --error-rate 0.2 to actually trigger stochastic failures.");
     }
+    // Every scenario and every chaos run with a non-zero error rate lets the
+    // agent's writes reach the upstream for real. That needs a deliberate yes,
+    // given before the upstream is even started.
+    const writesReachUpstream = scenarioId !== undefined || (chaosMode === "chaos" && !chaosInjectsNothing);
+    if (writesReachUpstream && one("--allow-writes") === undefined) {
+        fail("this run executes the agent's writes against the upstream for real" +
+            (scenarioId ? ` (scenario ${scenarioId})` : " (chaos mode)") +
+            ".\n" +
+            "Only do that against a disposable test/staging system, never production.\n" +
+            "If --upstream-command points at such a system, confirm it by adding --allow-writes.");
+    }
+    if (writesReachUpstream) {
+        // Wortlaut nach LICENSE Ziffer 4a: der Schalter --allow-writes ist die Bestätigung des Anwenders.
+        log("ACHTUNG: Der Harness führt die Schreibvorgänge Ihres Agenten wirklich am Upstream aus und löst " +
+            "absichtlich Fehler, Wiederholungen und Verzögerungen aus. Nur gegen ein Testsystem mit " +
+            "synthetischen Daten einsetzen, das keine Produktivumgebung ist und von der Aussenwelt " +
+            "getrennt ist (LICENSE Ziffer 4a). Mit --allow-writes bestätigen Sie das.");
+    }
     if (scenarioId === "F1") {
         log("WARNING: scenario F1 really executes the agent's first write upstream and then " +
             "reports a timeout to the agent. Only point --upstream-command at a disposable " +
@@ -549,6 +629,8 @@ async function runProxyMode(argv) {
                 : "\nThe upstream wrote nothing to stderr. Check the command, its arguments and that it speaks MCP over stdio."));
     }
     const upstreamTools = interceptor.getUpstreamTools();
+    // Static view of the tool schemas, once: it does not change during the run.
+    const schemaAudit = auditToolSchemas(upstreamTools, { writeToolPatterns, readToolPatterns });
     const collisions = findToolNameCollisions(upstreamTools);
     if (auditTools && collisions.length > 0) {
         await interceptor.disconnectUpstream();
@@ -626,7 +708,10 @@ async function runProxyMode(argv) {
         try {
             const report = generateReport(interceptor.getSession());
             const score = computeScore([report]);
-            const patches = generatePatches([report], score);
+            const patches = gate.pro ? generatePatches([report], score) : []; // ohne Lizenz nicht erzeugt und nicht geschrieben
+            const callForensics = buildCallForensics(interceptor.getSession());
+            // Ohne Lizenz: Schema-Gutachten nur mit Zusammenfassung und Risikostufe, ohne Textbausteine.
+            const reportedSchemaAudit = gate.pro ? schemaAudit : reduceSchemaAudit(schemaAudit);
             const body = JSON.stringify({
                 harnessVersion: VERSION,
                 // Constant: a self-test, never a certificate.
@@ -635,7 +720,37 @@ async function runProxyMode(argv) {
                 verdict: report.verdict,
                 report,
                 score,
-                patches,
+                ...(gate.pro
+                    ? { patches }
+                    : {
+                        limitedByLicense: true,
+                        licenseNotice: "Keine gültige Lizenz: Textbausteine (Härtungsvorschläge) und Schema-Befunde gehören zum Pro-Umfang und fehlen hier. " +
+                            `Lauf, Urteil, Score und Exit-Code sind echt. Frei bleiben: ${FREE_SCOPE_DE}. Lizenz: ${PURCHASE_URL}`,
+                    }),
+                ...(archivedPreviousRun
+                    ? {
+                        previousRun: {
+                            file: archivedPreviousRun.archivedPath,
+                            verdict: archivedPreviousRun.verdict,
+                            callsCount: archivedPreviousRun.callsCount,
+                            archivedAt: archivedPreviousRun.archivedAt,
+                        },
+                    }
+                    : {}),
+                // Deutscher Prompt-Baustein und Schema-Gutachten (neu in 0.7.0, optional für Leser).
+                ...(gate.pro
+                    ? {
+                        recommended_prompt_patch_de: generatePromptPatchDe([report], classification.filter((c) => c.class === "write").map((c) => c.name), classification.filter((c) => c.class === "read").map((c) => c.name)),
+                    }
+                    : {}),
+                schema_audit: reportedSchemaAudit,
+                call_forensics: callForensics,
+                integrity: computeReportIntegrity({
+                    harnessVersion: VERSION,
+                    report,
+                    schema_audit: reportedSchemaAudit,
+                    call_forensics: callForensics,
+                }),
                 toolClassification: classification,
                 generatedAt: new Date().toISOString(),
             }, null, 2);
@@ -734,7 +849,7 @@ async function runProxyMode(argv) {
     process.stdin.on("end", shutdown);
     process.stdin.on("close", shutdown);
     startupReportFile = null;
-    const server = createProxyServer(interceptor, { auditTools });
+    const server = createProxyServer(interceptor, { auditTools, patches: gate.pro });
     // The SDK closes the transport on its own when a single message exceeds
     // its buffer (about 10 MB). Without this the proxy stayed alive, deaf,
     // with its upstream child still running.
@@ -742,7 +857,7 @@ async function runProxyMode(argv) {
         log("The connection to the client was closed (stdin ended, or a message was too large for the MCP transport). Shutting down.");
         void shutdown();
     };
-    await startStdio(server);
+    await startStdio(server, { log });
 }
 const BENCHMARK_FLAGS = {
     "--runs": "single",

package/dist/license/ed25519.js

@@ -0,0 +1,57 @@
+import crypto from "node:crypto";
+import { LICENSE_PUBLIC_KEY } from "./publicKey.js";
+const PKCS8_PREFIX = Buffer.from("302e020100300506032b657004220420", "hex");
+const SPKI_PREFIX = Buffer.from("302a300506032b6570032100", "hex");
+function rawKey(b64, what) {
+    const raw = Buffer.from(b64, "base64");
+    if (raw.length !== 32)
+        throw new Error(`${what}: erwartet 32 Byte (base64), erhalten ${raw.length}`);
+    return raw;
+}
+export function generateLicenseKeyPair() {
+    const { privateKey, publicKey } = crypto.generateKeyPairSync("ed25519");
+    return {
+        seed: privateKey.export({ format: "der", type: "pkcs8" }).subarray(-32).toString("base64"),
+        publicKey: publicKey.export({ format: "der", type: "spki" }).subarray(-32).toString("base64"),
+    };
+}
+export function signEd25519(domain, payload, seedB64) {
+    const key = crypto.createPrivateKey({
+        key: Buffer.concat([PKCS8_PREFIX, rawKey(seedB64, "LICENSE_SIGNING_SEED")]),
+        format: "der",
+        type: "pkcs8",
+    });
+    return crypto.sign(null, Buffer.from(`${domain}.${payload}`), key).toString("base64url");
+}
+function isCiEnvironment(env) {
+    const on = (v) => v !== undefined && v !== "" && !/^(0|false|no)$/i.test(v);
+    return on(env.CI) || on(env.GITHUB_ACTIONS);
+}
+let warnedKeyOverride = false;
+export function defaultPublicKey(env = process.env) {
+    const override = env.AGENT_AUDIT_LICENSE_PUBLIC_KEY;
+    if (!override)
+        return LICENSE_PUBLIC_KEY;
+    if (isCiEnvironment(env) && env.AGENT_AUDIT_ALLOW_TEST_KEY !== "1") {
+        if (!warnedKeyOverride) {
+            warnedKeyOverride = true;
+            console.warn("⚠ Lizenz-Schlüssel-Override wird in CI ignoriert (eingebetteter Schlüssel gilt).");
+        }
+        return LICENSE_PUBLIC_KEY;
+    }
+    return override;
+}
+export function verifyEd25519(domain, payload, sigB64url, publicKeyB64 = defaultPublicKey()) {
+    try {
+        const key = crypto.createPublicKey({
+            key: Buffer.concat([SPKI_PREFIX, rawKey(publicKeyB64, "Public Key")]),
+            format: "der",
+            type: "spki",
+        });
+        const sig = Buffer.from(sigB64url, "base64url");
+        return crypto.verify(null, Buffer.from(`${domain}.${payload}`), key, sig);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/license/gate.js

@@ -0,0 +1,91 @@
+// Lizenz-Sperre nach dem Muster von CPCG (Privacy Chaos Gate): Der Lauf selbst
+// (Proxy, Szenarien F1 bis F5, Score, PASS/FAIL, Exit-Code) ist nie davon
+// abhängig. Ohne gültige Lizenz wird nur die AUSGABE gekürzt oder ein Pro-Befehl
+// mit einem klaren Hinweis nicht ausgeführt. Die Prüfung der Lizenz selbst
+// (Ed25519, offline) liegt in verifier.ts.
+import { resolveLicense } from "./verifier.js";
+export const PURCHASE_URL = "https://cuonztech.ch/agent-harness.html#audit";
+// Alte Adresse aus früheren Texten des Verifizierers; die Website leitet weiter.
+const LEGACY_URL = "https://cuonztech.ch/agent-audit";
+// Zuordnung frei/Pro. Dieselbe Tabelle steht in der README (Abschnitt «Lizenz und Umfang»).
+export const PRO_FEATURES = {
+    dossier: {
+        name: "Das Prüf-Dossier (report --dossier)",
+        command: "report --dossier",
+        mode: "gekürzt",
+        free: "Das Dossier enthält nur Kopf, Score und das Urteil je Szenario",
+    },
+    ui: {
+        name: "Die geführte Web-Oberfläche (ui)",
+        command: "ui",
+        mode: "gesperrt",
+        free: "Der Weg über die Kommandozeile (proxy, doctor, report)",
+    },
+    campaign: {
+        name: "Der Kampagnen-Runner (campaign)",
+        command: "campaign",
+        mode: "gesperrt",
+        free: "Der Selbsttest (benchmark) und jeder einzelne Proxy-Lauf",
+    },
+    "schema-audit": {
+        name: "Das Schema-Gutachten (Befunde je Tool und Schema-Vorschläge)",
+        command: "proxy --report-file, report",
+        mode: "gekürzt",
+        free: "Die Zusammenfassung und die Risikostufe je Tool (auch in doctor)",
+    },
+    hardening: {
+        name: "Der Textbaustein- und Prompt-Patch-Generator (Härtungsvorschläge)",
+        command: "proxy --report-file, report, cuonztech__get_score",
+        mode: "gekürzt",
+        free: "Der Score, das Urteil und die Beobachtungen",
+    },
+};
+export const FREE_SCOPE_DE = "MCP-Chaos-Proxy mit den Szenarien F1 bis F5, doctor, Kompaktbericht, JSON-Report (--report-file), Resilience Score und PASS/FAIL samt Exit-Code";
+/** Löst die Lizenz auf (--license, sonst Umgebungsvariablen). Ohne gültige Lizenz ist `pro` false. */
+export function resolveProGate(licenseKey) {
+    const verdict = resolveLicense(licenseKey);
+    return { pro: verdict.valid === true, verdict };
+}
+/** Der Grund in einem Satz, ohne Kauf-Link (der steht immer am Ende des Hinweises). */
+export function reasonSentence(verdict) {
+    if (verdict.valid)
+        return "Die Lizenz ist gültig.";
+    const raw = (verdict.reason ?? "").trim();
+    const none = raw === "" || raw === "Nicht lizenziert" || raw.startsWith("Kein Lizenzschlüssel");
+    if (none)
+        return "Es ist keine Lizenz hinterlegt.";
+    const core = raw
+        .replace(LEGACY_URL, "")
+        .replace(/\s*(Lizenzen erhältlich unter|Verlängerung unter)\s*$/i, "")
+        .trim()
+        .replace(/\.$/, "");
+    return `Ihre Lizenz ist nicht gültig: ${core}.`;
+}
+/**
+ * Hinweis für einen Befehl, der ohne Lizenz nicht läuft (`ui`, `campaign`).
+ * Form: «Keine gültige Lizenz: <Funktion> gehört zum Pro-Umfang. Frei bleiben …. Lizenz: <URL>»
+ */
+export function lockedNotice(feature, verdict) {
+    const f = PRO_FEATURES[feature];
+    return (`Keine gültige Lizenz: ${f.name} gehört zum Pro-Umfang. ${reasonSentence(verdict)}\n` +
+        `Frei bleiben: ${FREE_SCOPE_DE}.\n` +
+        `Der Befehl wurde nicht ausgeführt. Lizenz: ${PURCHASE_URL}\n` +
+        `Aktivierung: --license <KEY> oder Umgebungsvariable AGENT_AUDIT_LICENSE.\n`);
+}
+/**
+ * Hinweis für eine gekürzte Ausgabe (Dossier, Schema-Gutachten, Härtungsvorschläge).
+ * Der Lauf selbst, das Urteil und der Exit-Code sind davon unberührt.
+ */
+export function shortenedNotice(feature, verdict) {
+    const f = PRO_FEATURES[feature];
+    return (`Keine gültige Lizenz: ${f.name} gehört zum Pro-Umfang. ${reasonSentence(verdict)} ` +
+        `Die Ausgabe ist gekürzt; der Lauf, das Urteil und der Exit-Code sind echt. ` +
+        `Frei bleiben: ${FREE_SCOPE_DE}. Lizenz: ${PURCHASE_URL}`);
+}
+/** Schlankere Fassung des Schema-Gutachtens ohne Lizenz: Zusammenfassung und Risikostufe, keine Befunde, kein Schema-Vorschlag. */
+export function reduceSchemaAudit(audit) {
+    return {
+        ...audit,
+        tools: audit.tools.map((t) => ({ ...t, findingsDe: [], recommendedSchemaPatch: null })),
+    };
+}

package/dist/license/index.js

@@ -0,0 +1,5 @@
+export * from "./publicKey.js";
+export * from "./ed25519.js";
+export * from "./types.js";
+export * from "./verifier.js";
+export * from "./gate.js";

package/dist/license/publicKey.js

@@ -0,0 +1,5 @@
+/**
+ * Öffentlicher Ed25519-Schlüssel des Cuonztech-Lizenzdienstes (32 Byte, base64).
+ * Der zugehörige private Seed liegt ausschliesslich serverseitig (config.php) und im KeePass.
+ */
+export const LICENSE_PUBLIC_KEY = "OddVMIYDwPSNJSwZiglu4dNLswB+PhWwZi1WZ/XXklE=";

package/dist/license/types.js

@@ -0,0 +1 @@
+export {};