cuonztech-agent-harness 0.7.0 → 0.9.0

package/dist/dossier-report.js

@@ -3,9 +3,11 @@
 // aus demselben Seitenmodell (Abschnitte aus Blöcken), damit beide Fassungen
 // dieselbe Aussage tragen. Alles Dynamische (Tool-Namen, Argumente, Agenten-Text,
 // Kunden- und Systemnamen) wird beim Rendern maskiert, nie vorher.
-import { LIMITS, OUTCOMES, claimHeadline, verdictText } from "./plain-report.js";
+import { LIMITS, OUTCOMES, claimHeadline, effectProbeLinesDe, verdictText } from "./plain-report.js";
+import { basename } from "node:path";
 import { evaluateAgentClaim } from "./core/claim-check.js";
 import { verifyReportIntegrity } from "./core/artifact-integrity.js";
+import { PURCHASE_URL } from "./license/gate.js";
 const TITLE = "CuonzTech Agent-Harness · Technisches Prüf- & Architektur-Dossier";
 const RISK_DE = { HIGH: "HOCH", MEDIUM: "MITTEL", LOW: "NIEDRIG" };
 const RISK_TONE = { HIGH: "fail", MEDIUM: "warn", LOW: "pass" };
@@ -127,7 +129,7 @@ function businessMatrix(file) {
         rows.push({ dimension: d1, label: "FAIL", tone: "fail", basis: `${report.duplicateExecutions} Doppelausführung(en) im Zielsystem nachgewiesen.` });
     }
     else if (report.coverage.writeCalls > 0 && !report.operations.some((op) => op.outcome === "EXECUTION_UNKNOWN")) {
-        rows.push({ dimension: d1, label: "PASS", tone: "pass", basis: `${report.coverage.writeCalls} Schreibaufruf(e) beobachtet, keine Doppelausführung.` });
+        rows.push({ dimension: d1, label: "PASS", tone: "pass", basis: `${report.coverage.writeCalls} Schreibaufruf(e) beobachtet, keine Doppelausführung.${report.effectProbe?.conclusion === "deduplicated" ? " Gezählt wurden Datensätze (Wirkungs-Sonde): Wiederholungen haben keinen zweiten erzeugt." : ""}` });
     }
     else {
         rows.push(notTested(d1, report.coverage.writeCalls === 0 ? "Es wurde kein Schreibvorgang beobachtet." : "Der Ausgang mindestens eines Vorgangs blieb offen; weder bestätigt noch als doppelt nachgewiesen."));
@@ -145,6 +147,10 @@ function businessMatrix(file) {
     else if (affected.some((op) => op.outcome === "UNVERIFIED_AFTER_TIMEOUT" || op.outcome === "EXECUTION_UNKNOWN")) {
         rows.push({ dimension: d2, label: "HINWEIS", tone: "warn", basis: "Der Agent hat nach der Störung nicht nachgesehen, ob der Vorgang schon ausgeführt war (UNVERIFIED_AFTER_TIMEOUT); der Ausgang bleibt offen." });
     }
+    else if (affected.some((op) => op.outcome === "DEDUPLICATED_RETRY")) {
+        const n = affected.filter((op) => op.outcome === "DEDUPLICATED_RETRY").length;
+        rows.push({ dimension: d2, label: "HINWEIS", tone: "warn", basis: `Der Agent hat nach der Störung erneut gesendet (DEDUPLICATED_RETRY, ${n}×); die Wirkungs-Sonde hat keinen zweiten Datensatz gezählt, das Zielsystem hat die Wiederholung selbst erkannt. Nachgesehen hat der Agent damit nicht unbedingt; die Wiederholung blieb ohne Folgen.` });
+    }
     else if (affected.some((op) => op.outcome === "RETRY_AFTER_VIOLATED")) {
         rows.push(notTested(d2, "Der Lauf wird unter der Wartezeit-Disziplin bewertet (siehe nächste Zeile)."));
     }
@@ -214,6 +220,9 @@ function summarySection(file) {
         intro: "Die Matrix beurteilt vier konkrete Risikodimensionen ausschliesslich anhand der Messdaten dieses einen Laufs.",
         blocks: [
             { t: "table", head: ["Risikodimension", "Bewertung", "Grundlage (Messdaten)"], rows: rows.map((r) => [[r.dimension], [badgeOf(r.label, r.tone)], [r.basis]]) },
+            ...(effectProbeLinesDe(file.report).length > 0
+                ? [{ t: "note", title: "Wirkungs-Sonde (--effect-probe)", items: effectProbeLinesDe(file.report).map((l) => inlineMarkup(l)) }]
+                : []),
         ],
     };
 }
@@ -435,15 +444,56 @@ function integritySection(file, options) {
             // Mit geprüfter Antwort würde der erste Standardsatz («nicht gemessen») Sektion 4 widersprechen.
             ...(answered ? LIMITS.slice(1) : LIMITS).map(inlineMarkup),
             [answered ? "Der Harness sieht von sich aus nur die Tool-Aufrufe; die Antwort des Agenten an den Nutzer wurde in Sektion 4 nur soweit geprüft, wie sie übergeben wurde und sich mit festen Regeln aus den Tool-Aufrufen beurteilen lässt." : "Eine Antwort des Agenten an den Nutzer wurde nicht übergeben und deshalb in Sektion 4 nicht geprüft."],
+            ...(file.previousRun ? [inlineMarkup(`Der Lauf folgte auf einen früheren Lauf (archiviert unter \`${basename(file.previousRun.file)}\`). Durch den Neustart des Prüfstands gilt dieses Urteil nur für die Aufrufe nach dem Neustart.`)] : []),
         ],
     });
     return { id: "integrity", title: "6. Kryptografischer Integritäts-Nachweis & Methodische Grenzen", blocks };
 }
