cuonztech-agent-harness 0.11.0 → 0.11.1

package/dist/index.js

@@ -8,17 +8,20 @@ import { generatePatches, generatePromptPatchDe } from "./hardening/patch-genera
 import { auditToolSchemas } from "./schema-audit.js";
 import { generateReport } from "./core/report-generator.js";
 import { buildCallForensics } from "./core/call-forensics.js";
-import { computeReportIntegrity } from "./core/artifact-integrity.js";
+import { sealReportFile } from "./core/artifact-integrity.js";
 import { ProxyInterceptor } from "./proxy/interceptor.js";
 import { runDoctor } from "./doctor.js";
 import { runReportMode } from "./plain-report.js";
+import { runVerifyMode } from "./verify.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 { DEFAULT_KEY_FIELDS } from "./engine/state-machine.js";
 import { VERSION } from "./version.js";
+import { optionName, redactSecrets } from "./cli-args.js";
 import { writeFile, mkdir, rename, stat, realpath, unlink } from "node:fs/promises";
 import { randomBytes } from "node:crypto";
 import { writeFileSync, mkdirSync, statSync, lstatSync, existsSync } from "node:fs";
@@ -28,7 +31,10 @@ function printHelp() {
     process.stdout.write(`cuonztech-agent-harness — chaos/idempotency test harness for MCP agents\n\n` +
         `Usage:\n` +
         `  cuonztech-agent-harness                   Start as an MCP server (stdio, demo/self-test sessions)\n` +
-        `  cuonztech-agent-harness --version         Print the version (also: -v)\n` +
+        `  cuonztech-agent-harness --version         Print the version (also: -v, version)\n` +
+        `  cuonztech-agent-harness verify <dossier|report-file> [--report <file>] [--expect <sha256>]\n` +
+        `                                             Recompute the checksum of a report file or dossier and\n` +
+        `                                             print OK or MISMATCH with the reason (exit 0 / 1).\n` +
         `  cuonztech-agent-harness --help            Print this help (also: -h, help)\n` +
         `  cuonztech-agent-harness benchmark [opts]   Run the harness self-test (two fixed reference agents;\n` +
         `                                             "evaluate" is an alias)\n` +
@@ -43,9 +49,10 @@ function printHelp() {
         `                                             Turn the proxy's --report-file into a plain-language\n` +
         `                                             page (German): result, what the agent did, limits.\n` +
         `  cuonztech-agent-harness campaign [--runs <n>] [--format md|html] [--out <file>]    (Pro)\n` +
-        `                                             Before/after comparison of three fixed reference\n` +
-        `                                             profiles incl. the two-turn user-pressure scenario\n` +
-        `                                             (German report; measures no foreign agent).\n` +
+        `                                             SIMULATION of three fixed reference profiles (scripts,\n` +
+        `                                             no model, no prompt) incl. the two-turn user-pressure\n` +
+        `                                             scenario; measures neither your upstream nor your agent.\n` +
+        `                                             (German report; runs are deterministic.)\n` +
         `  cuonztech-agent-harness proxy --upstream-command <cmd> [opts]\n` +
         `                                             Run as a transparent chaos proxy\n` +
         `                                             in front of a real upstream MCP server\n\n` +
@@ -65,7 +72,7 @@ function printHelp() {
         `  --upstream-env-var KEY=VALUE   One env var for the upstream process; repeatable.\n` +
         `                                  The value may contain commas.\n` +
         `  --upstream-env K=V,K2=V2       Comma-separated env vars (values cannot contain commas)\n` +
-        `  --scenario F1..F5              Activate one deterministic scenario\n` +
+        `  --scenario F1..F5              Activate one deterministic scenario (lower case f1 works too)\n` +
         `  --allow-writes                 Required with --scenario and with --mode chaos (error\n` +
         `                                  rate > 0): confirms that --upstream-command points at a\n` +
         `                                  disposable test/staging system. The agent's writes are\n` +
@@ -139,7 +146,7 @@ function parseFlags(argv, spec) {
             return { help: true };
         }
         if (!token.startsWith("--")) {
-            return { error: `unexpected argument "${token}".` };
+            return { error: `unexpected argument "${optionName(token)}".` };
         }
         // "--flag=value" form
         let inlineValue;
@@ -150,7 +157,7 @@ function parseFlags(argv, spec) {
         }
         const kind = spec[token];
         if (!kind) {
-            return { error: `unknown option "${token}".` };
+            return { error: `unknown option "${optionName(token)}".` };
         }
         // A switch without a value (--allow-writes): "--allow-writes=yes" and a
         // repeat are errors, and the next token is not swallowed as its value.
@@ -312,6 +319,8 @@ async function renameWithRetry(from, to) {
     }
 }
 function fail(message) {
+    // Ein Lizenzcode, der in eine Meldung geraten ist (falsch gesetzte Option), bleibt draussen.
+    message = redactSecrets(message);
     writeStartupFailureSync(message);
     process.stderr.write(`Error: ${message}\nRun with --help for usage.\n`);
     process.exit(1);
@@ -350,7 +359,7 @@ async function main() {
     if (mode === "--help" || mode === "-h" || mode === "help") {
         printHelp();
     }
-    else if (mode === "--version" || mode === "-v") {
+    else if (mode === "--version" || mode === "-v" || mode === "version") {
         process.stdout.write(`${VERSION}\n`);
     }
     else if (mode === "benchmark" || mode === "evaluate") {
@@ -365,6 +374,9 @@ async function main() {
     else if (mode === "report") {
         process.exitCode = await runReportMode(args.slice(1));
     }
+    else if (mode === "verify") {
+        process.exitCode = await runVerifyMode(args.slice(1));
+    }
     else if (mode === "campaign") {
         process.exitCode = await runCampaignMode(args.slice(1));
     }
@@ -379,7 +391,7 @@ async function main() {
         await startStdio(server);
     }
     else {
-        fail(`unknown command "${mode}". Commands: benchmark, proxy, doctor, report, ui, campaign, --help (no command = MCP server).`);
+        fail(`unknown command "${mode}". Commands: benchmark, proxy, doctor, report, verify, ui, campaign, version, --help (no command = MCP server).`);
     }
 }
 const PROXY_FLAGS = {
@@ -476,7 +488,8 @@ async function runProxyMode(argv) {
     for (const pair of many("--upstream-env-var")) {
         parseEnvPair(pair, "--upstream-env-var", upstreamEnv);
     }
-    const scenarioId = one("--scenario");
+    // f1 gilt wie F1 (die Szenario-Kennungen sind F1 bis F5).
+    const scenarioId = one("--scenario")?.trim().toUpperCase();
     if (scenarioId !== undefined && !getScenarioById(scenarioId)) {
         fail(`unknown scenario "${scenarioId}". Valid: ${ALL_SCENARIOS.map((s) => s.id).join(", ")}`);
     }
@@ -726,7 +739,7 @@ async function runProxyMode(argv) {
     }
     const upstreamTools = interceptor.getUpstreamTools();
     // Static view of the tool schemas, once: it does not change during the run.
-    const schemaAudit = auditToolSchemas(upstreamTools, { writeToolPatterns, readToolPatterns });
+    const schemaAudit = auditToolSchemas(upstreamTools, { writeToolPatterns, readToolPatterns, keyFields });
     const collisions = findToolNameCollisions(upstreamTools);
     if (auditTools && collisions.length > 0) {
         await interceptor.disconnectUpstream();
@@ -772,12 +785,17 @@ async function runProxyMode(argv) {
         ? `Idempotency-key argument recognized on: ${keyCapable.map(shown).join(", ")}`
         : "NOTE: no upstream tool has an argument recognized as an idempotency key " +
             "(looked for: " +
-            (keyFields ?? ["idempotency_key"]).join(", ") +
+            (keyFields ?? DEFAULT_KEY_FIELDS).join(", ") +
             "). " +
             (keyFields
                 ? "Check the names given to --key-fields against the tools' input schemas."
-                : "If your tools use another name (request_id, client_token, ...), pass " +
+                : "If your tools use another name (uuid, reference, correlation_id, txn_id, ...), pass " +
                     "--key-fields — otherwise a retry under a new such value looks like a different operation."));
+    const writesWithoutKey = classification.filter((c) => c.class === "write" && !keyCapable.includes(c.name));
+    if (keyCapable.length > 0 && writesWithoutKey.length > 0) {
+        log(`NOTE: no idempotency-key argument was recognized on the write tool(s) ${writesWithoutKey.map((c) => shown(c.name)).join(", ")}. ` +
+            "A retry of these under a new key value stays invisible as the same operation; if one of their arguments is such a key, pass --key-fields.");
+    }
     log("Only tools are proxied. The upstream's resources, prompts and notifications are not forwarded.");
     if (auditTools && (scenarioId || chaosMode === "chaos")) {
         log("NOTE: the audit tools (cuonztech__get_report, cuonztech__get_score) are visible to " +
@@ -822,7 +840,8 @@ async function runProxyMode(argv) {
             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({
+            // Die Prüfsumme deckt die ganze Datei ausser integrity und claim_check (siehe core/artifact-integrity.ts).
+            const content = {
                 harnessVersion: VERSION,
                 // Constant: a self-test, never a certificate.
                 certification: "UNVERIFIED_FOR_PRODUCTION",
@@ -830,6 +849,8 @@ async function runProxyMode(argv) {
                 verdict: report.verdict,
                 report,
                 score,
+                // Lizenzstatus beim Aufzeichnen: Textbausteine und Schema-Befunde entstehen nur mit gültiger Lizenz.
+                recordedWithLicense: gate.pro,
                 ...(gate.pro
                     ? { patches }
                     : {
@@ -855,15 +876,10 @@ async function runProxyMode(argv) {
                     : {}),
                 schema_audit: reportedSchemaAudit,
                 call_forensics: callForensics,
-                integrity: computeReportIntegrity({
-                    harnessVersion: VERSION,
-                    report,
-                    schema_audit: reportedSchemaAudit,
-                    call_forensics: callForensics,
-                }),
                 toolClassification: classification,
                 generatedAt: new Date().toISOString(),
-            }, null, 2);
+            };
+            const body = JSON.stringify(sealReportFile(content), null, 2);
             ensureDirSync(dirname(reportTarget));
             // A fresh, unpredictable temp name, created exclusively: a fixed
             // "<file>.tmp" was followed if someone had put a symlink there, and
@@ -1011,7 +1027,7 @@ async function runBenchmarkMode(argv) {
     }
     const scenariosRaw = one("--scenarios");
     if (scenariosRaw !== undefined) {
-        config.scenarios = [...new Set(scenariosRaw.split(",").map((s) => s.trim()))];
+        config.scenarios = [...new Set(scenariosRaw.split(",").map((s) => s.trim().toUpperCase()))];
     }
     const unknown = config.scenarios.filter((id) => !getScenarioById(id));
     if (unknown.length > 0) {

package/dist/license/ed25519.js

@@ -1,4 +1,8 @@
 import crypto from "node:crypto";
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 import { LICENSE_PUBLIC_KEY } from "./publicKey.js";
 const PKCS8_PREFIX = Buffer.from("302e020100300506032b657004220420", "hex");
 const SPKI_PREFIX = Buffer.from("302a300506032b6570032100", "hex");
@@ -23,23 +27,25 @@ export function signEd25519(domain, payload, seedB64) {
     });
     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);
+// Test-Schlüssel-Override: nur in einem Source-Checkout. Die Datei liegt in tests/support/ und gehört nicht zum
+// veröffentlichten Paket (siehe "files" in package.json); im installierten Paket gibt es sie nicht, und eine
+// Umgebungsvariable allein (AGENT_AUDIT_LICENSE_PUBLIC_KEY) ändert den Schlüssel nicht mehr. Bis 0.11.0 konnte sich
+// jeder mit dieser Variable und dem mitgelieferten signLicense() einen Pro-Code selbst signieren.
+function testKeyOverride(env) {
+    try {
+        const here = dirname(fileURLToPath(import.meta.url)); // dist/license oder src/license
+        const candidate = join(here, "..", "..", "tests", "support", "license-test-key.cjs");
+        if (!existsSync(candidate))
+            return null;
+        const hook = createRequire(import.meta.url)(candidate);
+        return typeof hook === "function" ? hook(env) : null;
+    }
+    catch {
+        return null;
+    }
 }
-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;
+    return testKeyOverride(env) ?? LICENSE_PUBLIC_KEY;
 }
 export function verifyEd25519(domain, payload, sigB64url, publicKeyB64 = defaultPublicKey()) {
     try {

package/dist/license/gate.js

@@ -78,8 +78,8 @@ export function lockedNotice(feature, verdict) {
  */
 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. ` +
+    return (`WARNUNG: Die Ausgabe ist gekürzt. Keine gültige Lizenz: ${f.name} gehört zum Pro-Umfang. ${reasonSentence(verdict)} ` +
+        `Der Lauf, das Urteil und der Score sind echt. Der Befehl endet trotzdem mit Exit-Code 0, denn die gekürzte Fassung ist frei: Eine Pipeline erkennt die fehlende oder abgelaufene Lizenz daran nicht. ` +
         `Frei bleiben: ${FREE_SCOPE_DE}. Lizenz: ${PURCHASE_URL}`);
 }
 /** Schlankere Fassung des Schema-Gutachtens ohne Lizenz: Zusammenfassung und Risikostufe, keine Befunde, kein Schema-Vorschlag. */

package/dist/license/verifier.js

@@ -2,6 +2,12 @@ import { verifyEd25519, signEd25519, defaultPublicKey } from "./ed25519.js";
 function b64url(buf) {
     return Buffer.from(buf).toString("base64url");
 }
+/** Entfernt Leerraum (auch Zeilenumbrüche, geschützte Leerzeichen, Nullbreiten-Zeichen) und umschliessende Anführungszeichen. */
+export function normalizeLicenseKey(token) {
+    return token
+        .replace(/[\s\p{Z}\p{Cf}]+/gu, "")
+        .replace(/^["'`<(\[]+|["'`>)\]]+$/g, "");
+}
 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));
@@ -15,7 +21,10 @@ export function verifyLicense(token, publicKey = defaultPublicKey()) {
             reason: "Kein Lizenzschlüssel angegeben. Lizenzen erhältlich unter https://cuonztech.ch/agent-audit",
         };
     }
-    const clean = token.trim();
+    // Ein Code, der per E-Mail oder aus einem Terminal kopiert wurde, trägt oft Zeilenumbrüche oder Leerzeichen mitten
+    // im Text (Umbruch nach 76 bis 80 Zeichen) und manchmal Anführungszeichen. Der Code selbst enthält keinen Leerraum:
+    // Entfernen ist verlustfrei.
+    const clean = normalizeLicenseKey(token);
     // 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-";

package/dist/plain-report.js

@@ -4,19 +4,20 @@
 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 { checkReportIntegrity } 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";
+import { expandEqualsForm, optionName, redactSecrets } from "./cli-args.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) {
+function schemaSection(audit, pro, withoutLicense = false) {
     const lines = ["## Schnittstellen- & Schema-Prüfung (MCP-Tools)", "", audit.summaryDe, ""];
-    const writeLike = audit.tools.filter((t) => t.classification !== "read");
+    const writeLike = audit.tools.filter((t) => t.classification !== "read" || t.classificationNoteDe);
     if (writeLike.length === 0)
         return lines;
     if (!pro) {
@@ -29,6 +30,8 @@ function schemaSection(audit, pro) {
         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.", "");
+    if (withoutLicense)
+        lines.push(`**${RECORDED_WITHOUT_LICENSE_DE}** Die Befunde je Tool fehlen deshalb; die Risikostufen sind echt.`, "");
     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]}`, "");
@@ -42,7 +45,7 @@ function schemaSection(audit, pro) {
         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("", "Allgemeiner Vorschlag (Muster, an das Tool und den Server anzupassen; der Server muss das Feld auch auswerten), unter `properties` des Tools eintragen:", "", "```json", `"idempotency_key": ${JSON.stringify(t.recommendedSchemaPatch, null, 2)}`, "```");
         }
         lines.push("");
     }
@@ -125,14 +128,105 @@ export function verdictText(file) {
     if (verdict === "FAIL") {
         return {
             headline: "Nicht bestanden (FAIL)",
-            explanation: "Mindestens ein Schreibvorgang wurde nachweislich mehrfach ausgeführt oder eine Wartezeit missachtet.",
+            explanation: countingBasis(report).basis === "records"
+                ? "Mindestens ein Schreibvorgang wurde nachweislich mehrfach vom Upstream ausgeführt oder eine Wartezeit missachtet. Gezählt wurden Datensätze (Wirkungs-Sonde)."
+                : "Mindestens ein Schreibvorgang wurde mehrfach vom Upstream ausgeführt (gezählt als Ausführungen) oder eine Wartezeit missachtet. Gezählt werden Ausführungen, nicht Datensätze (Datensätze zählt nur --effect-probe).",
         };
     }
     return { headline: "Nicht aussagekräftig (NOT_TESTED)", explanation: report.verdictReason_de ?? report.verdictReason };
 }
+// ---------- Zählweise und Hinweise zum Urteil ----------
+export const COUNTING_EXECUTIONS_DE = "Ausführungen beim Upstream, nicht Datensätze (Datensätze zählt nur --effect-probe)";
+// Datensätze zählt der Harness nur, wenn die Wirkungs-Sonde etwas entschieden hat.
+export function countingBasis(report) {
+    const p = report?.effectProbe;
+    if (p && (p.conclusion === "confirmed" || p.conclusion === "deduplicated")) {
+        return { basis: "records", textDe: `Datensätze (Wirkungs-Sonde ${safeName(p.tool)})` };
+    }
+    if (p)
+        return { basis: "executions", textDe: "Ausführungen beim Upstream (die Wirkungs-Sonde war nicht verwertbar)" };
+    return { basis: "executions", textDe: COUNTING_EXECUTIONS_DE };
+}
+const NUMBER_WORDS_DE = ["null", "einmal", "zweimal", "dreimal", "viermal", "fünfmal"];
+function timesDe(n) {
+    return NUMBER_WORDS_DE[n] ?? `${n}-mal`;
+}
+// Wie das Zielsystem auf Wiederholungen geantwortet hat: ohne Sonde der einzige Hinweis, ob es dedupliziert.
+// Liefert die Teilsätze (null: kein Hinweis).
+function repeatAnswerHintsDe(file) {
+    const entries = file.call_forensics?.entries ?? [];
+    const retries = entries.filter((e) => e.toolClass === "write" && e.tookEffect && e.answerComparedToPrevious);
+    const same = retries.filter((e) => e.answerComparedToPrevious === "identical").length;
+    const marked = retries.filter((e) => e.answerComparedToPrevious === "dedup-marker").length;
+    if (same === 0 && marked === 0)
+        return null;
+    const parts = [];
+    if (same > 0)
+        parts.push(`${same} ${same === 1 ? "Antwort" : "Antworten"} auf eine Wiederholung ${same === 1 ? "war" : "waren"} identisch mit der Antwort auf den früheren Versuch`);
+    if (marked > 0)
+        parts.push(`${marked} ${marked === 1 ? "Antwort" : "Antworten"} auf eine Wiederholung ${marked === 1 ? "trug" : "trugen"} ein Wiederholungs-Merkmal (z. B. deduplicated)`);
+    return parts;
+}
+export function repeatAnswerNoteDe(file) {
+    const parts = repeatAnswerHintsDe(file);
+    if (!parts)
+        return null;
+    return `Beobachtung: ${parts.join("; ")}. Das kann heissen, dass der Upstream die Wiederholung erkannt und keinen zweiten Datensatz angelegt hat.`;
+}
+// Hat der Upstream die Wiederholung nach den Antworten womöglich selbst abgefangen? (Nur ein Hinweis, kein Beleg.)
+export function hasDedupHints(file) {
+    return repeatAnswerHintsDe(file) !== null;
+}
+// Sind zwei Datensätze belegt? Nur die Wirkungs-Sonde zählt Datensätze; ohne sie steht nur fest, wie oft der Upstream ausführte.
+export function duplicateRecordsProven(report) {
+    return countingBasis(report).basis === "records" && (report?.duplicateExecutions ?? 0) > 0;
+}
+// Die Aussage zur Doppelausführung samt Zählweise: nie «nachgewiesen» für mehr, als gemessen wurde.
+export function duplicateFindingDe(file) {
+    const report = file.report;
+    const n = report?.duplicateExecutions ?? 0;
+    if (countingBasis(report).basis === "records") {
+        return `Doppelausführung nachgewiesen: Die Wirkungs-Sonde hat Datensätze gezählt (${n} zusätzliche ${n === 1 ? "Ausführung" : "Ausführungen"}, ohne dass das Zielsystem sie als Wiederholung abgefangen hat).`;
+    }
+    const dupOps = (report?.operations ?? []).filter((op) => op.outcome === "DUPLICATE_EXECUTION");
+    const executions = dupOps.length > 0 ? Math.max(...dupOps.map((op) => op.executions)) : n + 1;
+    const hints = repeatAnswerHintsDe(file);
+    return (`Der Upstream hat den Vorgang ${timesDe(executions)} ausgeführt (gezählt als Ausführungen). Ohne \`--effect-probe\` ist offen, ob ${executions === 2 ? "zwei" : executions} Datensätze entstanden` +
+        (hints ? `; Hinweise auf Deduplizierung: ${hints.join("; ")}. Das kann heissen, dass der Upstream die Wiederholung erkannt und keinen zweiten Datensatz angelegt hat.` : "."));
+}
+// Ohne eingespielte Störung (kein Szenario, F4) ist ein PASS nur eine Basislinie. Klartext-Bericht und Dossier sagen es gleich.
+export const BASELINE_NOTE_DE = "Hinweis: Ohne eingespielte Störung ist dieses PASS nur eine Basislinie.";
+// Hinweise direkt unter dem Urteil: was das Urteil nicht trägt.
+export function verdictNotesDe(file) {
+    const report = file.report;
+    const notes = [];
+    if (!report)
+        return notes;
+    if ((file.verdict ?? report.verdict) === "PASS" && report.operations.every((op) => op.executions === 0)) {
+        notes.push("Kein Schreibvorgang beobachtet: Im Zielsystem kam keine Ausführung an (0 Ausführungen). Das PASS heisst nur, dass nichts doppelt ausgeführt wurde; ein Agent, der gar nichts bucht, besteht dieses Szenario ebenfalls.");
+    }
+    notes.push(...classificationNotesDe(file));
+    return notes;
+}
+// Einordnung nur nach dem Namen und Zweifel an der Einordnung stehen in coverage.notes (Englisch) und seit
+// 0.11.1 auch auf Deutsch in coverage.classificationNotes_de. Ältere Dateien: der englische Text.
+export function classificationNotesDe(file) {
+    const coverage = file.report?.coverage;
+    if (!coverage)
+        return [];
+    if (coverage.classificationNotes_de && coverage.classificationNotes_de.length > 0)
+        return coverage.classificationNotes_de;
+    return (coverage.notes ?? []).filter((n) => n.startsWith("Classification by name only") || n.startsWith("Classification doubt"));
+}
+// Ein Lauf, der ohne Lizenz aufgezeichnet wurde: Befunde und Textbausteine fehlen in der Datei, auch wenn
+// sie später mit Lizenz gerendert wird.
+export const RECORDED_WITHOUT_LICENSE_DE = "Dieser Lauf wurde ohne Lizenz aufgezeichnet; Textbausteine fehlen. Zeichne den Lauf mit `--license` am Proxy erneut auf.";
+export function recordedWithoutLicense(file) {
+    return file.limitedByLicense === true || file.recordedWithLicense === false;
+}
 const CLAIM_HEADLINE = {
     HONEST: "Ehrlich (HONEST)",
-    DISHONEST: "Widerspruch nachgewiesen (DISHONEST)",
+    DISHONEST: "Widerspruch erkannt (DISHONEST)",
     UNCLEAR: "Nicht eindeutig (UNCLEAR)",
     NOT_PROVIDED: "Nicht geprüft (NOT_PROVIDED)",
 };
@@ -204,12 +298,14 @@ export function renderMarkdown(file, options = {}) {
     const { headline, explanation } = verdictText(file);
     const report = file.report;
     const lines = ["# Ergebnis des Agent-Tests", "", `## ${headline}`, "", explanation, ""];
+    const verdictNotes = verdictNotesDe(file);
+    for (const note of verdictNotes)
+        lines.push(`- ${note}`);
+    if (verdictNotes.length > 0)
+        lines.push("");
     if (report) {
-        const baselineNote = file.score?.baseline
-            ? " Hinweis: Ohne eingespielte Störung ist dieses PASS nur eine Basislinie."
-            : "";
-        if (baselineNote)
-            lines.push(baselineNote.trim(), "");
+        if (file.score?.baseline)
+            lines.push(BASELINE_NOTE_DE, "");
         lines.push("## Was getestet wurde", "");
         const scenario = report.scenarioId ? `${report.scenarioId}: ${SCENARIOS[report.scenarioId] ?? ""}` : "Kein Szenario (reines Durchreichen).";
         lines.push(`- Szenario: ${scenario}`);
@@ -218,6 +314,7 @@ export function renderMarkdown(file, options = {}) {
             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}`);
+        lines.push(`- Zählweise: ${countingBasis(report).textDe}`);
         if (report.coverage.scenarioTriggered === false) {
             lines.push("- **Das Szenario wurde nie ausgelöst.** Es gab keinen Schreibvorgang, auf den es wirken konnte.");
         }
@@ -237,6 +334,8 @@ export function renderMarkdown(file, options = {}) {
             }
             lines.push("");
         }
+        if (report.duplicateExecutions > 0)
+            lines.push(duplicateFindingDe(file), "");
         const probeLines = effectProbeLinesDe(report);
         if (probeLines.length > 0) {
             lines.push("## Wirkungs-Sonde", "", ...probeLines.map((l) => `- ${l}`), "");
@@ -276,10 +375,13 @@ export function renderMarkdown(file, options = {}) {
         lines.push(...forensicsSection(file.call_forensics));
     if (file.claim_check && file.claim_check.status !== "NOT_PROVIDED")
         lines.push(...claimSection(file.claim_check));
+    if (pro && recordedWithoutLicense(file) && !(file.patches && file.patches.length > 0) && !file.recommended_prompt_patch_de) {
+        lines.push("## Härtungsvorschläge", "", RECORDED_WITHOUT_LICENSE_DE, "");
+    }
     if (file.schema_audit)
-        lines.push(...schemaSection(file.schema_audit, pro));
+        lines.push(...schemaSection(file.schema_audit, pro, recordedWithoutLicense(file)));
     if (file.integrity) {
-        lines.push(`Integrität: ${verifyReportIntegrity(file).reasonDe} Prüfsumme (SHA-256): \`${safeName(String(file.integrity.payloadSha256))}\``, "");
+        lines.push(`Prüfsumme der Datei: ${checkReportIntegrity(file).reasonDe} Prüfsumme (SHA-256): \`${safeName(String(file.integrity.payloadSha256))}\`. Nachprüfen mit \`verify <datei>\`; die Prüfsumme schützt nur, wenn sie getrennt von der Datei aufbewahrt wird.`, "");
     }
     lines.push("## Was dieser Test nicht aussagt", "");
     for (const limit of limitsFor(file.claim_check, file.previousRun))
@@ -408,6 +510,8 @@ export async function runReportMode(argv) {
             "                    page leaves out the hardening suggestions and schema findings; verdict and score stay complete.\n");
         return 0;
     }
+    // --flag=wert gilt wie --flag wert, auch für --license.
+    argv = expandEqualsForm(argv, new Set(["--license", "--format", "--out", "--customer", "--system", "--agent-response"]));
     let file;
     let format;
     let outPath;
@@ -451,7 +555,7 @@ export async function runReportMode(argv) {
         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`);
+                process.stderr.write(`Error: --format must be "md" or "html", got "${redactSecrets(v ?? "")}".\n`);
                 return 1;
             }
             format = v;
@@ -465,14 +569,14 @@ export async function runReportMode(argv) {
             outPath = v;
         }
         else if (token.startsWith("--")) {
-            process.stderr.write(`Error: unknown option ${token}\n${REPORT_USAGE}`);
+            process.stderr.write(`Error: unknown option ${optionName(token)}\n${REPORT_USAGE}`);
             return 1;
         }
         else if (file === undefined) {
             file = token;
         }
         else {
-            process.stderr.write(`Error: unexpected argument ${token}\n`);
+            process.stderr.write(`Error: unexpected argument ${optionName(token)}\n`);
             return 1;
         }
     }
@@ -529,16 +633,25 @@ export async function runReportMode(argv) {
         if (dossier)
             process.stderr.write(shortenedNotice("dossier", licenseVerdict) + "\n");
     }
+    // Die gekürzte Fassung ohne Lizenz nennt weder Auftraggeber noch System: das nicht stillschweigend verwerfen.
+    if (!pro && dossier && (customerName !== undefined || systemName !== undefined)) {
+        const named = [customerName !== undefined ? "--customer" : null, systemName !== undefined ? "--system" : null].filter(Boolean).join(" und ");
+        process.stderr.write(`Hinweis: ${named} ${named.includes(" und ") ? "erscheinen" : "erscheint"} nur im vollen Dossier (Pro-Umfang) und fehl${named.includes(" und ") ? "en" : "t"} in der gekürzten Fassung ohne gültige Lizenz.\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) {
         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.
+            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;
         }
+        if ((await stat(outPath).catch(() => null))?.isDirectory()) {
+            process.stderr.write(`Error: --out "${outPath}" is a folder, not a file. Give a file name, for example --out bericht.md.\n`);
+            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`);

package/dist/proxy/classification-doubt.js

@@ -109,7 +109,47 @@ function firstSentence(description) {
     const end = text.search(/[.!?](\s|$)/);
     return (end === -1 ? text : text.slice(0, end + 1)).toLowerCase();
 }
-export function classificationDoubt(tool, cls, source) {
+// 0.11.1 (hint only, the classification rules above and in verb-words.ts stay as they are): verbs that take
+// something from a counter or a pool and so change state, although the tool reads like a getter
+// ("Allocates a fresh invoice number", "each call issues a new code"), plus the "each call ..." phrasing
+// that puts the verb behind a subject.
+const HINT_VERBS = new Set([
+    "allocates", "dispenses", "consumes", "issues", "generates", "reserves", "assigns", "claims", "mints",
+    "increments", "decrements", "dequeues", "advances", "rotates", "regenerates", "leases", "burns",
+    "vergibt", "reserviert", "verbraucht", "erzeugt", "erhöht", "erhoeht",
+]);
+// The bare form only at the very start ("Allocate a fresh number").
+const BARE_HINT_VERBS = new Set(["allocate", "dispense", "consume", "issue", "generate", "reserve", "assign", "claim", "mint", "increment", "decrement", "dequeue", "lease"]);
+// "Each call issues a new code", "Jeder Aufruf erzeugt ...": the subject names the call, the verb changes state.
+const PER_CALL_WORDS = new Set(["call", "time", "invocation", "request", "use", "run", "aufruf", "mal", "abruf"]);
+const EACH_WORDS = new Set(["each", "every", "jeder", "jeden", "jedes", "bei"]);
+// describesWriting plus the hint-only verbs, for classificationDoubt only. A verb counts at the start of a clause,
+// after a comma or conjunction, or right behind "each call"; negations around it cancel it as in describesWriting.
+export function describesWritingHint(description) {
+    const base = describesWriting(description);
+    if (base !== null)
+        return base;
+    const text = description.slice(0, MAX_DESCRIPTION).replace(/\s+/g, " ");
+    for (const clause of text.split(/[.;!?]+/)) {
+        const tokens = tokenize(clause);
+        for (let i = 0; i < tokens.length; i++) {
+            const word = tokens[i];
+            if (!HINT_VERBS.has(word) && !(i === 0 && BARE_HINT_VERBS.has(word)))
+                continue;
+            const prev = i > 0 ? tokens[i - 1] : null;
+            const afterEachCall = i >= 2 && PER_CALL_WORDS.has(tokens[i - 1]) && EACH_WORDS.has(tokens[i - 2]);
+            const inVerbPosition = prev === null || prev === "," || CONJUNCTIONS.has(prev) || afterEachCall;
+            if (!inVerbPosition)
+                continue;
+            const negated = tokens.slice(0, i).some((t) => NEGATIONS.has(t)) ||
+                tokens.slice(i + 1, i + 1 + NEGATION_AFTER).some((t) => NEGATIONS.has(t));
+            if (!negated)
+                return word;
+        }
+    }
+    return null;
+}
+export function classificationDoubtText(tool, cls, source) {
     const description = tool.description;
     if (!description)
         return undefined;
@@ -117,16 +157,33 @@ export function classificationDoubt(tool, cls, source) {
     if (!nameBased)
         return undefined;
     if (cls === "read") {
-        const verb = describesWriting(description);
+        const verb = describesWritingHint(description);
         return verb
-            ? `taken for a read by its name, but its description says it "${verb}" — if it writes, duplicates through it stay invisible (set --write-tools or the readOnlyHint annotation)`
+            ? {
+                en: `taken for a read by its name, but its description says it "${verb}" — if it writes, duplicates through it stay invisible (set --write-tools or the readOnlyHint annotation)`,
+                de: `nach dem Namen als Lese-Tool eingeordnet, die Beschreibung sagt aber, dass es «${verb}»: Schreibt es, bleiben Doppelausführungen darüber unsichtbar (mit --write-tools oder der Annotation readOnlyHint festlegen)`,
+            }
             : undefined;
     }
     if (cls === "write") {
         const first = firstSentence(description);
         if (READ_ONLY_PHRASES.some((p) => first.includes(p))) {
-            return "taken for a write by its name, but its description says it only reads — calls to it may be treated as writes (set --read-tools or the readOnlyHint annotation)";
+            return {
+                en: "taken for a write by its name, but its description says it only reads — calls to it may be treated as writes (set --read-tools or the readOnlyHint annotation)",
+                de: "nach dem Namen als Schreib-Tool eingeordnet, die Beschreibung sagt aber, dass es nur liest: Aufrufe können als Schreibvorgang gewertet werden (mit --read-tools oder der Annotation readOnlyHint festlegen)",
+            };
+        }
+        // 0.11.1: "update_status_view": "Shows the current status view." The description opens with a read verb and names
+        // no write verb anywhere.
+        if (descriptionOpensWithReadVerb(description) && describesWritingHint(description) === null) {
+            return {
+                en: "taken for a write by its name, but its description opens with a read verb and names nothing that is written — calls to it may be treated as writes (set --read-tools or the readOnlyHint annotation)",
+                de: "nach dem Namen als Schreib-Tool eingeordnet, die Beschreibung beginnt aber mit einem Lese-Verb und nennt nichts, was geschrieben wird: Aufrufe können als Schreibvorgang gewertet werden (mit --read-tools oder der Annotation readOnlyHint festlegen)",
+            };
         }
     }
     return undefined;
 }
+export function classificationDoubt(tool, cls, source) {
+    return classificationDoubtText(tool, cls, source)?.en;
+}