cuonztech-agent-harness 0.7.0 → 0.8.0

package/dist/index.js

@@ -12,10 +12,11 @@ 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 { isReplaceableReportFile, isReservedFileName, notReplaceableMessage } from "./report-file-guard.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";
@@ -35,13 +36,13 @@ 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>]\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` +
@@ -91,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` +
@@ -183,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.
@@ -219,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 });
@@ -231,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");
@@ -344,6 +379,7 @@ const PROXY_FLAGS = {
     "--audit-tools": "single",
     "--report-file": "single",
     "--allow-writes": "boolean",
+    "--license": "single",
 };
 function parseEnvPair(pair, flag, into) {
     const eq = pair.indexOf("=");
@@ -367,6 +403,8 @@ async function runProxyMode(argv) {
         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" +
@@ -485,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, "?");
@@ -507,6 +556,13 @@ async function runProxyMode(argv) {
             "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 " +
@@ -652,8 +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.
@@ -662,15 +720,35 @@ 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).
-                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: schemaAudit,
+                ...(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: schemaAudit,
+                    schema_audit: reportedSchemaAudit,
                     call_forensics: callForensics,
                 }),
                 toolClassification: classification,
@@ -771,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.

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 {};

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

@@ -2,22 +2,32 @@
 // 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, realpath } from "node:fs/promises";
-import { extname, resolve } from "node:path";
+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) {
+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))) {
@@ -83,8 +93,13 @@ export const LIMITS = [
 ];
 // 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 function limitsFor(claim) {
-    return claim && claim.status !== "NOT_PROVIDED" ? [LIMIT_ANSWER_CHECKED, ...LIMITS.slice(1)] : [...LIMITS];
+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;
@@ -156,7 +171,8 @@ function claimSection(claim) {
         lines.push("");
     return lines;
 }
-export function renderMarkdown(file) {
+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, ""];
@@ -170,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.");
@@ -201,7 +220,10 @@ export function renderMarkdown(file) {
             lines.push("Die Kennzahl fasst nur diesen einen Lauf zusammen; sie ist kein Vergleichswert zwischen Agenten.", "");
         }
         const hasPatches = Boolean(file.patches && file.patches.length > 0);
-        if (hasPatches || file.recommended_prompt_patch_de) {
+        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, "```", "");
@@ -210,7 +232,7 @@ export function renderMarkdown(file) {
                 lines.push(`### ${patch.category} (${patch.severity})`, "", patch.trigger_de ?? patch.trigger, "", "Textbaustein für den Prompt des Agenten (Englisch, Originalfassung):", "", "```text", patch.promptSnippet, "```", "");
             }
         }
-        const observations = report.observations_de ?? report.observations.map((o) => `Aufruf ${o.callNumber}, ${o.tool}: ${o.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)
@@ -223,12 +245,12 @@ export function renderMarkdown(file) {
     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));
+        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 limitsFor(file.claim_check))
+    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);
@@ -241,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;
@@ -300,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 [
@@ -343,12 +365,15 @@ export async function runReportMode(argv) {
             "  --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 full test and architecture dossier (6 sections) instead of the short page\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");
+            "                    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;
@@ -358,11 +383,20 @@ export async function runReportMode(argv) {
     let customerName;
     let systemName;
     let agentResponse;
+    let licenseKey;
     for (let i = 0; i < argv.length; i++) {
         const token = argv[i];
         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() === "") {
@@ -456,10 +490,17 @@ export async function runReportMode(argv) {
         return 1;
     }
     const chosen = format ?? (outExt === ".html" || outExt === ".htm" ? "html" : "md");
-    const dossierOptions = { customerName, systemName, agentResponse };
+    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) : renderMarkdown(parsed);
+        : chosen === "html" ? renderHtml(parsed, { pro }) : renderMarkdown(parsed, { pro });
     if (outPath) {
         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.