+// Gekürzte Fassung ohne gültige Lizenz (wie «Nur Zahlen» bei CPCG): Kopf, Score und das Urteil je Szenario.
+// Der Lauf und sein Urteil sind echt; Details, Aufruf-Protokoll, Härtungspaket und Anhänge gehören zum Pro-Umfang.
+function limitedSection(file) {
+    const verdict = file.verdict ?? file.report?.verdict ?? "NOT_TESTED";
+    const tone = verdict === "PASS" ? "pass" : verdict === "FAIL" ? "fail" : "warn";
+    const score = file.score?.overall;
+    const scenario = file.report?.scenarioId ?? (file.report?.mode ? `Modus ${file.report.mode}` : "—");
+    return {
+        id: "scenario-verdict",
+        title: "Urteil je Szenario",
+        blocks: [
+            {
+                t: "table",
+                head: ["Szenario", "Urteil", "Resilience Score", "Aufrufe", "Schreibvorgänge"],
+                rows: [
+                    [
+                        [clean(scenario)],
+                        [badgeOf(verdict, tone)],
+                        [file.report && typeof score === "number" ? `${score} / 100` : "nicht bewertet"],
+                        [String(file.report?.totalCalls ?? "—")],
+                        [String(file.report?.coverage?.writeCalls ?? "—")],
+                    ],
+                ],
+            },
+            {
+                t: "note",
+                title: "Umfang dieser Fassung",
+                items: [
+                    ["Das Urteil, der Score und die Zahlen stammen aus dem echten Lauf und sind vollständig."],
+                    ["Gekürzt ohne Lizenz: Geschäftsrisiko-Matrix, Schnittstellen-Gutachten, Aufruf-Protokoll mit Parameter-Diff, Abgleich mit der Antwort des Agenten, Härtungspaket und Integritäts-Nachweis."],
+                    [`Das vollständige Prüf-Dossier gehört zum Pro-Umfang. Lizenz: ${PURCHASE_URL}`],
+                ],
+            },
+        ],
+    };
+}
 function build(file, options = {}) {
     const { headline, explanation } = verdictText(file);
     const score = file.score?.overall;
-    const sections = [summarySection(file), schemaSection(file), forensicsSection(file), claimSection(file, options), hardeningSection(file), integritySection(file, options)];
+    const limited = options.limited === true;
+    const sections = limited
+        ? [limitedSection(file)]
+        : [summarySection(file), schemaSection(file), forensicsSection(file), claimSection(file, options), hardeningSection(file), integritySection(file, options)];
     return {
+        limited,
         headline,
         explanation,
         verdictLabel: headline,
@@ -456,6 +506,14 @@ function build(file, options = {}) {
             ["Auftraggeber / Umgebung", clean(options.customerName ?? "Lokale Prüfumgebung")],
             ["Session-ID", clean(file.report?.sessionId ?? "—")],
             ["Szenario / Modus", clean(file.report?.scenarioId ?? file.report?.mode ?? "—")],
+            [
+                "Lizenzstatus",
+                options.licenseVerdict?.valid
+                    ? `PRO (${options.licenseVerdict.claims?.sub ?? options.licenseVerdict.claims?.customer ?? "Aktiviert"})`
+                    : limited
+                        ? `EVALUATION (keine gültige Lizenz, gekürzte Fassung; Lizenz: ${PURCHASE_URL})`
+                        : "EVALUATION (Bibliotheksaufruf ohne Lizenzprüfung, volle Fassung)",
+            ],
         ],
         sections,
     };
@@ -566,7 +624,7 @@ export function renderDossierHtml(file, options) {
         `<title>${escHtml(TITLE)}</title>`,
         `<style>${CSS}</style></head><body><main class="wrap"><header>`,
         `<div class="topline"><strong>${escHtml(TITLE)}</strong><span>${escHtml(d.date)} · ${escHtml(d.version)}</span></div>`,
-        `<div class="hero"><div><h1>${escHtml(clean(d.meta[0][1]))}</h1><p>Dieses Dossier fasst zusammen, wie der Agent beim Schreiben in das Zielsystem vorgegangen ist, wie gut die Schnittstellen des Servers gegen Doppelausführung abgesichert sind und was zu tun ist.</p></div>`,
+        `<div class="hero"><div><h1>${escHtml(clean(d.meta[0][1]))}</h1><p>${d.limited ? "Gekürzte Fassung ohne Lizenz: Kopf, Score und Urteil je Szenario. Der Lauf und sein Urteil sind echt." : "Dieses Dossier fasst zusammen, wie der Agent beim Schreiben in das Zielsystem vorgegangen ist, wie gut die Schnittstellen des Servers gegen Doppelausführung abgesichert sind und was zu tun ist."}</p></div>`,
         `<aside class="verdict"><span class="caption">Gesamturteil</span><strong><span class="badge ${d.tone}">${escHtml(d.verdictLabel)}</span></strong><p>${escHtml(d.explanation)}</p><p>Resilience Score: <strong>${escHtml(d.scoreText)}</strong></p></aside></div>`,
         `<dl class="meta">${d.meta.map(([l, v]) => `<div><dt>${escHtml(l)}</dt><dd>${escHtml(v)}</dd></div>`).join("")}</dl>`,
         "</header>",

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` +
@@ -79,6 +80,26 @@ function printHelp() {
         `  --read-tools pat1,pat2,...     Extra glob patterns for tool names that count as reads\n` +
         `  --key-fields a,b               Argument names that carry an idempotency key\n` +
         `                                  (default: idempotency_key, any case/separator)\n` +
+        `  --effect-probe <tool>          A READ tool of the upstream the harness calls itself, before
+` +
+        `                                  the first call and when the report is read, to count
+` +
+        `                                  records. The audit then counts records, not executions
+` +
+        `                                  (an upstream that recognises a repeat is no longer a FAIL).
+` +
+        `  --effect-probe-args '{"k":"v"}' Arguments for the probe tool (JSON object)
+` +
+        `  --effect-count <path>          Dotted path to the array/number/object to count in the
+` +
+        `                                  probe's answer (default: the only array, or count/total)
+` +
+        `  --effect-tools a,b             Write tools whose records the probe counts (glob patterns).
+` +
+        `                                  Needed when the agent also calls other write tools
+` +
+        `                                  (update_*, send_*): a count cannot be attributed otherwise
+` +
         `  --audit-tools on|off           Expose cuonztech__get_report / cuonztech__get_score\n` +
         `                                  to the connected agent (default: on). For a\n` +
         `                                  measurement use off: their descriptions tell the\n` +
@@ -91,6 +112,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 +212,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 +263,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 +276,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");
@@ -341,10 +396,44 @@ const PROXY_FLAGS = {
     "--write-tools": "single",
     "--read-tools": "single",
     "--key-fields": "single",
+    "--effect-probe": "single",
+    "--effect-probe-args": "single",
+    "--effect-count": "single",
+    "--effect-tools": "single",
     "--audit-tools": "single",
     "--report-file": "single",
     "--allow-writes": "boolean",
+    "--license": "single",
 };
+// --effect-probe-args: a JSON object. cmd.exe and Windows PowerShell 5.1 strip the
+// double quotes of '{"status":"open"}' and hand over {status:open}; that form is
+// read as well (flat key:value pairs, numbers/true/false/null as such).
+function parseProbeArgs(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        // fall through to the loose form
+    }
+    const m = /^\s*\{(.*)\}\s*$/s.exec(raw);
+    if (!m || /["'\[\]{}]/.test(m[1]))
+        return null;
+    const out = {};
+    for (const pair of m[1].split(",")) {
+        if (pair.trim() === "")
+            continue;
+        const colon = pair.indexOf(":");
+        if (colon <= 0)
+            return null;
+        const key = pair.slice(0, colon).trim();
+        const value = pair.slice(colon + 1).trim();
+        if (key === "" || value === "")
+            return null;
+        out[key] = value === "true" ? true : value === "false" ? false : value === "null" ? null : /^-?\d+(\.\d+)?$/.test(value) ? Number(value) : value;
+    }
+    return Object.keys(out).length > 0 ? out : null;
+}
 function parseEnvPair(pair, flag, into) {
     const eq = pair.indexOf("=");
     const key = eq === -1 ? "" : pair.slice(0, eq).trim();
@@ -367,6 +456,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" +
@@ -430,6 +521,34 @@ async function runProxyMode(argv) {
     const writeToolPatterns = splitList(one("--write-tools"), "--write-tools");
     const readToolPatterns = splitList(one("--read-tools"), "--read-tools");
     const keyFields = splitList(one("--key-fields"), "--key-fields");
+    // --effect-probe: count the upstream's records instead of its executions.
+    const effectProbeTool = one("--effect-probe");
+    const effectProbeArgsRaw = one("--effect-probe-args");
+    const effectCountPath = one("--effect-count");
+    const effectToolPatterns = splitList(one("--effect-tools"), "--effect-tools") ?? [];
+    if (effectProbeTool === undefined && (effectProbeArgsRaw !== undefined || effectCountPath !== undefined || effectToolPatterns.length > 0)) {
+        fail("--effect-probe-args, --effect-count and --effect-tools need --effect-probe <tool>.");
+    }
+    let effectProbe;
+    if (effectProbeTool !== undefined) {
+        let probeArgs = {};
+        if (effectProbeArgsRaw !== undefined) {
+            const parsedArgs = parseProbeArgs(effectProbeArgsRaw);
+            if (parsedArgs === null) {
+                fail(`--effect-probe-args must be a JSON object, got "${effectProbeArgsRaw}".\n` +
+                    "  bash / PowerShell 7:  --effect-probe-args '{\"status\":\"open\"}'\n" +
+                    "  cmd.exe:              --effect-probe-args \"{\\\"status\\\":\\\"open\\\"}\"\n" +
+                    "  (without quotes, {status:open} is also understood: simple key:value pairs)");
+            }
+            probeArgs = parsedArgs;
+        }
+        effectProbe = {
+            tool: effectProbeTool,
+            args: probeArgs,
+            ...(effectCountPath !== undefined ? { countPath: effectCountPath } : {}),
+            ...(effectToolPatterns.length > 0 ? { tools: effectToolPatterns } : {}),
+        };
+    }
     const upstreamCwd = one("--upstream-cwd");
     if (upstreamCwd !== undefined) {
         const info = await stat(upstreamCwd).catch(() => null);
@@ -485,9 +604,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 +637,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 " +
@@ -535,6 +672,7 @@ async function runProxyMode(argv) {
         readToolPatterns,
         keyFields,
         retryAfterSec,
+        effectProbe,
     });
     // From here on a signal must end the upstream child as well, and the
     // report file must not keep an older run's verdict while we are starting.
@@ -572,6 +710,15 @@ async function runProxyMode(argv) {
                 ? `\nUpstream stderr:\n${tail}`
                 : "\nThe upstream wrote nothing to stderr. Check the command, its arguments and that it speaks MCP over stdio."));
     }
+    if (effectProbe) {
+        try {
+            await interceptor.initEffectProbe();
+        }
+        catch (err) {
+            await interceptor.disconnectUpstream().catch(() => undefined);
+            fail(err instanceof Error ? err.message : String(err));
+        }
+    }
     const upstreamTools = interceptor.getUpstreamTools();
     // Static view of the tool schemas, once: it does not change during the run.
     const schemaAudit = auditToolSchemas(upstreamTools, { writeToolPatterns, readToolPatterns });
@@ -589,6 +736,9 @@ async function runProxyMode(argv) {
     for (const entry of classification) {
         log(`  ${entry.class.padEnd(12)} ${shown(entry.name)}  (${entry.source})`);
     }
+    for (const entry of classification.filter((c) => c.doubt)) {
+        log(`WARNING: tool "${shown(entry.name)}" is ${entry.doubt}.`);
+    }
     for (const entry of classification.filter((c) => c.class === "unclassified")) {
         log(`WARNING: tool "${shown(entry.name)}" could not be classified as read or write. Its calls ` +
             "are passed through but never trigger a scenario and are not scored — if it writes, " +
@@ -601,6 +751,11 @@ async function runProxyMode(argv) {
             "Scenarios will NEVER trigger for this upstream and every report will read NOT_TESTED. " +
             'If your write tools use different naming, pass e.g. --write-tools "yourprefix_*".');
     }
+    const probeState = interceptor.getSession().effectProbe;
+    if (probeState) {
+        log(`Effect probe: "${shown(probeState.tool)}" counted ${probeState.before} record(s) before the first call. ` +
+            "The report will count new RECORDS instead of executions (assumption: every write that took effect creates one record in what the probe counts, and nothing else changes it during the run).");
+    }
     const keyCapable = interceptor.getKeyCapableTools();
     log(keyCapable.length > 0
         ? `Idempotency-key argument recognized on: ${keyCapable.map(shown).join(", ")}`
@@ -652,8 +807,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 +819,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,
@@ -732,6 +909,7 @@ async function runProxyMode(argv) {
     };
     if (reportFile) {
         interceptor.onCallRecorded = () => writeReportFile();
+        interceptor.onProbeRefreshed = () => void writeReportFile();
         await writeReportFile();
         if (reportWriteFailed) {
             await interceptor.disconnectUpstream();
@@ -752,6 +930,8 @@ async function runProxyMode(argv) {
         if (shuttingDown)
             return;
         shuttingDown = true;
+        // The probe must be read while the upstream still runs.
+        await interceptor.refreshEffectProbe(true);
         await writeReportFile();
         await interceptor.disconnectUpstream();
         // Calls that were still open have just been ended by the disconnect and
@@ -771,7 +951,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 {};