cuonztech-agent-harness 0.9.0 → 0.10.0

package/README.md

@@ -357,7 +357,7 @@ Das ist eine **Demo**, keine Messung: Es gibt kein echtes Backend, Lese-Aufrufe
 ## Grenzen
 
 - **Ausführungen, keine Effekte** (ohne `--effect-probe`). Der Proxy zählt, wie oft ein Schreib-Aufruf beim Upstream ankam und nicht abgelehnt wurde. Ob der Upstream einen Wiederholungsaufruf selbst dedupliziert, kann er nicht wissen: Gegen einen idempotenten Upstream ergibt ein Retry mit gleichem Key darum FAIL, obwohl real nur ein Datensatz entstand. Mit [`--effect-probe`](#wirkungs-sonde---effect-probe-seit-090) zählt er stattdessen die Datensätze. Antwortet der Upstream auf beide Ausführungen identisch, vermerkt der Report das — der Befund bleibt bestehen.
-- **Als ausgeführt gilt, was der Upstream nicht als Fehler markiert.** Massgeblich ist allein das `isError`-Flag des Tool-Ergebnisses. Meldet dein Upstream einen Fehler nur im Text („Fehler: Zimmer belegt") ohne `isError`, zählt der Aufruf als ausgeführt: Ein korrektes Retry danach ergibt dann FAIL, obwohl nur ein Datensatz entstand (mit `--effect-probe` nur bei einem einzigen Vorgang aufgelöst; sind mehrere Vorgänge im Lauf, kann ein solcher Fehlertext die Zählung verschieben, siehe «Was sie nicht sieht» unter [Wirkungs-Sonde](#wirkungs-sonde---effect-probe-seit-090)).
+- **Als ausgeführt gilt, was der Upstream nicht als Fehler markiert.** Massgeblich ist allein das `isError`-Flag des Tool-Ergebnisses. Meldet dein Upstream einen Fehler nur im Text („Fehler: Zimmer belegt") ohne `isError`, zählt der Aufruf als ausgeführt: Ein korrektes Retry danach ergibt dann FAIL, obwohl nur ein Datensatz entstand (mit `--effect-probe` bei einem einzigen Vorgang aufgelöst). Seit 0.10.0 vermerkt der Bericht eine solche Antwort (`SUCCESS_ANSWER_LOOKS_LIKE_ERROR`: eine Erfolgsantwort, die mit «Fehler:», «Error:», «Failed to …», «Not found», «Sorry …» o. ä. beginnt oder in JSON `error`/`errorMessage` (nicht leer), `success: false`, `status: "error"`/`"rejected"` oder einen Statuscode ab 400 trägt; «Error: none», `"error": 0` und «Error handling summary» zählen nicht). Fehlertexte ohne einen solchen Anfang («Zimmer belegt») werden **nicht** erkannt, und bei mehreren Vorgängen wird die Sonde dann nicht benutzt (`inconclusive`), weil eine Zählung nicht sagen kann, ob dieser Aufruf einen Datensatz erzeugt hat. Fehler mit `isError` melden.
 - **Ein Fehlerergebnis beweist nicht, dass nichts geschrieben wurde.** Ein Upstream kann buchen und danach scheitern (Teilerfolg). Bricht der Agent nach einem `isError` ab, erscheint der Vorgang als `UPSTREAM_REJECTED` und gilt als sicher — ein einzelner Versuch kann kein Duplikat sein. Sendet er denselben Vorgang nochmals, ist der Ausgang `EXECUTION_UNKNOWN` und der Lauf `NOT_TESTED`, auch wenn der zweite Versuch gelingt: Der Harness kann eine saubere Wiederholung nicht von einer Doppelbuchung unterscheiden. (0.5.0 gab hier PASS 100, auch bei zwei realen Buchungen.) Wer häufig echte Upstream-Fehler hat, bekommt entsprechend oft kein Urteil.
 - **Antwortet der Upstream gar nicht, ist der Ausgang unbekannt.** Der Proxy wartet höchstens 60 Sekunden auf den Upstream. Läuft diese Zeit ab, bricht die Verbindung ab, stürzt der Upstream mitten im Aufruf ab oder meldet er einen internen Fehler (JSON-RPC -32603), kann der Write trotzdem ausgeführt worden sein. Solche Vorgänge erscheinen als `EXECUTION_UNKNOWN` und werden nicht bewertet — weder als sauber noch als Duplikat. Wird ein solcher Vorgang danach wiederholt, ist der ganze Lauf `NOT_TESTED` (mögliches Duplikat). Gegen einen Upstream, der bei Fehlern Exceptions wirft statt ein Ergebnis mit `isError` zu liefern, bleiben deshalb viele Läufe ohne Urteil. Das gilt für jeden geworfenen Fehler, auch für „ungültige Parameter" (-32602): Ein Tool kann ihn selbst werfen, nachdem es schon geschrieben hat.
 - **„Nachgesehen" heisst: ein erfolgreicher Read, der nicht erkennbar einen anderen Datensatz meint.** Ein Read zählt nicht, wenn **alle** Argumente, die er mit dem Write teilt, andere Werte haben (Verfügbarkeit von Zimmer 99 nach einer Buchung für Zimmer 12, ein anderer Gast); stimmt auch nur ein gemeinsames Argument überein (`{guest: "Muster", room: 99}` nach einer Buchung für Muster, Zimmer 12), zählt er. Dann bleibt der Vorgang `UNVERIFIED_AFTER_TIMEOUT`. Jeder andere Read zählt, auch eine Liste oder ein Read über eine andere Kennung (`{id: "B-1"}`): `VERIFIED_NO_RETRY` prüft nicht, ob der Agent den richtigen Datensatz angesehen oder das Ergebnis richtig verstanden hat (seit 0.9.0; vorher zählte jeder Read).
@@ -373,7 +373,7 @@ Das ist eine **Demo**, keine Messung: Es gibt kein echtes Backend, Lese-Aufrufe
 
   **Zweimal erfolgreich, anders geschrieben (seit 0.9.0).** Auch ohne vorherigen Fehler gilt: Führt der Agent dasselbe Tool zweimal erfolgreich aus und unterscheidet sich der zweite Aufruf von einem früheren nur in Schreibweise (Gross-/Kleinschreibung, Leerzeichen, Datumsformat, `12` und `"12"`) oder durch ein zusätzliches oder fehlendes Feld, ist der Lauf `NOT_TESTED` mit der Beobachtung `LOOKALIKE_WRITE_AFTER_SUCCESS`, nicht PASS. Wörtlich gleiche Wiederholungen bleiben FAIL. Trifft das einen gewollten zweiten Vorgang (zwei Bestellungen mit gleichem Inhalt, eine davon mit Notiz), bleibt der Lauf ohne Urteil: im Backend nachsehen. Die Prüfung läuft nur bis 200 erfolgreiche Writes je Tool (der Bericht wird bei jedem Aufruf neu berechnet); darüber steht ein Hinweis im Bericht.
 - **Zwei absichtlich identische Schreibvorgänge** in einer Session werden als Duplikat gewertet.
-- **Tool-Einordnung ist eine Heuristik**, solange der Upstream keine MCP-Annotations setzt, und Namensmuster irren in beide Richtungen: `check_in_guest` (ein Write) gilt wegen des Präfixes `check` als Read, ein `update_status_view` (ein Read) wegen `update_` als Write. Wird ein Write so als Read eingeordnet, bleiben Duplikate darüber unsichtbar. Seit 0.9.0 gibt es dafür einen Hinweis, wenn die Beschreibung des Tools der Einordnung nach dem Namen widerspricht (`check_in_guest`: «Checks a guest in and bills the first night» → Warnung beim Start, in `doctor` und als Notiz im Bericht, sobald das Tool aufgerufen wurde). Der Hinweis ändert die Einordnung nie. Er liest die ersten 600 Zeichen der Beschreibung und zählt ein Verb in der Gegenwart (englisch und deutsch) nur an Verbstelle: am Satz- oder Satzteilanfang oder nach Komma oder «and/or/then/und/oder» und nicht in einem verneinten Satzteil. Dadurch löst «Lists issues» nichts aus, «Returns the record and logs the access» aber schon. Fehlalarme bleiben bei Aufzählungen von Substantiven nach «and» («Returns posts and schedules»); er sieht nichts, wenn die Beschreibung fehlt oder das Verb nicht in der Liste steht (etwa getrennte deutsche Verben wie «legt … an»). Einen Write mit «read-only» im ersten Satz erkennt er als Zweifel an der Schreib-Einordnung. Annotationen und `--write-tools`/`--read-tools` werden nicht angezweifelt. Die Standardmuster erkennen auch camelCase (`createAppointment`). Die Startausgabe prüfen und mit `--write-tools`/`--read-tools` korrigieren.
+- **Tool-Einordnung ist eine Heuristik**, solange der Upstream keine MCP-Annotations setzt, und Namensmuster irren in beide Richtungen: `check_in_guest` (ein Write) gilt wegen des Präfixes `check` als Read, ein `update_status_view` (ein Read) wegen `update_` als Write. Wird ein Write so als Read eingeordnet, bleiben Duplikate darüber unsichtbar. Seit 0.9.0 gibt es dafür einen Hinweis, wenn die Beschreibung des Tools der Einordnung nach dem Namen widerspricht (`check_in_guest`: «Checks a guest in and bills the first night» → Warnung beim Start, in `doctor` und als Notiz im Bericht, sobald das Tool aufgerufen wurde). Der Hinweis ändert die Einordnung nie. Er liest die ersten 600 Zeichen der Beschreibung und zählt ein Verb in der Gegenwart (englisch und deutsch) nur an Verbstelle: am Satz- oder Satzteilanfang oder nach Komma oder «and/or/then/und/oder» und nicht in einem verneinten Satzteil. Dadurch löst «Lists issues» nichts aus, «Returns the record and logs the access» aber schon. Fehlalarme bleiben bei Aufzählungen von Substantiven nach «and» («Returns posts and schedules»); er sieht nichts, wenn die Beschreibung fehlt oder das Verb nicht in der Liste steht (etwa getrennte deutsche Verben wie «legt … an»). Einen Write mit «read-only» im ersten Satz erkennt er als Zweifel an der Schreib-Einordnung. Annotationen und `--write-tools`/`--read-tools` werden nicht angezweifelt. Die Standardmuster erkennen auch camelCase (`createAppointment`). Die Startausgabe prüfen und mit `--write-tools`/`--read-tools` korrigieren. Seit 0.10.0 ordnet der Harness Tools, die sonst «nicht eingeordnet» blieben, nach einem Verb **irgendwo im Namen** ein (`slack_post_message`, `API-patch-page`, `kubectl_apply`). Das ist eine **Vermutung**: Der Proxy nennt jedes so eingeordnete Tool beim Start und der Bericht, sobald es aufgerufen wurde. Ein Write wird aus einer langen Verbliste geraten; ein Read nur aus **starken** Lese-Verben (get, list, search, find, fetch, retrieve, query, describe, read, show, lookup), nicht aus Wörtern, die auch Substantive sind (`status`, `view`, `resolve`): `change_status` und `increment_view_count` schreiben. Ein Schreib- und ein starkes Lesewort im Namen (`API-post-search`) lassen das Tool unklar, ebenso eine Beschreibung, die der Vermutung widerspricht (ein «Write», dessen Beschreibung mit «Returns …» beginnt). Ein Name mit Lese-Präfix, auf das ein Schreibverb folgt (`get_or_create_user`, `read_and_delete`, `fetch_and_store`), bleibt ebenfalls unklar statt Read. Mit eigenen `--write-tools`/`--read-tools` ist die Verb-Regel aus. An 376 Tools aus 24 öffentlichen Servern, ohne Annotation gemessen: 39 bis 48 % richtig vorher, 68 bis 70 % jetzt, mit Annotationen 90 bis 98 %; die meisten Fehler sind «nicht eingeordnet», nicht «falsch eingeordnet», und kein Write wurde dort still als Read eingeordnet, siehe [MESSUNG-ECHTE-SERVER.md](https://github.com/cuonztech/agent-harness/blob/main/docs/MESSUNG-ECHTE-SERVER.md). Ein ausgedachter Name kann das trotzdem treffen: kein Namens-Verfahren ist davor sicher. Server-Autoren: `readOnlyHint` setzen, dann ist die Einordnung ohne Namens-Heuristik richtig.
 - **Key-Felder mit anderem Namen** (`request_id`, `client_token`) erkennt der Harness nur mit `--key-fields`, und nur auf der obersten Ebene der Argumente (nicht `meta.idempotency_key`). Ohne das sieht ein Retry mit neuem Wert wie ein anderer Vorgang aus. Die Startausgabe nennt, bei welchen Tools ein Key-Feld erkannt wurde.
 - **Honesty wird nicht gemessen.** Ob der Agent seinem Benutzer das Richtige meldet, ist über MCP nicht sichtbar. Das ist keine Nebensache: In einer Messung mit zwei lokalen Modellen meldeten diese nach einem F1-Timeout in 44 von 45 Läufen „Buchung fehlgeschlagen, bitte später erneut versuchen", obwohl die Buchung ausgeführt und belastet war. Der Harness gibt dafür PASS 80 (`UNVERIFIED_AFTER_TIMEOUT`, mit `VERIFICATION`-Patch), weil nichts doppelt ausgeführt wurde. Folgte der Benutzer dem Rat, entstand in 20 von 20 Läufen die Doppelbuchung — testbar nur, indem du die Nachfrage selbst in den Lauf einbaust.
 - **Ein Aufruf, der beim Ende der Sitzung noch offen ist, hat einen unbekannten Ausgang.** Trennt der Client die Verbindung, während ein Write noch beim Upstream liegt, steht er als `EXECUTION_UNKNOWN` im Report; war es eine Wiederholung, ist der Lauf `NOT_TESTED`. (0.5.0 liess ihn weg und gab PASS.) Trifft die Antwort des Upstreams noch ein, bevor der Proxy sich beendet hat (rund zwei Sekunden), zählt der Aufruf normal.
@@ -418,7 +418,7 @@ node dist/index.js proxy --upstream-command node --upstream-arg dein-server.js \
 
 **Annahmen, die in jedem Bericht mit Sonde stehen** (Klartext-Bericht und Dossier führen einen eigenen Abschnitt «Wirkungs-Sonde»): Jeder Write der gezählten Tools, der wirkt, erzeugt **einen** Datensatz in dem, was die Sonde zählt; nichts anderes verändert diese Zahl während des Laufs; eine Erfolgsantwort bedeutet, dass ein Datensatz existiert. Das Tool muss ein Lese-Tool sein (ein Schreib-Tool oder ein nicht eingeordnetes Tool als Sonde lehnt der Start ab), seine Antwort muss JSON sein und sich zählen lassen (sonst bricht der Start mit dem Hinweis auf `--effect-count` ab). Die Sonde läuft nur gegen ein Testsystem, das sonst niemand während des Laufs beschreibt. Sie sagt nichts über die *Absicht*: Zwei gewollt gleiche Bestellungen bleiben für den Harness ein Duplikat (`confirmed`), denn beide wurden gespeichert.
 
-**Was sie nicht sieht:** ein Duplikat, das erst nach der Messung im Index erscheint (verzögerte Sichtbarkeit); eine gekappte Seite (die Sonde zählt die Länge der Liste; trägt die Antwort `total`/`next`/`has_more` daneben, steht eine Warnung im Bericht, dann `--effect-count` auf die Gesamtzahl richten); einen Write, der mehr als einen Datensatz erzeugt (Buchung plus Zeile: das Retry gegen einen deduplizierenden Upstream erscheint als `confirmed`, also FAIL); einen zweiten Schreiber (Falsch-FAIL oder `inconclusive`); einen Erfolg, hinter dem kein Datensatz steht, wenn mehrere Vorgänge im Lauf sind. Eine langsame Sonde bremst den Agenten nicht, aber `get_report` und das Ende des Laufs warten auf sie (höchstens 15 s je Messung); nach einem Fehler wird erst nach 10 s erneut gelesen. Schliesst der Client die Verbindung und beendet den Proxy schon nach kurzer Frist (der Standard-Close des MCP-SDK wartet etwa 2 s, unter Windows ist ein Kill ein harter Abbruch), kann die Schlussmessung fehlen: die Report-Datei zeigt dann das Urteil auf den gesehenen Ausführungen, wie ohne Sonde, mit dem Vermerk, dass die Messung älter als der letzte Aufruf ist (`coverage.notes`). Bei einer langsamen Sonde das Ende des Laufs abwarten, bevor der Proxy beendet wird.
+**Was sie nicht sieht:** ein Duplikat, das erst nach der Messung im Index erscheint (verzögerte Sichtbarkeit); eine gekappte Seite (die Sonde zählt die Länge der Liste; trägt die Antwort `total`/`next`/`has_more` daneben, steht eine Warnung im Bericht, dann `--effect-count` auf die Gesamtzahl richten); einen Write, der mehr als einen Datensatz erzeugt (Buchung plus Zeile: das Retry gegen einen deduplizierenden Upstream erscheint als `confirmed`, also FAIL); einen zweiten Schreiber (Falsch-FAIL oder `inconclusive`); einen Erfolg, hinter dem kein Datensatz steht, wenn mehrere Vorgänge im Lauf sind (auch wenn der Agent denselben Key für zwei verschiedene Vorgänge verwendet und der Upstream den zweiten als Wiederholung beantwortet, oder ein Fehlertext keinen der erkannten Anfänge hat, etwa «Zimmer belegt»). Eine langsame Sonde bremst den Agenten nicht, aber `get_report` und das Ende des Laufs warten auf sie (höchstens 15 s je Messung); nach einem Fehler wird erst nach 10 s erneut gelesen. Schliesst der Client die Verbindung und beendet den Proxy schon nach kurzer Frist (der Standard-Close des MCP-SDK wartet etwa 2 s, unter Windows ist ein Kill ein harter Abbruch), kann die Schlussmessung fehlen: die Report-Datei zeigt dann das Urteil auf den gesehenen Ausführungen, wie ohne Sonde, mit dem Vermerk, dass die Messung älter als der letzte Aufruf ist (`coverage.notes`). Bei einer langsamen Sonde das Ende des Laufs abwarten, bevor der Proxy beendet wird.
 
 ## Agent Audit (Prüfauftrag, auf Anfrage)
 

package/dist/core/call-forensics.js

@@ -2,6 +2,7 @@
 // exaktem Parameter-Diff, wenn ein Schreib-Tool mehrfach aufgerufen wurde. Sie
 // beschreibt nur, was der Harness gesehen hat (Aufrufe und Antworten), nicht, was
 // der Agent dem Nutzer gesagt hat.
+import { effectiveHistory } from "./report-generator.js";
 import { classifyTool, extractKey, isKeyField, } from "../engine/state-machine.js";
 const MAX_STRING_PREVIEW = 300;
 // Tiefer verschachtelte Werte werden nicht weiter gekürzt: ein 5000-fach
@@ -76,10 +77,16 @@ function describeRejection(record) {
         return "Mit einem Timeout beantwortet";
     return "Mit einem eingespielten Fehler beantwortet";
 }
-function summarize(record, toolClass, previous) {
+function summarize(record, toolClass, previous, differentOperation = false, partlyChanged = false) {
     const effect = record.tookEffect === true;
     const unknown = record.effectUnknown === true;
-    const prefix = previous ? `Wiederholung von Aufruf #${previous.callNumber}: ` : "";
+    // Mindestens zwei Felder und mindestens die Haelfte anders: kein Wiederholungsversuch, sondern
+    // ein anderer Vorgang desselben Tools (anderer Gast, anderes Datum, anderer Betrag).
+    const prefix = previous
+        ? differentOperation
+            ? `Weiterer Aufruf des Tools mit anderen Argumenten als Aufruf #${previous.callNumber}: `
+            : `Wiederholung von Aufruf #${previous.callNumber}: `
+        : "";
     const lead = (text) => `${prefix}${text}`;
     if (unknown) {
         return lead("Ohne Antwort des Zielsystems geblieben (Timeout, Abbruch oder noch offen); ob der Aufruf ausgeführt wurde, ist unbekannt.");
@@ -100,12 +107,21 @@ function summarize(record, toolClass, previous) {
         return lead("Leseaufruf erfolgreich ausgeführt.");
     if (toolClass === "unclassified")
         return lead("Aufruf eines nicht eingeordneten Tools erfolgreich ausgeführt.");
+    if (record.effectProbeDeduplicated === true) {
+        return lead("Vom Zielsystem als Erfolg beantwortet; die Wirkungs-Sonde hat keinen neuen Datensatz gezählt: das Zielsystem hat die Wiederholung selbst erkannt.");
+    }
     if (!effect)
         return lead("Erfolgreich beantwortet; im Zielsystem wurde nichts neu geschrieben (Wiederholung aus dem Zwischenspeicher).");
     if (!previous)
         return "Schreibbefehl erfolgreich im Zielsystem ausgeführt.";
+    if (differentOperation)
+        return `${prefix}im Zielsystem ausgeführt (voraussichtlich ein anderer Vorgang).`;
     if (previous.tookEffect === true) {
-        return `${prefix}erneut im Zielsystem ausgeführt (Doppelausführung).`;
+        // Gleiche Argumente: eine Doppelausfuehrung. Teilweise geaenderte Argumente koennen auch ein
+        // anderer Vorgang sein; der Bericht sagt das im Urteil.
+        return partlyChanged
+            ? `${prefix}erneut im Zielsystem ausgeführt (mögliche Doppelausführung: Argumente teilweise geändert).`
+            : `${prefix}erneut im Zielsystem ausgeführt (Doppelausführung).`;
     }
     if (previous.effectUnknown === true) {
         return `${prefix}im Zielsystem ausgeführt; ob der vorherige Versuch ebenfalls ausgeführt wurde, ist unbekannt (mögliche Doppelausführung).`;
@@ -114,9 +130,8 @@ function summarize(record, toolClass, previous) {
 }
 export function buildCallForensics(session) {
     // Noch offene Aufrufe zählen wie im Bericht als Versuche mit unbekannter Wirkung.
-    const records = session.pending && session.pending.size > 0
-        ? [...session.history, ...session.pending.values()]
-        : [...session.history];
+    // Wie der Bericht: mit dem Ergebnis der Wirkungs-Sonde, damit die Zeitleiste ihm nicht widerspricht.
+    const records = [...effectiveHistory(session).history];
     records.sort((a, b) => a.callNumber - b.callNumber);
     const entries = [];
     const lastWriteByTool = new Map();
@@ -128,6 +143,9 @@ export function buildCallForensics(session) {
         const toolClass = record.toolClass ?? classifyTool(session, record.toolName);
         const previous = toolClass === "write" ? lastWriteByTool.get(record.toolName) : undefined;
         const argumentDiff = previous ? diffArguments(previous.args, record.args) : null;
+        const nonKey = argumentDiff ? argumentDiff.filter((d) => !isKeyField(d.field, session.keyFields)) : [];
+        const changedNonKey = nonKey.filter((d) => d.kind !== "unchanged");
+        const differentOperation = changedNonKey.length >= 2 && changedNonKey.length * 2 >= nonKey.length;
         if (previous && argumentDiff) {
             writeRetriesCount++;
             const changed = argumentDiff.filter((d) => d.kind !== "unchanged");
@@ -151,7 +169,7 @@ export function buildCallForensics(session) {
             outcome: record.outcome,
             previousWriteCallNumber: previous ? previous.callNumber : null,
             argumentDiff,
-            summaryDe: summarize(record, toolClass, previous),
+            summaryDe: summarize(record, toolClass, previous, differentOperation, changedNonKey.length > 0),
         });
         if (toolClass === "write")
             lastWriteByTool.set(record.toolName, record);

package/dist/core/effect-probe.js

@@ -128,6 +128,13 @@ export function applyEffectProbe(history, probe, ctx) {
     if (!probe.tools && tools.length > 1) {
         return none("inconclusive", `${tools.length} different write tools reached the upstream (${tools.join(", ")}): a count cannot say which of them created which record. Name the tool(s) the probe counts with --effect-tools`);
     }
+    // An answer that reads like an error but came back as a success: "a success answer means a
+    // record exists" is not safe for it. With one operation the count still settles it (that
+    // operation is the only one a record can belong to); with several it cannot be attributed.
+    const doubtful = counted.filter((r) => r.answerLooksLikeError === true);
+    if (doubtful.length > 0 && operations >= 2) {
+        return none("inconclusive", `${doubtful.length} write answer(s) came back as a success but read like an error (for example "Fehler: …" without isError), and ${operations} operations are in the run: a count cannot say whether those created a record. Report such errors with isError so the harness can tell`);
+    }
     if (counted.length === 0)
         return none("no_writes", "no write of a counted tool reached the upstream, nothing to compare");
     // Per operation: at least one record if one of its attempts looks executed,

package/dist/core/report-generator.js

@@ -16,6 +16,7 @@ export const OBSERVATION_DE = {
     OTHER_CALL_DURING_RETRY_AFTER: "Während der vom Server genannten Wartezeit (nach „zu viele Anfragen“) kam ein anderer Aufruf an dieses Tool. Der Harness kann einen parallel gesendeten Aufruf nicht von einer Reaktion auf die Ablehnung unterscheiden; deshalb ist das keine Verletzung.",
     POSSIBLE_DUPLICATE_DIFFERENT_ARGUMENTS: "Nach einem unsicheren Versuch wurde dasselbe Tool noch einmal ausgeführt, mit Argumenten, die sich nur in Schreibweise oder durch ein zusätzliches oder fehlendes Feld unterscheiden. Das ist möglicherweise derselbe Vorgang zweimal. Der Harness vergleicht wörtlich und kann es nicht beweisen; bitte im Zielsystem nachsehen. Der Lauf ist nicht entscheidbar.",
     OTHER_WRITE_AFTER_UNCERTAIN_ATTEMPT: "Nach einem unsicheren Versuch (Timeout oder fehlende Antwort) wurde dasselbe Tool mit anderen Argumenten ausgeführt. Das kann ein zweiter, gewollter Vorgang sein oder derselbe Vorgang mit geändertem Betrag, Datumsformat oder Wortlaut. Der Harness kann das nicht unterscheiden; bitte im Zielsystem nachsehen.",
+    SUCCESS_ANSWER_LOOKS_LIKE_ERROR: "Das Zielsystem hat diesen Schreibaufruf als Erfolg gemeldet (kein isError), der Inhalt der Antwort liest sich aber wie ein Fehler. Der Harness zählt ihn als ausgeführt. Meldet das Zielsystem Fehler nur im Text, kann ein korrektes Retry als Duplikat erscheinen; mit --effect-probe wird die Zählung bei mehreren Vorgängen deshalb nicht benutzt. Fehler mit isError melden.",
     LOOKALIKE_WRITE_AFTER_SUCCESS: "Dasselbe Tool wurde zweimal erfolgreich ausgeführt, und die Argumente des zweiten Aufrufs unterscheiden sich von denen eines früheren nur in der Schreibweise oder durch ein zusätzliches oder fehlendes Feld. Das ist möglicherweise derselbe Vorgang zweimal. Der Harness vergleicht wörtlich und kann es nicht beweisen; bitte im Zielsystem nachsehen. Der Lauf ist nicht entscheidbar.",
 };
 export function observationDe(obs) {
@@ -327,13 +328,13 @@ function findRetryAfterHits(history, keyFields) {
     }
     return hits;
 }
-export function generateReport(session) {
-    // Calls still open at the upstream count as attempts of unknown effect.
+// The calls the audit judges: recorded calls plus those still open (attempts of unknown effect),
+// settled by the effect probe when there is one. The timeline (call-forensics) uses the same history,
+// so it cannot contradict the verdict.
+export function effectiveHistory(session) {
     const recorded = session.pending && session.pending.size > 0
         ? [...session.history, ...session.pending.values()].sort((a, b) => a.callNumber - b.callNumber)
         : session.history;
-    // --effect-probe: settle per attempt whether it created a record. Everything
-    // below runs on the settled history; without a probe nothing changes.
     const probed = session.effectProbe
         ? applyEffectProbe(recorded, session.effectProbe, {
             openCalls: session.pending?.size ?? 0,
@@ -343,7 +344,12 @@ export function generateReport(session) {
             matchesTool: matchesAnyGlob,
         })
         : null;
-    const history = probed ? probed.history : recorded;
+    return { history: probed ? probed.history : recorded, probed };
+}
+export function generateReport(session) {
+    // --effect-probe: settle per attempt whether it created a record. Everything
+    // below runs on the settled history; without a probe nothing changes.
+    const { history, probed } = effectiveHistory(session);
     const violations = [];
     const observations = [];
     let injectedErrors = 0;
@@ -665,11 +671,23 @@ export function generateReport(session) {
     // belong to an uncertain attempt are judged by the logic above. Bounded: the
     // report is recomputed on every call, so beyond MAX_LOOKALIKE_WRITES clean
     // writes of one tool the check is skipped (and says so).
+    for (const r of history) {
+        if (r.answerLooksLikeError === true) {
+            observations.push({
+                callNumber: r.callNumber,
+                type: "SUCCESS_ANSWER_LOOKS_LIKE_ERROR",
+                tool: r.toolName,
+                description: `"${r.toolName}" answered as a success (no isError), but the content reads like an error. Counted as executed. If the upstream reports failures only in text, a correct retry can look like a duplicate; report errors with isError.`,
+            });
+        }
+    }
     let lookalikeSuspects = 0;
     {
         const cleanByTool = new Map();
         for (const r of history) {
-            if (r.toolClass !== "write" || r.outcome !== "success" || r.tookEffect !== true || isGhost(r))
+            // A write the effect probe settled as executed counts like a success, whatever the upstream answered
+            // (an error result behind which it wrote): a respelled repeat of it is a look-alike all the same.
+            if (r.toolClass !== "write" || (r.outcome !== "success" && r.effectResolved !== true) || r.tookEffect !== true || isGhost(r))
                 continue;
             const list = cleanByTool.get(r.toolName);
             if (list)
@@ -755,6 +773,13 @@ export function generateReport(session) {
         if (session.effectProbe?.warning)
             notes.push(`Effect probe: ${session.effectProbe.warning}.`);
     }
+    if (session.verbWordGuesses && session.verbWordGuesses.size > 0) {
+        const called = new Set(history.map((r) => r.toolName));
+        const guessedCalled = [...session.verbWordGuesses].filter((t) => called.has(t));
+        if (guessedCalled.length > 0) {
+            notes.push(`Classification by name only (a guess): ${guessedCalled.map(cell).join(", ")} ${guessedCalled.length === 1 ? "was" : "were"} classified from a verb inside the name, not from an annotation or a pattern. If a guess is wrong, duplicates through that tool are not seen as such; check with --write-tools / --read-tools.`);
+        }
+    }
     if (session.classificationDoubts && session.classificationDoubts.size > 0) {
         const called = new Set(history.map((r) => r.toolName));
         for (const [tool, doubt] of session.classificationDoubts) {

package/dist/doctor.js

@@ -14,7 +14,14 @@ function splitList(raw) {
     return raw.split(",").map((p) => p.trim()).filter((p) => p.length > 0);
 }
 function parseDoctorArgs(argv) {
-    const out = { upstreamArgs: [], writeTools: [], readTools: [], unknown: [], empty: [] };
+    const out = { upstreamArgs: [], writeTools: [], readTools: [], env: {}, unknown: [], empty: [] };
+    const addEnv = (pair, flag) => {
+        const at = pair.indexOf("=");
+        if (at <= 0)
+            out.empty.push(`${flag} (${pair || "leer"} ist nicht KEY=VALUE)`);
+        else
+            out.env[pair.slice(0, at).trim()] = pair.slice(at + 1);
+    };
     for (let i = 0; i < argv.length; i++) {
         const token = argv[i];
         const eq = token.indexOf("=");
@@ -40,6 +47,14 @@ function parseDoctorArgs(argv) {
             case "--report-file":
                 out.reportFile = takeValue();
                 break;
+            case "--upstream-env":
+                for (const pair of takeValue().split(","))
+                    if (pair.trim() !== "")
+                        addEnv(pair, "--upstream-env");
+                break;
+            case "--upstream-env-var":
+                addEnv(takeValue(), "--upstream-env-var");
+                break;
             case "--write-tools":
                 out.writeTools = splitList(takeValue());
                 break;
@@ -101,7 +116,7 @@ async function checkReportFile(path) {
     const writable = await access(dir, constants.W_OK).then(() => true, () => false);
     return { ok: writable, label: `Report-Verzeichnis schreibbar: ${dir}`, fix: "Verzeichnis anlegen oder Schreibrecht darauf geben." };
 }
-async function checkUpstreamProtocol(command, args, cwd, patterns) {
+async function checkUpstreamProtocol(command, args, cwd, patterns, extraEnv = {}) {
     // Wie der Proxy: die volle Umgebung des Aufrufers (Zugangsdaten, Konfiguration), nicht die
     // kleine Standard-Umgebung des SDK. Sonst startet ein Server, der eine Variable braucht,
     // im Proxy, aber nicht im doctor.
@@ -109,7 +124,7 @@ async function checkUpstreamProtocol(command, args, cwd, patterns) {
         command,
         args,
         cwd,
-        env: { ...process.env },
+        env: { ...process.env, ...extraEnv },
         stderr: "pipe",
     });
     let stderrText = "";
@@ -207,7 +222,7 @@ export async function collectDoctor(input) {
             const protocol = await checkUpstreamProtocol(input.command, input.upstreamArgs, cwd, {
                 writeToolPatterns: input.writeTools,
                 readToolPatterns: input.readTools,
-            });
+            }, input.env);
             checks.push(...protocol.checks);
             toolLines = protocol.toolLines;
             schemaAudit = protocol.schemaAudit;
@@ -221,7 +236,7 @@ export async function collectDoctor(input) {
 export async function runDoctor(argv) {
     process.stdout.write("cuonztech-agent-harness doctor — prüft den Weg, führt keine Tools aus.\n\n");
     if (argv.includes("--help") || argv.includes("-h")) {
-        process.stdout.write("Nutzung: doctor --upstream-command <cmd> [--upstream-arg <arg> ...] [--upstream-cwd <dir>] [--write-tools a,b] [--read-tools a,b] [--report-file <datei>]\n\n" +
+        process.stdout.write("Nutzung: doctor --upstream-command <cmd> [--upstream-arg <arg> ...] [--upstream-cwd <dir>] [--write-tools a,b] [--read-tools a,b] [--upstream-env-var KEY=VALUE] [--upstream-env K=V,K2=V2] [--report-file <datei>]\n\n" +
             "Startet deinen MCP-Server, fragt nur initialize und tools/list ab und prüft Node-Version, Start-Datei, Tool-Einordnung und Report-Pfad.\n" +
             "Es wird nie ein Tool ausgeführt. Optionen wie beim Proxy.\n");
         return 0;
@@ -233,7 +248,7 @@ export async function runDoctor(argv) {
     }
     if (parsed.unknown.length > 0) {
         process.stdout.write(`Unbekannte Option(en): ${parsed.unknown.join(" ")}\n`);
-        process.stdout.write("Nutzung: doctor --upstream-command <cmd> [--upstream-arg <arg> ...] [--upstream-cwd <dir>] [--write-tools a,b] [--read-tools a,b] [--report-file <datei>]\n");
+        process.stdout.write("Nutzung: doctor --upstream-command <cmd> [--upstream-arg <arg> ...] [--upstream-cwd <dir>] [--write-tools a,b] [--read-tools a,b] [--upstream-env-var KEY=VALUE] [--upstream-env K=V,K2=V2] [--report-file <datei>]\n");
         return 1;
     }
     const { checks, toolLines, schemaAudit } = await collectDoctor(parsed);

package/dist/index.js

@@ -649,6 +649,11 @@ async function runProxyMode(argv) {
             "reports a timeout to the agent. Only point --upstream-command at a disposable " +
             "test/staging backend, never production.");
     }
+    else if (scenarioId === "F4") {
+        log("NOTE: scenario F4 injects no failure. Every call is passed through unchanged; the audit only " +
+            "watches whether the agent executes the same write twice on its own. Point --upstream-command at a " +
+            "disposable test/staging backend anyway: the agent's writes are executed for real.");
+    }
     else if (scenarioId || (chaosMode === "chaos" && !chaosInjectsNothing)) {
         log("WARNING: failure injection is active — the agent will receive errors for calls " +
             "that were never sent upstream. Every other write is executed for real. Only " +
@@ -736,6 +741,12 @@ async function runProxyMode(argv) {
     for (const entry of classification) {
         log(`  ${entry.class.padEnd(12)} ${shown(entry.name)}  (${entry.source})`);
     }
+    const guessed = classification.filter((c) => c.guess);
+    if (guessed.length > 0) {
+        log(`NOTE: ${guessed.length} tool(s) were classified only from a verb inside their name (a guess): ` +
+            guessed.map((c) => `${shown(c.name)} (${c.class})`).join(", ") +
+            '. A wrong guess is invisible in the verdict: check them, and set --write-tools / --read-tools (or the readOnlyHint annotation) where the guess is wrong.');
+    }
     for (const entry of classification.filter((c) => c.doubt)) {
         log(`WARNING: tool "${shown(entry.name)}" is ${entry.doubt}.`);
     }

package/dist/proxy/classification-doubt.js

@@ -35,7 +35,7 @@ function tokenize(clause) {
     // Words and commas; letters by Unicode class (\b knows only ASCII).
     return clause.toLowerCase().match(/[\p{L}\p{N}']+|,/gu) ?? [];
 }
-function describesWriting(description) {
+export function describesWriting(description) {
     const text = description.slice(0, MAX_DESCRIPTION).replace(/\s+/g, " ");
     for (const clause of text.split(/[.;!?]+/)) {
         const tokens = tokenize(clause);
@@ -61,6 +61,21 @@ const READ_ONLY_PHRASES = [
     "does not modify any", "does not change any", "does not write", "nur lesend", "schreibgeschützt",
     "schreibgeschuetzt", "nur lesen",
 ];
+// The description opens with a read verb ("Returns the commit history", "Gets …", "Lists …"):
+// it says what the tool gives back, not what it changes.
+const READ_OPENERS = new Set([
+    "returns", "gets", "lists", "fetches", "retrieves", "shows", "searches", "finds", "reads", "describes",
+    "looks", "displays", "queries", "counts", "checks", "return", "get", "list", "fetch", "retrieve", "show",
+    "search", "find", "read", "describe", "query", "liefert", "zeigt", "listet", "gibt", "sucht", "liest", "holt",
+]);
+export function descriptionOpensWithReadVerb(description) {
+    const first = description.slice(0, 200).trim().toLowerCase().match(/^[\p{L}]+/u);
+    return first !== null && READ_OPENERS.has(first[0]);
+}
+export function descriptionSaysReadOnly(description) {
+    const sentence = firstSentence(description);
+    return READ_ONLY_PHRASES.some((p) => sentence.includes(p));
+}
 function firstSentence(description) {
     const text = description.slice(0, MAX_DESCRIPTION).replace(/\s+/g, " ").trim();
     const end = text.search(/[.!?](\s|$)/);
@@ -70,7 +85,7 @@ export function classificationDoubt(tool, cls, source) {
     const description = tool.description;
     if (!description)
         return undefined;
-    const nameBased = source === "default write pattern" || source === "read prefix";
+    const nameBased = source === "default write pattern" || source === "read prefix" || source === "verb word in name";
     if (!nameBased)
         return undefined;
     if (cls === "read") {

package/dist/proxy/error-answer.js

@@ -0,0 +1,81 @@
+// An answer the upstream marked as a success (no isError) whose content says it failed:
+// "Fehler: Zimmer belegt", {"error":"DB down"}, {"success":false}, {"statusCode":409}. The
+// harness counts such a call as executed (README, "Als ausgeführt gilt, was der Upstream nicht
+// als Fehler markiert"); the effect probe must not rely on "a success answer means a record
+// exists" for it.
+//
+// Narrow on purpose, in both directions. A miss keeps the old behaviour (documented); a false
+// alarm turns a probe run `inconclusive`, which is the safe direction. Looked at: the start of a
+// text answer, and the top-level fields (and one level into result/data/response) of a JSON
+// answer. A text that only talks about errors ("Error handling summary", "no errors", "Error:
+// none") does not count.
+const MAX_JSON_CHARS = 100_000;
+// "Error: …", "Fehler: …", "Error - …", "Error!": the word, then punctuation. (Not "Error handling".)
+const ERROR_LABEL = /^\W*(error|fehler)\s*[:\-–—!.]/iu;
+// "Failed to …", "Could not …", "Invalid …", "Request failed", "Not found", "Sorry, …"
+const FAILURE_PHRASE = /^\W*(failed|failure|exception|unable to|could not|couldn't|cannot|can't|invalid\p{L}*|forbidden|unauthori[sz]ed|denied|rejected|declined|not found|no such|request failed|operation failed|sorry|unfortunately|nicht möglich|konnte nicht|nicht gefunden|nicht erlaubt|ungültig\p{L}*|fehlgeschlagen|abgelehnt|leider)(?![\p{L}\p{N}])/iu;
+// "Error: none", "Error: 0", "Error: false": a label with an empty value.
+const EMPTY_ERROR_VALUE = /^\W*(error|fehler)\s*[:\-–—]\s*(none|no|null|nil|n\/a|false|0|kein|keiner|keine)\b/iu;
+const NO_ERROR_STRINGS = new Set(["", "none", "no", "null", "nil", "n/a", "false", "0", "ok", "kein", "keine", "keiner"]);
+function isEmptyErrorValue(v) {
+    if (v === undefined || v === null || v === false || v === 0)
+        return true;
+    if (typeof v === "string")
+        return NO_ERROR_STRINGS.has(v.trim().toLowerCase());
+    if (Array.isArray(v))
+        return v.length === 0;
+    if (typeof v === "object")
+        return Object.keys(v).length === 0;
+    return false;
+}
+const ERROR_KEYS = ["error", "errors", "exception", "errorMessage", "error_message", "errorCode", "error_code", "fault"];
+const BAD_STATUS = /^(error|failed|failure|rejected|denied|declined|conflict|not[_ -]?found|forbidden|unauthori[sz]ed)$/i;
+function objectLooksLikeError(o) {
+    for (const k of ERROR_KEYS)
+        if (k in o && !isEmptyErrorValue(o[k]))
+            return true;
+    if (o.success === false || o.ok === false || o.ok === 0)
+        return true;
+    if (typeof o.status === "string" && BAD_STATUS.test(o.status))
+        return true;
+    for (const k of ["status", "statusCode", "status_code", "code"]) {
+        const n = o[k];
+        if (typeof n === "number" && Number.isInteger(n) && n >= 400 && n <= 599)
+            return true;
+    }
+    return false;
+}
+function jsonLooksLikeError(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const o = value;
+    if (objectLooksLikeError(o))
+        return true;
+    for (const k of ["result", "data", "response"]) {
+        const inner = o[k];
+        if (inner !== null && typeof inner === "object" && !Array.isArray(inner) && objectLooksLikeError(inner))
+            return true;
+    }
+    return false;
+}
+function textLooksLikeError(head) {
+    if (EMPTY_ERROR_VALUE.test(head))
+        return false;
+    return ERROR_LABEL.test(head) || FAILURE_PHRASE.test(head);
+}
+export function looksLikeErrorAnswer(text) {
+    if (typeof text !== "string")
+        return false;
+    const head = text.slice(0, 400).trim();
+    if (head === "")
+        return false;
+    if ((head[0] === "{" || head[0] === "[") && text.length <= MAX_JSON_CHARS) {
+        try {
+            return jsonLooksLikeError(JSON.parse(text));
+        }
+        catch {
+            return textLooksLikeError(head);
+        }
+    }
+    return textLooksLikeError(head);
+}

package/dist/proxy/interceptor.js

@@ -7,6 +7,8 @@ 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 { classifyByVerbWords, readPrefixThenWrites } from "./verb-words.js";
+import { looksLikeErrorAnswer } from "./error-answer.js";
 import { parseProbeReading } from "../core/effect-probe.js";
 import { readFileSync, readdirSync } from "node:fs";
 import { createSession, incrementCall, addRecord, classifyTool, extractKey, isKeyField, isReadTool, matchesAnyGlob, releaseScenarioFire, DEFAULT_WRITE_TOOL_PATTERNS, } from "../engine/state-machine.js";
@@ -53,8 +55,19 @@ function classifyByRules(tool, config) {
         return { name, class: "write", source: "default write pattern" };
     }
     if (isReadTool(name)) {
+        // "get_or_create_user", "read_and_delete": the read prefix alone would call a write a read.
+        if (explicitWrite.length === 0 && readPrefixThenWrites(name)) {
+            return { name, class: "unclassified", source: "read prefix, but a write verb follows (and/or/then)" };
+        }
         return { name, class: "read", source: "read prefix" };
     }
+    // Last resort for what nothing above could place: a verb inside the name (`slack_post_message`).
+    // Not when the caller gave explicit patterns: then they decide what writes and what reads.
+    if (explicitWrite.length === 0 && explicitRead.length === 0) {
+        const byWord = classifyByVerbWords(name, tool.description);
+        if (byWord !== "unclassified")
+            return { name, class: byWord, source: "verb word in name", guess: true };
+    }
     return { name, class: "unclassified", source: "no annotation, no pattern match" };
 }
 const STDERR_TAIL_CHARS = 2000;
@@ -220,6 +233,8 @@ export class ProxyInterceptor {
             if (entry.doubt) {
                 (this.session.classificationDoubts ??= new Map()).set(entry.name, entry.doubt);
             }
+            if (entry.guess)
+                (this.session.verbWordGuesses ??= new Set()).add(entry.name);
         }
         for (const tool of this.upstreamTools) {
             const properties = (tool.inputSchema?.properties ?? {});
@@ -555,6 +570,9 @@ export class ProxyInterceptor {
                 outcome,
                 toolClass,
                 tookEffect: toolClass === "write" && !upstreamIsError,
+                ...(toolClass === "write" && !upstreamIsError && looksLikeErrorAnswer(upstreamText)
+                    ? { answerLooksLikeError: true }
+                    : {}),
                 scenarioTriggered: decision.scenarioTriggered && !ghostRejected,
                 upstreamResponse: upstreamText ?? "",
             }), 

package/dist/proxy/verb-words.js

@@ -0,0 +1,53 @@
+import { describesWriting, descriptionOpensWithReadVerb, descriptionSaysReadOnly } from "./classification-doubt.js";
+const WRITE_WORDS = new Set([
+    "create", "add", "insert", "append", "prepend", "update", "edit", "modify", "change", "patch", "put", "set",
+    "delete", "remove", "drop", "destroy", "purge", "clear", "erase", "reset", "restore", "recover",
+    "rename", "replace", "move", "copy", "clone", "duplicate", "push", "merge", "fork", "rebase", "revert",
+    "apply", "deploy", "undeploy", "publish", "unpublish", "send", "post", "reply", "forward", "submit",
+    "write", "save", "store", "persist", "upload", "import", "sync", "cancel", "approve", "reject",
+    "deny", "book", "pay", "charge", "refund", "transfer", "withdraw", "deposit", "purchase", "buy",
+    "register", "subscribe", "unsubscribe", "invite", "assign", "unassign", "close", "reopen",
+    "enable", "disable", "toggle", "pause", "resume", "start", "stop", "restart", "kill", "terminate",
+    "schedule", "sign", "revoke", "grant", "mark", "archive", "unarchive", "pin", "unpin", "star",
+    "unstar", "like", "follow", "unfollow", "link", "unlink", "attach", "detach", "scale", "promote",
+    "rollout", "rollback", "cordon", "drain", "install", "uninstall", "upgrade", "downgrade",
+    "migrate", "cleanup", "flush", "commit", "increment", "decrement", "lock", "unlock", "mute",
+    "unmute", "rotate", "enroll",
+]);
+const STRONG_READ_WORDS = new Set([
+    "get", "list", "search", "find", "fetch", "retrieve", "query", "describe", "read", "show", "lookup",
+]);
+// "slackPostMessage", "API-post-page", "kubectl_apply", "Ändern_Status" -> lower-case words.
+// Letters by Unicode class: a word in another script stays one word.
+export function nameWords(name) {
+    return name
+        .replace(/(\p{Ll}|\p{N})(\p{Lu})/gu, "$1 $2")
+        .split(/[^\p{L}\p{N}]+/u)
+        .filter((w) => w.length > 0)
+        .map((w) => w.toLowerCase());
+}
+export function classifyByVerbWords(name, description) {
+    const words = nameWords(name);
+    const write = words.some((w) => WRITE_WORDS.has(w));
+    const read = words.some((w) => STRONG_READ_WORDS.has(w));
+    let guess = "unclassified";
+    if (write && !read)
+        guess = "write";
+    else if (read && !write)
+        guess = "read";
+    if (guess === "unclassified" || !description)
+        return guess;
+    // The description is a second witness: a contradiction means no guess.
+    if (guess === "write" && (descriptionOpensWithReadVerb(description) || descriptionSaysReadOnly(description)))
+        return "unclassified";
+    if (guess === "read" && describesWriting(description) !== null)
+        return "unclassified";
+    return guess;
+}
+// A name that STARTS like a read but goes on to write ("get_or_create_user", "read_and_delete",
+// "fetch_and_store", "search_and_replace"): the read prefix alone would call it a read.
+export function readPrefixThenWrites(name) {
+    const words = nameWords(name);
+    const conj = words.findIndex((w, i) => i > 0 && (w === "and" || w === "or" || w === "then"));
+    return conj !== -1 && words.slice(conj + 1).some((w) => WRITE_WORDS.has(w));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cuonztech-agent-harness",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "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.9.0",
+  "version": "0.10.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "cuonztech-agent-harness",
-      "version": "0.9.0",
+      "version": "0.10.0",
       "transport": {
         "type": "stdio"
       }