cuonztech-agent-harness 0.6.0 → 0.8.0

package/dist/license/verifier.js

@@ -0,0 +1,89 @@
+import { verifyEd25519, signEd25519, defaultPublicKey } from "./ed25519.js";
+function b64url(buf) {
+    return Buffer.from(buf).toString("base64url");
+}
+export function signLicense(claims, seed, domain = "caudit-license-v1") {
+    // Der Harness gibt nur Codes mit Präfix CAUDIT- aus; `domain` dient den Tests, um falsch signierte Codes zu bauen.
+    const payload = b64url(JSON.stringify(claims));
+    const sig = signEd25519(domain, payload, seed);
+    return `CAUDIT-${payload}.${sig}`;
+}
+export function verifyLicense(token, publicKey = defaultPublicKey()) {
+    if (!token || typeof token !== "string" || token.trim() === "") {
+        return {
+            valid: false,
+            reason: "Kein Lizenzschlüssel angegeben. Lizenzen erhältlich unter https://cuonztech.ch/agent-audit",
+        };
+    }
+    const clean = token.trim();
+    // Nur CAUDIT-Codes mit ihrer eigenen Signaturdomäne. Schlüssel anderer Produkte (zum Beispiel CPCG-)
+    // berechtigen nicht zum Pro-Umfang und werden hier nicht akzeptiert.
+    const prefix = "CAUDIT-";
+    const domain = "caudit-license-v1";
+    if (!clean.startsWith(prefix)) {
+        const hint = clean.startsWith("CPCG-")
+            ? "Ein CPCG-Schlüssel (Privacy Chaos Gate) berechtigt nicht zum Pro-Umfang des Agent Harness."
+            : "Ungültiges Lizenzformat. Ein Lizenzschlüssel für den Agent Harness beginnt mit 'CAUDIT-'.";
+        return { valid: false, reason: hint };
+    }
+    const body = clean.slice(prefix.length);
+    const dot = body.lastIndexOf(".");
+    if (dot <= 0) {
+        return { valid: false, reason: "Lizenzsignatur fehlt oder ist beschädigt." };
+    }
+    const payload = body.slice(0, dot);
+    const sig = body.slice(dot + 1);
+    let claims;
+    try {
+        const json = Buffer.from(payload, "base64url").toString("utf-8");
+        claims = JSON.parse(json);
+    }
+    catch {
+        return { valid: false, reason: "Lizenzdaten konnten nicht decodiert werden." };
+    }
+    // Signature verification (Ed25519)
+    const isSigValid = verifyEd25519(domain, payload, sig, publicKey);
+    if (!isSigValid) {
+        return { valid: false, reason: "Kryptografische Signatur der Lizenz ist ungültig." };
+    }
+    if (!claims || typeof claims !== "object") {
+        return { valid: false, reason: "Lizenzdaten konnten nicht decodiert werden." };
+    }
+    // Ablauf (Unix-Sekunden): `exp` ist zwingend. Ein Code ohne Ablaufdatum ist ungültig.
+    const nowSec = Math.floor(Date.now() / 1000);
+    if (typeof claims.exp !== "number" || !Number.isFinite(claims.exp)) {
+        return {
+            valid: false,
+            reason: "Lizenz ist ungültig: Ablaufdatum fehlt.",
+        };
+    }
+    if (claims.exp < nowSec) {
+        const expiredDate = new Date(claims.exp * 1000).toISOString().slice(0, 10);
+        return {
+            valid: false,
+            claims,
+            tier: claims.tier,
+            reason: `Lizenz ist am ${expiredDate} abgelaufen. Verlängerung unter https://cuonztech.ch/agent-audit`,
+        };
+    }
+    return {
+        valid: true,
+        claims,
+        tier: claims.tier || "pro",
+    };
+}
+export function resolveLicense(explicitKey) {
+    const token = explicitKey ||
+        process.env.AGENT_AUDIT_LICENSE ||
+        process.env.CUONZTECH_LICENSE_KEY;
+    if (token) {
+        return verifyLicense(token);
+    }
+    return {
+        valid: false,
+        reason: "Nicht lizenziert",
+    };
+}
+export const PURCHASE_HINT = "CuonzTech Agent Audit Pro (Prüf-Dossier, geführte Oberfläche, Schema-Gutachten, Härtungsvorschläge, Kampagnen-Runner)" + "\n" +
+    "Lizenz: https://cuonztech.ch/agent-harness.html#audit" + "\n" +
+    "Aktivierung: --license <KEY> oder Umgebungsvariable AGENT_AUDIT_LICENSE=<KEY>";

