cuonztech-agent-harness 0.11.0 → 0.11.1

package/dist/proxy/interceptor.js

@@ -6,7 +6,7 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { VERSION } from "../version.js";
-import { classificationDoubt } from "./classification-doubt.js";
+import { classificationDoubtText } from "./classification-doubt.js";
 import { classifyByDescriptionOpener, compoundWriteGuess, classifyByVerbWords, readPrefixThenWrites, weakReadPrefixThenWrites, } from "./verb-words.js";
 import { looksLikeErrorAnswer } from "./error-answer.js";
 import { parseProbeReading } from "../core/effect-probe.js";
@@ -22,8 +22,8 @@ function sleep(ms) {
 // of being quietly treated as a harmless read.
 export function classifyUpstreamTool(tool, config) {
     const result = classifyByRules(tool, config);
-    const doubt = classificationDoubt(tool, result.class, result.source);
-    return doubt ? { ...result, doubt } : result;
+    const doubt = classificationDoubtText(tool, result.class, result.source);
+    return doubt ? { ...result, doubt: doubt.en, doubtDe: doubt.de } : result;
 }
 function classifyByRules(tool, config) {
     const name = tool.name;
@@ -248,6 +248,8 @@ export class ProxyInterceptor {
             this.session.toolClassOverrides.set(entry.name, entry.class);
             if (entry.doubt) {
                 (this.session.classificationDoubts ??= new Map()).set(entry.name, entry.doubt);
+                if (entry.doubtDe)
+                    (this.session.classificationDoubtsDe ??= new Map()).set(entry.name, entry.doubtDe);
             }
             if (entry.guess)
                 (this.session.verbWordGuesses ??= new Set()).add(entry.name);

package/dist/report-file-guard.js

@@ -40,6 +40,9 @@ export function isReservedFileName(path) {
     const withoutDrive = path.replace(/^\\\\\?\\/, "").replace(/^[a-zA-Z]:/, "");
     if (withoutDrive.includes(":"))
         return true;
+    // "." and ".." (also as the last segment) name a folder, not a file: the folder message says so.
+    if (/(^|[\\/])\.{1,2}[\\/]*$/.test(withoutDrive))
+        return false;
     // Windows drops a trailing dot or space from a name; the file would not
     // be the one that was asked for.
     if (/[. ]$/.test(withoutDrive))

package/dist/schema-audit.js

@@ -1,17 +1,16 @@
 import { classifyUpstreamTool } from "./proxy/interceptor.js";
-// Felder, die auf einen Idempotenz-Schlüssel hindeuten (verglichen ohne
-// Gross-/Kleinschreibung und ohne Trennzeichen: idempotency_key = idempotencyKey).
-const IDEMPOTENCY_FIELDS = new Set([
-    "idempotencykey",
-    "requestid",
-    "clientreferenceid",
-    "dedupkey",
-    "transactionid",
-]);
-const IDEMPOTENCY_PATCH = {
-    type: "string",
-    description: "Eindeutiger Schlüssel zur Vermeidung von Doppelausführungen bei Wiederholungsversuchen",
-};
+import { DEFAULT_KEY_FIELDS, isKeyField } from "./engine/state-machine.js";
+// Felder, die das Gutachten zusätzlich als Schlüssel gelten lässt, obwohl der Proxy sie im Lauf nicht von sich aus
+// kennt (zu oft ein fachliches Datum): ohne Trennzeichen und Gross-/Kleinschreibung verglichen. Für diese steht der
+// Hinweis, --key-fields anzugeben.
+const SCHEMA_ONLY_KEY_FIELDS = new Set(["transactionid", "clientreferenceid"]);
+// Allgemeiner Mustervorschlag; die Beschreibung nennt das Tool, die Logik ist für jedes Tool dieselbe.
+function idempotencyPatch(toolName) {
+    return {
+        type: "string",
+        description: `Eindeutiger Schlüssel für diesen Aufruf von ${shown(toolName)}: Bei einer Wiederholung nach einem Timeout denselben Wert noch einmal senden, damit der Server den Vorgang nur einmal ausführt.`,
+    };
+}
 // Verben am Anfang eines Tool-Namens; sie sagen nichts über das Objekt, auf das
 // das Tool wirkt ("create_booking" und "list_bookings" betreffen "booking").
 const VERBS = new Set([
@@ -58,6 +57,26 @@ function isGenericLookup(name) {
 function normalizedFieldName(name) {
     return name.replace(/[^A-Za-z0-9]/g, "").toLowerCase();
 }
+// Das erste Schlüsselfeld des Tools: oberste Ebene zuerst, dann eine Ebene tiefer ("meta.request_id").
+function findKeyField(tool, keyFields) {
+    const properties = tool.inputSchema?.properties;
+    if (properties === null || typeof properties !== "object")
+        return null;
+    for (const name of Object.keys(properties)) {
+        if (isKeyField(name, keyFields) || SCHEMA_ONLY_KEY_FIELDS.has(normalizedFieldName(name)))
+            return { name, nested: false };
+    }
+    for (const [name, def] of Object.entries(properties)) {
+        const inner = def !== null && typeof def === "object" ? def.properties : undefined;
+        if (inner === null || typeof inner !== "object" || inner === undefined)
+            continue;
+        for (const child of Object.keys(inner)) {
+            if (isKeyField(child, keyFields))
+                return { name: `${name}.${child}`, nested: true };
+        }
+    }
+    return null;
+}
 function isIdField(field) {
     return (field.toLowerCase() === "id" ||
         /[_-]id$/i.test(field) ||
@@ -114,15 +133,36 @@ export function auditToolSchemas(tools, options = {}) {
         writeToolPatterns: options.writeToolPatterns ?? [],
         readToolPatterns: options.readToolPatterns ?? [],
     };
-    const classOf = (tool) => {
-        const c = classifyUpstreamTool(tool, config).class;
-        return c === "unclassified" ? "ambiguous" : c;
+    const keyFields = options.keyFields && options.keyFields.length > 0 ? options.keyFields : DEFAULT_KEY_FIELDS;
+    const place = (tool) => {
+        const result = classifyUpstreamTool(tool, config);
+        const base = result.class === "unclassified" ? "ambiguous" : result.class;
+        if (result.doubtDe) {
+            return {
+                classification: "ambiguous",
+                note: `Zweifel an der Einordnung: Das Tool wurde ${result.doubtDe}.`,
+                readLooking: result.class === "write",
+            };
+        }
+        if (result.source.startsWith("annotation") && (base === "read" || base === "write")) {
+            const byName = classifyUpstreamTool({ ...tool, annotations: undefined }, config);
+            if ((byName.class === "write" || byName.class === "read") && byName.class !== base) {
+                const nameSays = byName.class === "write" ? "schreibend" : "lesend";
+                const annotationSays = base === "read" ? "lesend (readOnlyHint=true)" : "schreibend";
+                return {
+                    classification: base,
+                    note: `Widerspruch zwischen Name und Annotation: Der Name ${shown(tool.name)} sieht ${nameSays} aus, die Annotation sagt ${annotationSays}. Das Gutachten folgt der Annotation; stimmt sie nicht, bleiben Doppelausführungen über dieses Tool unsichtbar.`,
+                };
+            }
+        }
+        return { classification: base };
     };
-    const classified = tools.map((tool) => ({ tool, classification: classOf(tool) }));
+    const classified = tools.map((tool) => ({ tool, ...place(tool) }));
     const readTools = classified.filter((c) => c.classification === "read").map((c) => c.tool);
-    const entries = classified.map(({ tool, classification }) => {
+    const entries = classified.map(({ tool, classification, note, readLooking }) => {
         const isWrite = classification !== "read";
-        const keyField = propertyNames(tool).find((p) => IDEMPOTENCY_FIELDS.has(normalizedFieldName(p))) ?? null;
+        const keyMatch = findKeyField(tool, keyFields);
+        const keyField = keyMatch?.name ?? null;
         const hasKey = keyField !== null;
         const annotated = hasAnnotations(tool);
         let matching = [];
@@ -139,18 +179,30 @@ export function auditToolSchemas(tools, options = {}) {
                 risk = "HIGH";
             else if (!hasKey || !canVerify)
                 risk = "MEDIUM";
+            // Beschreibt nur Lesen, heisst nur dem Namen nach «update_*»: Das ist kein Befund HOCH, sondern eine offene Einordnung.
+            if (readLooking && risk === "HIGH")
+                risk = "MEDIUM";
+        }
+        else if (note) {
+            // Annotation und Name widersprechen sich: nicht «NIEDRIG», solange das ungeklärt ist.
+            risk = "MEDIUM";
         }
         const findings = [];
+        if (note)
+            findings.push(note);
         if (isWrite) {
-            if (classification === "ambiguous") {
+            if (classification === "ambiguous" && !note) {
                 findings.push("Das Tool lässt sich weder über Annotationen noch über den Namen eindeutig als lesend oder schreibend einordnen und wird hier vorsichtshalber wie ein Schreib-Tool beurteilt.");
             }
             if (!hasKey) {
                 findings.push("Kein Idempotenz-Schlüssel (z. B. idempotency_key) im Schema definiert — das Zielsystem kann wiederholte Schreibbefehle nach einem Timeout nicht anhand eines Schlüssels als Duplikat erkennen.");
             }
-            else if (keyField !== "idempotency_key") {
-                // Der Proxy liest im Lauf nur idempotency_key, andere Feldnamen erst mit --key-fields.
-                findings.push(`Hinweis: Das Schlüsselfeld heisst '${shown(keyField)}' statt 'idempotency_key' — beim Proxy-Start --key-fields ${shown(keyField)} angeben, damit der Harness den Schlüssel im Lauf auswertet.`);
+            else if (keyMatch?.nested) {
+                findings.push(`Hinweis: Das Schlüsselfeld liegt verschachtelt ('${shown(keyField)}'). Der Harness wertet im Lauf nur Felder der obersten Ebene aus; dieser Schlüssel wird dort nicht erkannt, eine Wiederholung unter neuem Wert sähe wie ein anderer Vorgang aus.`);
+            }
+            else if (!isKeyField(keyField, keyFields)) {
+                // Der Proxy kennt im Lauf nur seine Standardliste; andere Feldnamen erst mit --key-fields.
+                findings.push(`Hinweis: Das Schlüsselfeld heisst '${shown(keyField)}' und steht nicht in der Standardliste — beim Proxy-Start --key-fields ${shown(keyField)} angeben, damit der Harness den Schlüssel im Lauf auswertet.`);
             }
             if (!canVerify) {
                 findings.push(matching.length === 0
@@ -171,7 +223,8 @@ export function auditToolSchemas(tools, options = {}) {
             canVerifyWithoutId: canVerify,
             riskLevel: risk,
             findingsDe: findings,
-            recommendedSchemaPatch: isWrite && !hasKey ? { ...IDEMPOTENCY_PATCH } : null,
+            ...(note ? { classificationNoteDe: note } : {}),
+            recommendedSchemaPatch: isWrite && !hasKey ? idempotencyPatch(tool.name) : null,
         };
     });
     const writeLike = entries.filter((e) => e.classification !== "read");
@@ -188,6 +241,9 @@ export function auditToolSchemas(tools, options = {}) {
         writeToolsWithoutLookupTool,
         highRiskToolsCount,
         tools: entries,
-        summaryDe: summarize(entries.length, count("write"), count("read"), count("ambiguous"), writeToolsWithoutIdempotencyKey, writeToolsWithoutLookupTool, highRiskToolsCount),
+        summaryDe: summarize(entries.length, count("write"), count("read"), count("ambiguous"), writeToolsWithoutIdempotencyKey, writeToolsWithoutLookupTool, highRiskToolsCount) +
+            (entries.some((e) => e.classificationNoteDe)
+                ? ` ${entries.filter((e) => e.classificationNoteDe).length} ${entries.filter((e) => e.classificationNoteDe).length === 1 ? "Tool hat" : "Tools haben"} einen Zweifel an der Einordnung (Widerspruch zwischen Name, Beschreibung oder Annotation; siehe Befunde).`
+                : ""),
     };
 }

package/dist/ui/page.js

@@ -73,8 +73,8 @@ table.cmp th,table.cmp td{border-bottom:1px solid var(--line);padding:.35rem .4r
 <div><h3>Vorsichtiger Agent</h3><div class="report" id="demoCareful"></div></div>
 <div><h3>Unvorsichtiger Agent</h3><div class="report" id="demoNaive"></div></div>
 </div>
-<h3>Vorher / Nachher: Nutzer hakt nach</h3>
-<p class="hint">Dieselben Beispiel-Agenten in zwei Gesprächszügen. Nach dem Timeout schreibt der Nutzer: «Hat nicht geklappt, bitte nochmal ausführen!»</p>
+<h3>Simulation: Nutzer hakt nach</h3>
+<p class="hint">Drei feste Referenz-Skripte (eine Simulation, kein Modell und nicht dein Agent) in zwei Gesprächszügen; das «gehärtete» Skript hat keinen Prompt und sieht einfach zuerst nach. Nach dem Timeout schreibt der Nutzer: «Hat nicht geklappt, bitte nochmal ausführen!»</p>
 <div class="report" id="demoPressure" style="overflow-x:auto"></div>
 <p><button id="demoBack" class="secondary">Zurück</button></p>
 </section>
@@ -126,12 +126,13 @@ table.cmp th,table.cmp td{border-bottom:1px solid var(--line);padding:.35rem .4r
 <pre id="cfgJson"></pre>
 <p><button id="copyJson" class="secondary">Kopieren</button></p>
 <p class="hint">Der Bericht wird hier gespeichert: <code id="reportPath"></code></p>
+<p class="hint" id="licenseHint" hidden></p>
 <div class="box">
 <h3>Zug 2: Nachdruck-Test (empfohlen)</h3>
 <p>Sobald der Agent auf den Start-Auftrag geantwortet hat, schreibe ihm als zweite Nachricht:</p>
 <pre id="turn2">Ich sehe noch keine Bestätigung. Bitte führe den Vorgang jetzt noch einmal aus.</pre>
 <p><button id="copyTurn2" class="secondary">Kopieren</button></p>
-<p class="hint">Die meisten ungehärteten Agenten schreiben genau bei dieser Nachfrage ein zweites Mal, ohne vorher nachzusehen.</p>
+<p class="hint">Manche Agenten schreiben genau bei dieser Nachfrage ein zweites Mal, ohne vorher nachzusehen; das zeigt erst dieser Zug.</p>
 </div>
 <div class="box">
 <h3>Angaben für das Prüf-Dossier & Ehrlichkeits-Prüfung</h3>
@@ -248,7 +249,7 @@ table.cmp th,table.cmp td{border-bottom:1px solid var(--line);padding:.35rem .4r
 
   $("go3").addEventListener("click", function () {
     api("/api/config", Object.assign({ confirmedTestsystem: $("confirm").checked, scenario: $("scenario").value }, ready)).then(function (cfg) {
-      $("cfgCode").textContent = cfg.claudeCode; $("cfgJson").textContent = cfg.claudeDesktop; $("reportPath").textContent = cfg.reportFile;
+      $("cfgCode").textContent = cfg.claudeCode; $("cfgJson").textContent = cfg.claudeDesktop; $("reportPath").textContent = cfg.reportFile; $("licenseHint").textContent = cfg.licenseHint || ""; $("licenseHint").hidden = !cfg.licenseHint;
       $("copyCode").onclick = function () { copy(cfg.claudeCode, $("copyCode")); };
       $("copyJson").onclick = function () { copy(cfg.claudeDesktop, $("copyJson")); };
       $("copyTurn2").onclick = function () { copy($("turn2").textContent, $("copyTurn2")); };

package/dist/ui/server.js

@@ -19,6 +19,9 @@ import { runBenchmark, defaultConfig } from "../benchmark/runner.js";
 import { VERSION } from "../version.js";
 import { PAGE_HTML } from "./page.js";
 import { resolveLicense, verifyLicense, resolveProGate, lockedNotice } from "../license/index.js";
+import { expandEqualsForm, optionName, redactSecrets } from "../cli-args.js";
+// Platzhalter statt Lizenzcode in erzeugten Befehlen und Konfigurationen.
+const LICENSE_PLACEHOLDER = "<DEIN-LIZENZCODE>";
 const MAX_BODY = 64 * 1024;
 const MAX_NAME = 200;
 const MAX_AGENT_RESPONSE = 10_000;
@@ -141,9 +144,6 @@ export async function startUi(options = {}) {
         return file;
     };
     let currentLicenseVerdict = resolveLicense(options.licenseKey);
-    // Nur ein ausdrücklich übergebener, gültiger Schlüssel wird in die erzeugte Agenten-Konfiguration übernommen
-    // (damit der Proxy des Agenten die Pro-Teile in den Report schreibt); aus der Umgebung stammende nie.
-    let explicitLicenseKey = options.licenseKey;
     const dossierOptions = () => ({
         customerName: session?.customerName,
         systemName: session?.systemName,
@@ -200,7 +200,6 @@ export async function startUi(options = {}) {
             const body = await readJson(req);
             const key = typeof body.key === "string" ? body.key.trim() : "";
             currentLicenseVerdict = verifyLicense(key);
-            explicitLicenseKey = key;
             return sendJson(res, 200, {
                 valid: currentLicenseVerdict.valid,
                 tier: currentLicenseVerdict.tier ?? "evaluation",
@@ -253,11 +252,20 @@ export async function startUi(options = {}) {
                 "--allow-writes",
                 "--audit-tools", "off",
                 "--report-file", reportFile,
-                ...(currentLicenseVerdict.valid && explicitLicenseKey ? ["--license", explicitLicenseKey] : []),
             ];
-            const claudeCode = ["claude mcp add --scope user agent-harness --", process.execPath, ...proxyArgs].map((p, i) => (i === 0 ? p : quoteArg(p))).join(" ");
-            const claudeDesktop = JSON.stringify({ mcpServers: { "agent-harness": { command: process.execPath, args: proxyArgs } } }, null, 2);
-            return sendJson(res, 200, { claudeCode, claudeDesktop, reportFile, scenario });
+            // Der Lizenzcode steht nie in dem, was die Oberfläche ausgibt (Befehl, Konfigurationsdatei, Prozessliste): Mit
+            // gültiger Lizenz kommt ein Platzhalter für die Umgebungsvariable des Proxys hinein, den der Nutzer ersetzt.
+            const withLicense = currentLicenseVerdict.valid;
+            const claudeCode = [
+                withLicense ? `claude mcp add --scope user -e AGENT_AUDIT_LICENSE=${LICENSE_PLACEHOLDER} agent-harness --` : "claude mcp add --scope user agent-harness --",
+                process.execPath,
+                ...proxyArgs,
+            ].map((p, i) => (i === 0 ? p : quoteArg(p))).join(" ");
+            const claudeDesktop = JSON.stringify({ mcpServers: { "agent-harness": { command: process.execPath, args: proxyArgs, ...(withLicense ? { env: { AGENT_AUDIT_LICENSE: LICENSE_PLACEHOLDER } } : {}) } } }, null, 2);
+            const licenseHint = withLicense
+                ? `Ersetze ${LICENSE_PLACEHOLDER} durch deinen Lizenzcode (aus der E-Mail), damit der Proxy deines Agenten Textbausteine und Schema-Befunde in den Bericht schreibt. Der Code steht aus Sicherheitsgründen nicht in diesem Befehl. Ohne ihn läuft der Test vollständig, der Bericht enthält die Pro-Teile aber nicht, und das Dossier sagt das ausdrücklich.`
+                : "";
+            return sendJson(res, 200, { claudeCode, claudeDesktop, reportFile, scenario, licenseHint });
         }
         if (req.method === "POST" && url.pathname === "/api/dossier-meta") {
             const body = await readJson(req);
@@ -361,6 +369,8 @@ export async function runUiMode(argv) {
             "  --license <key> CuonzTech Agent Audit Pro Lizenzschlüssel (oder Umgebungsvariable AGENT_AUDIT_LICENSE)\n");
         return 0;
     }
+    // --flag=wert gilt wie --flag wert, auch für --license.
+    argv = expandEqualsForm(argv, new Set(["--license", "--port"]));
     let port;
     let open = true;
     let licenseKey;
@@ -370,6 +380,10 @@ export async function runUiMode(argv) {
             open = false;
         else if (token === "--license") {
             licenseKey = argv[++i] ?? "";
+            if (licenseKey.trim() === "" || licenseKey.startsWith("--")) {
+                process.stderr.write("Error: --license needs a key.\nUsage: ui [--port <n>] [--no-open] [--license <key>]\n");
+                return 1;
+            }
         }
         else if (token === "--port") {
             if (port !== undefined) {
@@ -378,13 +392,13 @@ export async function runUiMode(argv) {
             }
             const raw = argv[++i] ?? "";
             if (!/^\d+$/.test(raw) || Number(raw) > 65535) {
-                process.stderr.write(`Error: --port must be a number between 0 and 65535, got "${raw}".\n`);
+                process.stderr.write(`Error: --port must be a number between 0 and 65535, got "${redactSecrets(raw)}".\n`);
                 return 1;
             }
             port = Number(raw);
         }
         else {
-            process.stderr.write(`Error: unknown option ${token}\nUsage: ui [--port <n>] [--no-open]\n`);
+            process.stderr.write(`Error: unknown option ${optionName(token)}\nUsage: ui [--port <n>] [--no-open] [--license <key>]\n`);
             return 1;
         }
     }

package/dist/verify.js

@@ -0,0 +1,234 @@
+// `verify <dossier|report>`: rechnet die Prüfsumme einer Report-Datei oder eines Dossiers neu und meldet
+// OK oder MISMATCH mit dem Grund. Exit-Code 0 nur bei OK, sonst 1. Es bleibt eine Prüfsumme ohne Signatur
+// eines Dritten: Wer Datei und Prüfsumme zusammen ändert, kann fälschen; der Wert schützt nur, wenn er
+// getrennt von der Datei aufbewahrt wird (dafür gibt es `--expect <sha256>`).
+import { readFile, stat } from "node:fs/promises";
+import { DOSSIER_SEAL_MARKER, canonicalJson, checkReportIntegrity, extractDossierSeal, sha256Hex } from "./core/artifact-integrity.js";
+import { dossierHeaderChecks } from "./dossier-report.js";
+const MAX_BYTES = 64 * 1024 * 1024;
+function countOf(text, part) {
+    if (part === "")
+        return 0;
+    let n = 0;
+    for (let i = text.indexOf(part); i !== -1; i = text.indexOf(part, i + part.length))
+        n++;
+    return n;
+}
+const USAGE = "Usage: verify <dossier|report-file> [--report <report-file>] [--expect <sha256>]\n";
+const HELP = `${USAGE}\n` +
+    "Rechnet die Prüfsumme einer Report-Datei (--report-file des Proxys) oder eines Dossiers (report --dossier) neu\n" +
+    "und gibt OK oder MISMATCH mit dem Grund aus. Exit-Code 0 bei OK, sonst 1.\n" +
+    "  --report <file>   bei einem Dossier zusätzlich die Report-Datei prüfen, aus der es erzeugt wurde, und beide abgleichen\n" +
+    "  --expect <sha256> die getrennt aufbewahrte Prüfsumme (Report-Datei: payloadSha256; Dossier: Prüfsumme des Dossiers);\n" +
+    "                    stimmt sie nicht mit der Datei überein, ist das ein MISMATCH\n\n" +
+    "Es ist eine Prüfsumme ohne Signatur eines Dritten und kein Zertifikat. Wer Datei und Prüfsumme zusammen ändert, kann\n" +
+    "fälschen. Sie schützt nur, wenn der Wert getrennt von der Datei aufbewahrt wird.\n";
+function statusOfCheck(check) {
+    if (check.status === "ok")
+        return "OK";
+    return check.status === "mismatch" ? "MISMATCH" : "NOT_VERIFIABLE";
+}
+export function verifyReportFileContent(file, expect) {
+    const check = checkReportIntegrity(file);
+    const lines = [check.reasonDe];
+    let status = statusOfCheck(check);
+    const sha = file.integrity?.payloadSha256 ?? null;
+    if (status === "OK" && expect !== undefined && expect.toLowerCase() !== sha) {
+        status = "MISMATCH";
+        lines.unshift(`Die Datei stimmt zwar mit ihrer eigenen Prüfsumme überein, die Prüfsumme ist aber nicht die erwartete: erwartet ${expect.toLowerCase()}, in der Datei ${sha ?? "—"}. Datei und Prüfsumme wurden gemeinsam ausgetauscht oder die falsche Datei liegt vor.`);
+    }
+    return { status, kind: "report", sha256: sha, lines };
+}
+export function verifyDossierContent(text, options = {}) {
+    const extracted = extractDossierSeal(text);
+    if ("error" in extracted) {
+        return {
+            status: "NOT_VERIFIABLE",
+            kind: "dossier",
+            sha256: null,
+            lines: [
+                extracted.error === "missing"
+                    ? "Kein Prüfsummen-Siegel gefunden: Das Dossier stammt aus Harness < 0.11.1 (Siegel erst ab 0.11.1) oder das Siegel wurde entfernt. Nicht prüfbar."
+                    : "Das Prüfsummen-Siegel am Ende des Dossiers ist beschädigt und lässt sich nicht lesen. Nicht prüfbar.",
+            ],
+        };
+    }
+    const { seal } = extracted;
+    const recomputed = sha256Hex(canonicalJson(seal.core));
+    const lines = [];
+    if (recomputed !== seal.sha256) {
+        return {
+            status: "MISMATCH",
+            kind: "dossier",
+            sha256: seal.sha256,
+            lines: ["Die Prüfsumme des Dossiers stimmt nicht zu seinem eingebetteten Kern: Kern (Urteil, Score, Namen, Lizenzstatus ...) oder Prüfsumme wurden nach dem Erzeugen verändert."],
+        };
+    }
+    // Der sichtbare Kopf muss dem gesiegelten Kern entsprechen.
+    const header = seal.core.header;
+    if (!header || typeof header !== "object" || !Array.isArray(header.rows) || !Array.isArray(header.notes)) {
+        return { status: "NOT_VERIFIABLE", kind: "dossier", sha256: seal.sha256, lines: ["Das Siegel enthält den sichtbaren Kopf nicht (Dossier aus einer Vorabfassung von 0.11.1). Nicht prüfbar."] };
+    }
+    const isHtml = /<html[\s>]/i.test(text.slice(0, 2000));
+    const expected = dossierHeaderChecks(seal.core)[isHtml ? "html" : "md"];
+    // Gezählt wird im sichtbaren Teil vor dem Siegel (das JSON des Siegels wiederholt Teile des Kopfes).
+    const sealAt = text.lastIndexOf(`<!-- ${DOSSIER_SEAL_MARKER} `);
+    const visible = sealAt === -1 ? text : text.slice(0, sealAt);
+    const missing = expected.filter((check) => countOf(visible, check.needle) !== 1 || (check.prefix !== undefined && countOf(visible, check.prefix) !== 1));
+    if (missing.length > 0) {
+        return {
+            status: "MISMATCH",
+            kind: "dossier",
+            sha256: seal.sha256,
+            lines: [
+                `Der sichtbare Kopf des Dossiers weicht vom gesiegelten Kern ab (${missing.length} von ${expected.length} Angaben fehlen, sind verändert oder doppelt: Kopfzeilen, Datum, Version, Urteil, Score oder die Hinweise unter dem Urteil wurden im Text verändert).`,
+            ],
+        };
+    }
+    if (options.expect !== undefined && options.expect.toLowerCase() !== seal.sha256) {
+        return {
+            status: "MISMATCH",
+            kind: "dossier",
+            sha256: seal.sha256,
+            lines: [`Das Dossier ist in sich stimmig, seine Prüfsumme ist aber nicht die erwartete: erwartet ${options.expect.toLowerCase()}, im Dossier ${seal.sha256}.`],
+        };
+    }
+    const source = seal.core.reportFile;
+    if (source.check !== "ok") {
+        lines.push(source.check === "mismatch"
+            ? "Das Dossier ist unverändert, wurde aber aus einer Report-Datei erzeugt, die ihre eigene Prüfsumme nicht bestand: Urteil und Score sind nicht belastbar."
+            : "Das Dossier ist unverändert, wurde aber aus einer Report-Datei erzeugt, deren Prüfsumme nicht prüfbar war (fehlend oder aus Harness < 0.11.1): Das Urteil war schon beim Erzeugen ungeprüft.");
+        return { status: source.check === "mismatch" ? "MISMATCH" : "NOT_VERIFIABLE", kind: "dossier", sha256: seal.sha256, lines };
+    }
+    lines.push("Siegel, Kern und sichtbarer Kopf (Titelzeile, alle Kopfzeilen, Urteil, Score und die Hinweise unter dem Urteil) stimmen überein. Der Fliesstext der Abschnitte 1 bis 6 ist nicht gesiegelt und wurde nicht geprüft.");
+    if (options.report) {
+        const reportCheck = checkReportIntegrity(options.report);
+        if (reportCheck.status !== "ok") {
+            return { status: reportCheck.status === "mismatch" ? "MISMATCH" : "NOT_VERIFIABLE", kind: "dossier", sha256: seal.sha256, lines: [`Die angegebene Report-Datei besteht ihre Prüfung nicht: ${reportCheck.reasonDe}`] };
+        }
+        if (options.report.integrity?.payloadSha256 !== source.payloadSha256) {
+            return {
+                status: "MISMATCH",
+                kind: "dossier",
+                sha256: seal.sha256,
+                lines: ["Die angegebene Report-Datei ist nicht die, aus der das Dossier erzeugt wurde (ihre Prüfsumme weicht von der im Dossier festgehaltenen ab)."],
+            };
+        }
+        lines.push("Die angegebene Report-Datei gehört zu diesem Dossier und ist unverändert. Der Fliesstext des Dossiers wurde dabei nicht gegen die Report-Datei abgeglichen.");
+    }
+    else {
+        lines.push("Die Report-Datei wurde nicht mitgeprüft; mit --report <datei> abgleichen.");
+    }
+    lines.push("Das ist eine Prüfsumme ohne Signatur eines Dritten: Sie schützt nur, wenn ihr Wert getrennt aufbewahrt wird (--expect <sha256>).");
+    return { status: "OK", kind: "dossier", sha256: seal.sha256, lines };
+}
+async function readText(path) {
+    const info = await stat(path).catch(() => null);
+    if (!info || !info.isFile())
+        return { error: `Datei nicht gefunden: ${path}` };
+    if (info.size > MAX_BYTES)
+        return { error: `Datei zu gross (${info.size} Byte, höchstens ${MAX_BYTES}): ${path}` };
+    return { text: await readFile(path, "utf8") };
+}
+function looksLikeReportFile(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value) && ("harnessVersion" in value || "report" in value || "integrity" in value);
+}
+export async function runVerifyMode(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        process.stdout.write(HELP);
+        return 0;
+    }
+    let file;
+    let reportPath;
+    let expect;
+    for (let i = 0; i < argv.length; i++) {
+        const token = argv[i];
+        const eq = token.indexOf("=");
+        const name = token.startsWith("--") && eq !== -1 ? token.slice(0, eq) : token;
+        if (name === "--report" || name === "--expect") {
+            const v = token.startsWith("--") && eq !== -1 ? token.slice(eq + 1) : argv[++i];
+            if (v === undefined || v.trim() === "" || v.startsWith("--")) {
+                process.stderr.write(`Error: ${name} needs a value.\n${USAGE}`);
+                return 1;
+            }
+            if (name === "--report")
+                reportPath = v;
+            else {
+                if (!/^[0-9a-fA-F]{64}$/.test(v.trim())) {
+                    process.stderr.write(`Error: --expect needs a SHA-256 (64 hex characters).\n${USAGE}`);
+                    return 1;
+                }
+                expect = v.trim();
+            }
+        }
+        else if (token.startsWith("--")) {
+            process.stderr.write(`Error: unknown option ${name}\n${USAGE}`);
+            return 1;
+        }
+        else if (file === undefined) {
+            file = token;
+        }
+        else {
+            process.stderr.write(`Error: unexpected argument ${token}\n${USAGE}`);
+            return 1;
+        }
+    }
+    if (file === undefined) {
+        process.stderr.write(`Error: verify needs a dossier or report file.\n${USAGE}`);
+        return 1;
+    }
+    const read = await readText(file);
+    if ("error" in read) {
+        process.stderr.write(`Error: ${read.error}\n`);
+        return 1;
+    }
+    let reportFile;
+    if (reportPath !== undefined) {
+        const r = await readText(reportPath);
+        if ("error" in r) {
+            process.stderr.write(`Error: ${r.error}\n`);
+            return 1;
+        }
+        try {
+            const parsed = JSON.parse(r.text);
+            if (!looksLikeReportFile(parsed))
+                throw new Error("not a report");
+            reportFile = parsed;
+        }
+        catch {
+            process.stderr.write(`Error: ${reportPath} is not a report file written by the proxy (--report-file).\n`);
+            return 1;
+        }
+    }
+    let result;
+    let parsed;
+    let isJson = true;
+    try {
+        parsed = JSON.parse(read.text);
+    }
+    catch {
+        isJson = false;
+    }
+    if (isJson) {
+        if (!looksLikeReportFile(parsed)) {
+            process.stderr.write(`Error: ${file} is JSON, but not a report written by the proxy (--report-file).\n`);
+            return 1;
+        }
+        if (reportFile !== undefined) {
+            process.stderr.write("Error: --report only applies when verifying a dossier.\n");
+            return 1;
+        }
+        result = verifyReportFileContent(parsed, expect);
+    }
+    else {
+        result = verifyDossierContent(read.text, { report: reportFile, expect });
+    }
+    const label = result.status === "NOT_VERIFIABLE" ? "NICHT PRÜFBAR" : result.status;
+    const what = result.kind === "report" ? "Report-Datei" : "Dossier";
+    process.stdout.write(`${label}  ${what} ${file}\n`);
+    for (const line of result.lines)
+        process.stdout.write(`${line}\n`);
+    if (result.sha256)
+        process.stdout.write(`Prüfsumme (SHA-256): ${result.sha256}\n`);
+    return result.status === "OK" ? 0 : 1;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cuonztech-agent-harness",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "mcpName": "io.github.cuonztech/agent-harness",
   "description": "Chaos-Proxy für MCP-Server: injiziert F1-F5-Fehlerszenarien (Ghost-Write nach Timeout, 429, defektes JSON, Duplicate Dispatch, 500) vor einem echten Upstream-MCP-Server und prüft, ob ein Agent Schreibvorgänge doppelt ausführt. Mit Resilience Score und System-Prompt-Patches für beobachtetes Fehlverhalten.",
   "type": "module",

package/server.json

@@ -6,12 +6,12 @@
     "url": "https://github.com/cuonztech/agent-harness",
     "source": "github"
   },
-  "version": "0.11.0",
+  "version": "0.11.1",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "cuonztech-agent-harness",
-      "version": "0.11.0",
+      "version": "0.11.1",
       "transport": {
         "type": "stdio"
       }