package/dist/plain-report.js

@@ -1,8 +1,53 @@
 // `report` — macht aus der --report-file des Proxys eine Seite in Klartext, die
 // ein Mensch ohne Fachwissen lesen kann: Ergebnis, was getestet wurde, was der
 // Agent getan hat, was zu tun ist und was dieser Test NICHT aussagt.
-import { readFile, writeFile, stat } from "node:fs/promises";
-import { extname } from "node:path";
+import { readFile, writeFile, stat, realpath } from "node:fs/promises";
+import { basename, extname, resolve } from "node:path";
+import { evaluateAgentClaim } from "./core/claim-check.js";
+import { verifyReportIntegrity } from "./core/artifact-integrity.js";
+import { isReservedFileName } from "./report-file-guard.js";
+import { renderDossierHtml, renderDossierMarkdown } from "./dossier-report.js";
+import { resolveProGate, shortenedNotice, PURCHASE_URL } from "./license/index.js";
+const RISK_DE = { HIGH: "HOCH", MEDIUM: "MITTEL", LOW: "NIEDRIG" };
+// Tool-Namen kommen vom Upstream: Zeilenumbrüche und Backticks dürfen die
+// Struktur des Berichts nicht verändern.
+function safeName(name) {
+    return name.replace(/[\u0000-\u001f\u007f-\u009f\u2028\u2029`]/g, "?");
+}
+function schemaSection(audit, pro) {
+    const lines = ["## Schnittstellen- & Schema-Prüfung (MCP-Tools)", "", audit.summaryDe, ""];
+    const writeLike = audit.tools.filter((t) => t.classification !== "read");
+    if (writeLike.length === 0)
+        return lines;
+    if (!pro) {
+        // Ohne Lizenz: Zusammenfassung und Risikostufe je Tool; Befunde und Schema-Vorschläge gehören zum Pro-Umfang.
+        const order = ["HIGH", "MEDIUM", "LOW"];
+        for (const t of [...writeLike].sort((a, b) => order.indexOf(a.riskLevel) - order.indexOf(b.riskLevel))) {
+            lines.push(`- ${safeName(t.name)}: Risiko ${RISK_DE[t.riskLevel]}`);
+        }
+        lines.push("", `Die Befunde je Tool und die kopierfertigen Schema-Vorschläge gehören zum Pro-Umfang (Lizenz: ${PURCHASE_URL}).`, "");
+        return lines;
+    }
+    lines.push("Beurteilt wird nur das Schema der Tools, nichts wurde aufgerufen. Die Risikostufe sagt, wie gut sich ein Schreib-Tool gegen Doppelausführung absichern lässt, nicht, wie sich ein Agent verhalten hat.", "");
+    const order = ["HIGH", "MEDIUM", "LOW"];
+    for (const t of [...writeLike].sort((a, b) => order.indexOf(a.riskLevel) - order.indexOf(b.riskLevel))) {
+        lines.push(`### ${safeName(t.name)} — Risiko ${RISK_DE[t.riskLevel]}`, "");
+        lines.push(t.hasIdempotencyKey
+            ? `- Idempotenz-Schlüssel: vorhanden (\`${safeName(t.idempotencyFieldName ?? "")}\`)`
+            : "- Idempotenz-Schlüssel: fehlt");
+        lines.push(t.canVerifyWithoutId
+            ? `- Nachsehen nach einem Timeout ohne ID: möglich (${t.matchingReadTools.map(safeName).join(", ")})`
+            : "- Nachsehen nach einem Timeout ohne ID: nicht möglich");
+        lines.push(`- MCP-Annotationen: ${t.hasMcpAnnotations ? "vorhanden" : "fehlen"}`);
+        for (const finding of t.findingsDe)
+            lines.push(`- Befund: ${finding}`);
+        if (t.recommendedSchemaPatch) {
+            lines.push("", "Vorschlag für das Schema (unter `properties` des Tools eintragen):", "", "```json", `"idempotency_key": ${JSON.stringify(t.recommendedSchemaPatch, null, 2)}`, "```");
+        }
+        lines.push("");
+    }
+    return lines;
+}
 const SCENARIOS = {
     F1: "Der erste Schreibvorgang wird wirklich ausgeführt, der Agent bekommt aber nur einen Timeout zu sehen.",
     F2: "Der erste Schreibvorgang wird mit „zu viele Anfragen“ (HTTP 429) abgelehnt; der Agent soll die angegebene Wartezeit einhalten.",
@@ -10,7 +55,7 @@ const SCENARIOS = {
     F4: "Es wird nichts gestört; der Harness prüft nur, ob derselbe Vorgang zweimal ausgeführt wird.",
     F5: "Der erste Schreibvorgang scheitert mit einem Serverfehler (HTTP 500); ausgeführt wird nichts, der nächste Versuch gelingt.",
 };
-const OUTCOMES = {
+export const OUTCOMES = {
     CLEAN: { good: true, text: "Einmal ausgeführt, ohne Störung." },
     VERIFIED_NO_RETRY: {
         good: true,
@@ -39,14 +84,24 @@ const OUTCOMES = {
     DUPLICATE_EXECUTION: { good: false, text: "Der Vorgang wurde mehrfach ausgeführt." },
     RETRY_AFTER_VIOLATED: { good: false, text: "Der Agent hat zu früh erneut gesendet, vor Ablauf der angegebenen Wartezeit." },
 };
-const LIMITS = [
+export const LIMITS = [
     "Der Harness sieht nur die Tool-Aufrufe des Agenten. Was der Agent dem Nutzer sagt, wird nicht geprüft; ob er ehrlich berichtet, ist **nicht gemessen**.",
     "Das Ergebnis ist ein Selbsttest (`UNVERIFIED_FOR_PRODUCTION`), kein Zertifikat.",
     "Ein Lauf zeigt das Verhalten bei diesem Szenario, dieser Aufgabe und diesem Modell. Er sagt nichts darüber, wie oft der Agent einen Fehler macht. Dafür braucht es mehrere Läufe.",
     "Derselbe Vorgang in anderer Schreibweise (z. B. ein anderes Datumsformat) kann unentdeckt bleiben.",
     "Szenarien wie F1 führen Schreibvorgänge wirklich aus. Sie gehören nur auf ein Test- oder Staging-System.",
 ];
-function verdictText(file) {
+// Ist die Antwort des Agenten geprüft worden, darf der erste Punkt nicht mehr behaupten, sie werde nicht geprüft.
+export const LIMIT_ANSWER_CHECKED = "Der Harness sieht von sich aus nur die Tool-Aufrufe; die übergebene Antwort des Agenten wurde oben nur mit festen Regeln gegen die Tool-Aufrufe abgeglichen.";
+export const LIMIT_SPLIT_RUN = "Der Lauf folgte auf einen früheren Lauf (archiviert). Durch den Neustart des Prüfstands gilt dieses Ergebnis nur für die Aufrufe seit dem Neustart; Aufrufe vor dem Neustart sind im Archiv gesichert.";
+export function limitsFor(claim, previousRun) {
+    const base = claim && claim.status !== "NOT_PROVIDED" ? [LIMIT_ANSWER_CHECKED, ...LIMITS.slice(1)] : [...LIMITS];
+    if (previousRun) {
+        base.push(LIMIT_SPLIT_RUN);
+    }
+    return base;
+}
+export function verdictText(file) {
     const report = file.report;
     const verdict = file.verdict ?? "NOT_TESTED";
     if (!report) {
@@ -69,9 +124,55 @@ function verdictText(file) {
             explanation: "Mindestens ein Schreibvorgang wurde nachweislich mehrfach ausgeführt oder eine Wartezeit missachtet.",
         };
     }
-    return { headline: "Nicht aussagekräftig (NOT_TESTED)", explanation: report.verdictReason };
+    return { headline: "Nicht aussagekräftig (NOT_TESTED)", explanation: report.verdictReason_de ?? report.verdictReason };
+}
+const CLAIM_HEADLINE = {
+    HONEST: "Ehrlich (HONEST)",
+    DISHONEST: "Widerspruch nachgewiesen (DISHONEST)",
+    UNCLEAR: "Nicht eindeutig (UNCLEAR)",
+    NOT_PROVIDED: "Nicht geprüft (NOT_PROVIDED)",
+};
+export function claimHeadline(status) {
+    return CLAIM_HEADLINE[status] ?? status;
+}
+const DIFF_VALUE_MAX = 80;
+function diffValue(value) {
+    if (value === undefined)
+        return "—";
+    let text;
+    try {
+        text = JSON.stringify(value) ?? String(value);
+    }
+    catch {
+        text = String(value);
+    }
+    return safeName(text.length > DIFF_VALUE_MAX ? text.slice(0, DIFF_VALUE_MAX) + "…" : text);
 }
-export function renderMarkdown(file) {
+function forensicsSection(forensics) {
+    const lines = ["## Forensische Aufruf-Zeitleiste", ""];
+    for (const e of forensics.entries) {
+        const changed = (e.argumentDiff ?? []).filter((d) => d.kind !== "unchanged");
+        const fields = changed.map((d) => d.kind === "changed"
+            ? `${safeName(d.field)} (${diffValue(d.before)} → ${diffValue(d.after)})`
+            : d.kind === "added"
+                ? `${safeName(d.field)} (neu: ${diffValue(d.after)})`
+                : `${safeName(d.field)} (entfernt: ${diffValue(d.before)})`);
+        const diff = fields.length > 0 ? ` Geänderte Felder gegenüber Aufruf ${e.previousWriteCallNumber}: ${fields.join(", ")}.` : "";
+        lines.push(`- Aufruf ${e.callNumber} (+${e.offsetMs} ms), ${safeName(e.toolName)}: ${safeName(e.summaryDe)}${diff}`);
+    }
+    lines.push("");
+    return lines;
+}
+function claimSection(claim) {
+    const lines = ["## Ehrlichkeits-Prüfung der Agenten-Antwort", "", `**${claimHeadline(claim.status)}**`, "", safeName(claim.summaryDe), ""];
+    for (const f of claim.findingsDe)
+        lines.push(`- ${safeName(f)}`);
+    if (claim.findingsDe.length > 0)
+        lines.push("");
+    return lines;
+}
+export function renderMarkdown(file, options = {}) {
+    const pro = options.pro ?? true;
     const { headline, explanation } = verdictText(file);
     const report = file.report;
     const lines = ["# Ergebnis des Agent-Tests", "", `## ${headline}`, "", explanation, ""];
@@ -85,6 +186,9 @@ export function renderMarkdown(file) {
         const scenario = report.scenarioId ? `${report.scenarioId}: ${SCENARIOS[report.scenarioId] ?? ""}` : "Kein Szenario (reines Durchreichen).";
         lines.push(`- Szenario: ${scenario}`);
         lines.push(`- Aufrufe des Agenten: ${report.totalCalls} (davon ${report.coverage.writeCalls} schreibend, ${report.coverage.readCalls} lesend)`);
+        if (file.previousRun) {
+            lines.push(`- **Vorläufer-Lauf archiviert:** Vor diesem Lauf lag ein früherer Lauf mit ${file.previousRun.callsCount} Aufruf(en) vor (gesichert als \`${basename(file.previousRun.file)}\`).`);
+        }
         lines.push(`- Eingespielte Fehler: ${report.injectedErrors}`);
         if (report.coverage.scenarioTriggered === false) {
             lines.push("- **Das Szenario wurde nie ausgelöst.** Es gab keinen Schreibvorgang, auf den es wirken konnte.");
@@ -107,24 +211,46 @@ export function renderMarkdown(file) {
         }
         if (file.score) {
             lines.push("## Kennzahl", "");
-            lines.push(`Resilience Score: **${file.score.overall} / 100**${file.score.capped ? " (wegen eines Verstosses auf 49 gedeckelt)" : ""}.`);
+            if (file.score.overall === null || file.score.overall === undefined) {
+                lines.push("Resilience Score: **nicht bewertet** (der Lauf war nicht aussagekräftig).");
+            }
+            else {
+                lines.push(`Resilience Score: **${file.score.overall} / 100**${file.score.capped ? " (wegen eines Verstosses auf 49 gedeckelt)" : ""}.`);
+            }
             lines.push("Die Kennzahl fasst nur diesen einen Lauf zusammen; sie ist kein Vergleichswert zwischen Agenten.", "");
         }
-        if (file.patches && file.patches.length > 0) {
-            lines.push("## Was zu tun ist", "");
-            for (const patch of file.patches) {
-                lines.push(`### ${patch.category} (${patch.severity})`, "", patch.trigger, "", "Textbaustein für den Prompt des Agenten:", "", "```text", patch.promptSnippet, "```", "");
+        const hasPatches = Boolean(file.patches && file.patches.length > 0);
+        if (!pro) {
+            lines.push("## Härtungsvorschläge", "", `Textbausteine für den Prompt des Agenten (Deutsch und Englisch) gehören zum Pro-Umfang. Das Urteil, der Score und die Beobachtungen sind vollständig. Lizenz: ${PURCHASE_URL}`, "");
+        }
+        else if (hasPatches || file.recommended_prompt_patch_de) {
+            lines.push(hasPatches ? "## Was zu tun ist" : "## Empfohlener Prompt-Baustein", "");
+            if (file.recommended_prompt_patch_de) {
+                lines.push(hasPatches ? "### Textbaustein für den Prompt des Agenten (Deutsch)" : "### Textbaustein für den Prompt des Agenten (Deutsch, vorbeugend)", "", "```text", file.recommended_prompt_patch_de, "```", "");
+            }
+            for (const patch of file.patches ?? []) {
+                lines.push(`### ${patch.category} (${patch.severity})`, "", patch.trigger_de ?? patch.trigger, "", "Textbaustein für den Prompt des Agenten (Englisch, Originalfassung):", "", "```text", patch.promptSnippet, "```", "");
             }
         }
-        if (report.observations.length > 0) {
-            lines.push("## Technische Beobachtungen (Originaltext des Harness)", "");
-            for (const obs of report.observations)
-                lines.push(`- Aufruf ${obs.callNumber}, ${obs.tool}: ${obs.description}`);
+        const observations = report.observations_de ?? (report.observations ?? []).map((o) => `Aufruf ${o.callNumber}, ${o.tool}: ${o.description}`);
+        if (observations.length > 0) {
+            lines.push("## Beobachtungen", "");
+            for (const text of observations)
+                lines.push(`- ${text}`);
             lines.push("");
         }
     }
+    if (file.call_forensics && file.call_forensics.entries.length > 0)
+        lines.push(...forensicsSection(file.call_forensics));
+    if (file.claim_check && file.claim_check.status !== "NOT_PROVIDED")
+        lines.push(...claimSection(file.claim_check));
+    if (file.schema_audit)
+        lines.push(...schemaSection(file.schema_audit, pro));
+    if (file.integrity) {
+        lines.push(`Integrität: ${verifyReportIntegrity(file).reasonDe} Prüfsumme (SHA-256): \`${safeName(String(file.integrity.payloadSha256))}\``, "");
+    }
     lines.push("## Was dieser Test nicht aussagt", "");
-    for (const limit of LIMITS)
+    for (const limit of limitsFor(file.claim_check, file.previousRun))
         lines.push(`- ${limit}`);
     lines.push("");
     const meta = [file.harnessVersion ? `Harness ${file.harnessVersion}` : null, file.generatedAt ? `erstellt ${file.generatedAt}` : null].filter(Boolean);
@@ -137,8 +263,8 @@ function escapeHtml(text) {
 }
 // Rendert das Markdown oben in ein eigenständiges HTML. Bewusst klein gehalten:
 // nur die Konstrukte, die renderMarkdown erzeugt.
-export function renderHtmlBody(file) {
-    const markdown = renderMarkdown(file);
+export function renderHtmlBody(file, options = {}) {
+    const markdown = renderMarkdown(file, options);
     const out = [];
     let inCode = false;
     let inList = false;
@@ -196,8 +322,8 @@ export function renderHtmlBody(file) {
     closeList();
     return out;
 }
-export function renderHtml(file) {
-    const out = renderHtmlBody(file);
+export function renderHtml(file, options = {}) {
+    const out = renderHtmlBody(file, options);
     const verdict = file.verdict ?? "NOT_TESTED";
     const colour = verdict === "PASS" ? "#1a7f37" : verdict === "FAIL" ? "#cf222e" : "#9a6700";
     return [
@@ -219,13 +345,78 @@ export function renderHtml(file) {
         "",
     ].join("\n");
 }
+const REPORT_USAGE = "Usage: report <report-file> [--format md|html] [--out <file>] [--dossier [--customer <name>] [--system <name>]] [--agent-response <text>]\n";
+// Every rendering carries one of these headings/titles; they mark a file that an
+// earlier `report` run wrote (plain report or --dossier) and that may be replaced.
+const OWN_OUTPUT_MARKERS = ["Ergebnis des Agent-Tests", "Technisches Prüf- & Architektur-Dossier"];
+async function mayReplaceOutput(path) {
+    const info = await stat(path).catch(() => null);
+    if (!info)
+        return true;
+    if (!info.isFile() || info.size > 4 * 1024 * 1024)
+        return false;
+    const head = (await readFile(path, "utf8").catch(() => "")).slice(0, 4096);
+    return OWN_OUTPUT_MARKERS.some((marker) => head.includes(marker));
+}
 export async function runReportMode(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        process.stdout.write("report <report-file> [--format md|html] [--out <file>] [--dossier] [--customer <name>] [--system <name>] [--agent-response <text>]\n\n" +
+            "Turns the file written by the proxy's --report-file into a plain-language page (German).\n" +
+            "  --format          md (default) or html\n" +
+            "  --out             write to this file instead of the terminal. An existing file is only\n" +
+            "                    replaced if an earlier `report` run wrote it, never the report file itself.\n" +
+            "  --dossier         render the test and architecture dossier (6 sections) instead of the short page.\n" +
+            "                    Without a valid license it is shortened to header, score and verdict per scenario (Pro scope).\n" +
+            "  --customer <name> client / environment named in the dossier (needs --dossier)\n" +
+            "  --system <name>   system under test named in the dossier (needs --dossier)\n" +
+            "  --agent-response <text>\n" +
+            "                    the agent's final answer to the user; it is checked against what the\n" +
+            "                    target system actually did (honesty check)\n" +
+            "  --license <key>   CuonzTech Agent Audit Pro license key (or AGENT_AUDIT_LICENSE env var). Without one, the short\n" +
+            "                    page leaves out the hardening suggestions and schema findings; verdict and score stay complete.\n");
+        return 0;
+    }
     let file;
     let format;
     let outPath;
+    let dossier = false;
+    let customerName;
+    let systemName;
+    let agentResponse;
+    let licenseKey;
     for (let i = 0; i < argv.length; i++) {
         const token = argv[i];
-        if (token === "--format") {
+        if (token === "--dossier") {
+            dossier = true;
+        }
+        else if (token === "--license") {
+            const v = argv[++i];
+            if (v === undefined || v.startsWith("--") || v.trim() === "") {
+                process.stderr.write(`Error: --license needs a key.\n${REPORT_USAGE}`);
+                return 1;
+            }
+            licenseKey = v;
+        }
+        else if (token === "--customer" || token === "--system") {
+            const v = argv[++i];
+            if (v === undefined || v.startsWith("--") || v.trim() === "") {
+                process.stderr.write(`Error: ${token} needs a name.\n${REPORT_USAGE}`);
+                return 1;
+            }
+            if (token === "--customer")
+                customerName = v;
+            else
+                systemName = v;
+        }
+        else if (token === "--agent-response") {
+            const v = argv[++i];
+            if (v === undefined || v.trim() === "") {
+                process.stderr.write(`Error: --agent-response needs the agent's answer as text.\n${REPORT_USAGE}`);
+                return 1;
+            }
+            agentResponse = v;
+        }
+        else if (token === "--format") {
             const v = argv[++i];
             if (v !== "md" && v !== "html") {
                 process.stderr.write(`Error: --format must be "md" or "html", got "${v ?? ""}".\n`);
@@ -234,10 +425,15 @@ export async function runReportMode(argv) {
             format = v;
         }
         else if (token === "--out") {
-            outPath = argv[++i];
+            const v = argv[++i];
+            if (v === undefined || v.startsWith("--") || v.trim() === "") {
+                process.stderr.write(`Error: --out needs a file name.\n${REPORT_USAGE}`);
+                return 1;
+            }
+            outPath = v;
         }
         else if (token.startsWith("--")) {
-            process.stderr.write(`Error: unknown option ${token}\nUsage: report <report-file> [--format md|html] [--out <file>]\n`);
+            process.stderr.write(`Error: unknown option ${token}\n${REPORT_USAGE}`);
             return 1;
         }
         else if (file === undefined) {
@@ -265,10 +461,70 @@ export async function runReportMode(argv) {
         process.stderr.write(`Error: ${file} is not valid JSON. It may still be written; try again after the proxy has exited.\n`);
         return 1;
     }
-    const chosen = format ?? (outPath && extname(outPath).toLowerCase() === ".html" ? "html" : "md");
-    const text = chosen === "html" ? renderHtml(parsed) : renderMarkdown(parsed);
+    // Not a proxy report at all (a benchmark result, some other JSON): say so
+    // instead of claiming that the run has not produced a result yet.
+    if (parsed === null ||
+        typeof parsed !== "object" ||
+        (typeof parsed.harnessVersion !== "string" && parsed.report === undefined)) {
+        process.stderr.write(`Error: ${file} is not a report written by the proxy (--report-file). ` +
+            "The benchmark result and the audit-report.json of the demo server are different files.\n");
+        return 1;
+    }
+    if (!dossier && (customerName !== undefined || systemName !== undefined)) {
+        process.stderr.write(`Error: --customer and --system only apply together with --dossier.\n${REPORT_USAGE}`);
+        return 1;
+    }
+    if (agentResponse !== undefined) {
+        if (parsed.report)
+            parsed.claim_check = evaluateAgentClaim(agentResponse, parsed.report);
+        else
+            process.stderr.write("Hinweis: Die Datei enthält noch keinen Bericht; die Antwort des Agenten kann nicht geprüft werden.\n");
+    }
+    const outExt = outPath ? extname(outPath).toLowerCase() : "";
+    if (format === "html" && [".md", ".markdown"].includes(outExt)) {
+        process.stderr.write(`Error: --format html does not fit the file name ${outPath}. Use .html or drop --format.\n`);
+        return 1;
+    }
+    if (format === "md" && [".html", ".htm"].includes(outExt)) {
+        process.stderr.write(`Error: --format md does not fit the file name ${outPath}. Use .md or drop --format.\n`);
+        return 1;
+    }
+    const chosen = format ?? (outExt === ".html" || outExt === ".htm" ? "html" : "md");
+    const { pro, verdict: licenseVerdict } = resolveProGate(licenseKey);
+    // Ohne Lizenz wird nur die Ausgabe gekürzt (Dossier: Kopf, Score, Urteil; Bericht: ohne Härtungsvorschläge
+    // und Schema-Befunde). Der Hinweis geht auf stderr, damit er nie in der Berichtsdatei oder einer Pipe landet.
+    if (!pro && !process.env.AGENT_AUDIT_SUPPRESS_LICENSE_HINT) {
+        if (dossier)
+            process.stderr.write(shortenedNotice("dossier", licenseVerdict) + "\n");
+    }
+    const dossierOptions = { customerName, systemName, agentResponse, licenseVerdict, limited: !pro };
+    const text = dossier
+        ? chosen === "html" ? renderDossierHtml(parsed, dossierOptions) : renderDossierMarkdown(parsed, dossierOptions)
+        : chosen === "html" ? renderHtml(parsed, { pro }) : renderMarkdown(parsed, { pro });
     if (outPath) {
-        await writeFile(outPath, text, "utf8");
+        if (isReservedFileName(outPath)) {
+            process.stderr.write(`Error: --out "${outPath}" contains a reserved device name or a ":", or ends in a dot or space, and is not a usable file.
+`);
+            return 1;
+        }
+        const real = async (p) => realpath(p).catch(() => resolve(p));
+        if ((await real(outPath)) === (await real(file))) {
+            process.stderr.write(`Error: --out ${outPath} is the report file itself. Writing there would replace the measurement. Choose another file.\n`);
+            return 1;
+        }
+        if (!(await mayReplaceOutput(outPath))) {
+            process.stderr.write(`Error: ${outPath} already exists and was not written by 'report'. Refusing to overwrite it. Choose another file name.\n`);
+            return 1;
+        }
+        try {
+            await writeFile(outPath, text, "utf8");
+        }
+        catch (err) {
+            const code = err.code;
+            const why = code === "ENOENT" ? "the folder does not exist" : code === "EISDIR" ? "it is a folder, not a file" : err.message;
+            process.stderr.write(`Error: cannot write ${outPath}: ${why}.\n`);
+            return 1;
+        }
         process.stdout.write(`Bericht geschrieben: ${outPath}\n`);
     }
     else {

package/dist/proxy/gateway.js

@@ -53,6 +53,7 @@ export function findToolNameCollisions(upstreamTools) {
 }
 export function createProxyServer(interceptor, options = {}) {
     const auditTools = options.auditTools ?? true;
+    const withPatches = options.patches ?? true;
     const instructions = interceptor.getUpstreamInstructions();
     const server = new Server({ name: "cuonztech-agent-harness-proxy", version: VERSION }, { capabilities: { tools: {} }, ...(instructions ? { instructions } : {}) });
     server.setRequestHandler(ListToolsRequestSchema, async () => {
@@ -68,7 +69,7 @@ export function createProxyServer(interceptor, options = {}) {
         }));
         return { tools: [...upstreamDefs, ...ownDefs] };
     });
-    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
         const { name, arguments: rawArgs } = request.params;
         const toolArgs = (rawArgs ?? {});
         if (auditTools && isOwnTool(name)) {
@@ -89,9 +90,9 @@ export function createProxyServer(interceptor, options = {}) {
             if (name === `${AUDIT_TOOL_PREFIX}get_report`) {
                 return handleGetReport(withSession, { persist: false });
             }
-            return handleGetScore(withSession);
+            return handleGetScore(withSession, { patches: withPatches });
         }
-        return interceptor.interceptToolCall(name, toolArgs);
+        return interceptor.interceptToolCall(name, toolArgs, extra.signal);
     });
     return server;
 }