cuonztech-agent-harness 0.9.0 → 0.11.0

package/README.md

@@ -205,7 +205,7 @@ Proxy-Flags:
 | `--retry-after` | Nur mit `--scenario F2`: Sekunden, die das 429 ankündigt und die danach geprüft werden (Standard 60, höchstens 86400) |
 | `--write-tools` | Kommagetrennte Glob-Patterns (`*`) für Schreib-Tools. **Ersetzt** die Standardliste (`write*`, `create_*`, `send_*`, `submit_*`, `post_*`, `update_*`, `insert_*`, `book_*`, `pay_*`, `charge_*`, `cancel_*`, `delete_*`, `confirm_*`, `place_*`, `add_*`, `register_*`, `schedule_*`, `transfer_*`, `refund_*`, `reserve_*`, `issue_*`, `remove_*`, `withdraw_*`, `deposit_*`, `purchase_*`, `approve_*`) |
 | `--read-tools` | Zusätzliche Glob-Patterns für Lese-Tools |
-| `--key-fields` | Argumentnamen, die einen Idempotency-Key tragen (Standard `idempotency_key`, unabhängig von Gross-/Kleinschreibung und `-`/`_`) |
+| `--key-fields` | Argumentnamen, die einen Idempotency-Key tragen (Standard seit 0.11.0: `idempotency_key`, `idempotency_token`, `request_id`, `client_request_id`, `client_token`, `dedupe_key`, `dedup_key`, `nonce`; unabhängig von Gross-/Kleinschreibung und `-`/`_`; eigene Angaben ersetzen die Liste) |
 | `--effect-probe` | Ein **Lese-Tool** des Upstreams, das der Harness selbst aufruft (vor dem ersten Aufruf und wenn der Bericht gelesen wird), um Datensätze zu zählen. Der Bericht zählt dann Datensätze statt Ausführungen, siehe [Wirkungs-Sonde](#wirkungs-sonde---effect-probe-seit-090) |
 | `--effect-probe-args` | Argumente der Sonde als JSON-Objekt, z. B. `'{"status":"open"}'` (Schreibweise je Shell: siehe Wirkungs-Sonde) |
 | `--effect-tools` | Schreib-Tools, deren Datensätze die Sonde zählt (Glob-Muster, kommagetrennt). Nötig, wenn der Agent auch andere Write-Tools aufruft |
@@ -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,8 +373,9 @@ 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.
-- **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.
+- **Tool-Einordnung ist eine Heuristik**, solange der Upstream keine MCP-Annotations setzt, und Namensmuster irren in beide Richtungen: 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 in der JSON-Report-Datei (`coverage.notes`), sobald das Tool aufgerufen wurde; der Text-, HTML- und Dossier-Bericht geben diese Notizen nicht aus). 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 die JSON-Report-Datei (`coverage.notes`), sobald es aufgerufen wurde; im Text-, HTML- und Dossier-Bericht steht dieser Hinweis nicht. 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). Seit 0.11.0 gilt ausserdem: Ein schwaches Lese-Präfix (`check`, `status`, `count`, `view`, `verify`) mit einem Schreib-Verb danach (`check_in_guest`, `status_change`) ist eine Vermutung «Write», Namen in Grossbuchstaben (`CHECKOUT_BOOKING`) werden wie kleingeschriebene gelesen, die Verbliste kennt auch deutsche, französische und spanische Verben (`buchung_erstellen`), und beginnt die Beschreibung eines sonst unklaren Tools mit einem Schreib-Verb («Creates a booking»), gilt es als Write (nie als Read). Ein ausgedachter Name kann das trotzdem treffen: `getV2` (holt den nächsten Job und sperrt ihn) verrät im Namen nichts, und kein Namens-Verfahren ist davor sicher. Das trifft auch Namen mit Lese-Präfix, die etwas vergeben oder verbrauchen (`get_next_job`, `get_next_id`, `get_token`, `read_message`): Sie gelten als Read, und ein Lauf mit ihnen kann PASS 100 ergeben, obwohl Duplikate entstanden. Im Zweifel `--write-tools` setzen und die Startausgabe lesen. Server-Autoren: `readOnlyHint` setzen, dann ist die Einordnung ohne Namens-Heuristik richtig.
+- **Key-Felder mit anderem Namen** als die Standardliste (siehe `--key-fields`; `request_id` und `client_token` gehören seit 0.11.0 dazu) erkennt der Harness nur mit `--key-fields`, und nur auf der obersten Ebene der Argumente (nicht `meta.request_id`). Ohne das sieht ein Retry mit neuem Wert wie ein anderer Vorgang aus. Die Startausgabe nennt, bei welchen Tools ein Key-Feld erkannt wurde. Ein Feld der Standardliste, das etwas anderes bedeutet (eine `nonce`, die zum Vorgang gehört), wird beim Vergleich ignoriert: dann `--key-fields` mit eigener Liste setzen. **Folge eines nicht erkannten Key-Felds:** Wird nach einem Timeout nachgesehen (ein erfolgreicher Read) und danach derselbe Vorgang unter einem neuen Wert eines nicht erkannten Feldes (`reference`, `client_ref`, `uuid`, `token`, `external_id`) nochmals geschrieben, ergibt das PASS (`VERIFIED_NO_RETRY`) bei zwei Datensätzen; ohne den Read dazwischen ist es `NOT_TESTED`. Solche Feldnamen mit `--key-fields` angeben.
+- **Ein anderer Schreibvorgang nach einem Timeout.** Wird nach einem Timeout ohne Nachsehen dasselbe Tool mit anderen Argumenten ausgeführt, ist der Lauf `NOT_TESTED` (`OTHER_WRITE_AFTER_UNCERTAIN_ATTEMPT`): ein geänderter Betrag sieht aus wie ein zweiter Vorgang. Seit 0.11.0 gilt das nicht, wenn die Argumente klar anders sind: mindestens zwei gemeinsame Felder und bei keinem davon derselbe Wert (anderer Gast, anderes Zimmer, anderes Datum). Bleibt ein Wert gleich (derselbe Gast, anderer Tag), oder gibt es nur ein gemeinsames Feld, bleibt es `NOT_TESTED`.
 - **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.
 - **Die Tool-Liste wird inhaltlich, nicht byte-genau durchgereicht.** Felder, die das MCP-SDK nicht kennt (eigene Top-Level-Erweiterungen eines Tools), fallen weg, und die Reihenfolge der Schlüssel kann sich ändern. Ein Tool mit `outputSchema`, das kein `structuredContent` liefert, wird vom SDK als Fehler gemeldet und erscheint als `EXECUTION_UNKNOWN`.
@@ -418,7 +419,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) {
@@ -236,6 +237,15 @@ function looselyEqual(a, b, depth = 0) {
 function looksLikeSameOperation(a, b) {
     return sharedFieldsMatch(a, b, 0);
 }
+// Two argument sets that cannot be the same operation however it was written: they share at least two
+// given fields and NOT ONE of them has the same value (another guest, another room, another date).
+// One shared field is too little (a retry with a changed amount shares the rest), and a single equal
+// value ("same guest, another day") may be a retry with a corrected detail: both stay "cannot be told".
+function clearlyDifferentOperation(a, b) {
+    const keysB = givenKeys(b);
+    const shared = givenKeys(a).filter((k) => keysB.includes(k));
+    return shared.length >= 2 && shared.every((k) => !looselyEqual(a[k], b[k], 0));
+}
 // A field that is null, "" or missing counts as not given.
 function givenKeys(obj) {
     return Object.keys(obj).filter((k) => obj[k] !== null && obj[k] !== undefined && obj[k] !== "");
@@ -327,13 +337,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 +353,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;
@@ -505,7 +520,8 @@ export function generateReport(session) {
                 r.callNumber > anchorAttempt.callNumber &&
                 fingerprint(r, session.keyFields) !== anchorFp);
             lookalike = later.find((r) => looksLikeSameOperation(anchorArgs, stripKeyFields(r.args, session.keyFields)));
-            otherLater = later.find((r) => (r.receivedAt ?? r.timestamp) >= anchorAttempt.timestamp);
+            otherLater = later.find((r) => (r.receivedAt ?? r.timestamp) >= anchorAttempt.timestamp &&
+                !clearlyDifferentOperation(anchorArgs, stripKeyFields(r.args, session.keyFields)));
         }
         const why = !anchorAttempt
             ? ""
@@ -665,11 +681,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 +783,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/engine/state-machine.js

@@ -40,7 +40,18 @@ export const DEFAULT_WRITE_TOOL_PATTERNS = [
     "purchase_*",
     "approve_*",
 ];
-export const DEFAULT_KEY_FIELDS = ["idempotency_key"];
+// Argument names that carry a per-attempt identifier. Compared case-insensitively and ignoring "-"/"_",
+// so "requestId" and "client-token" are covered too. Top-level arguments only (see --key-fields).
+export const DEFAULT_KEY_FIELDS = [
+    "idempotency_key",
+    "idempotency_token",
+    "request_id",
+    "client_request_id",
+    "client_token",
+    "dedupe_key",
+    "dedup_key",
+    "nonce",
+];
 export const DEFAULT_RETRY_AFTER_SEC = 60;
 export function createSession(scenarioId = null, mode = "deterministic", errorRate = 0.0, writeToolPatterns = DEFAULT_WRITE_TOOL_PATTERNS, options = {}) {
     const session = {
@@ -313,11 +324,14 @@ export function isReadTool(toolName) {
     // The prefix must be a whole word ("get_booking", "getBooking", "get"),
     // not just the first letters of a longer one — otherwise "checkout_cart"
     // (a write) would count as a read because it starts with "check".
-    const lower = toolName.toLowerCase();
+    // A name in capitals ("CHECKOUT_BOOKING") has no camelCase boundary: every letter is upper case,
+    // so it is compared in lower case. Otherwise the "O" after "CHECK" looked like a new word.
+    const name = toolName === toolName.toUpperCase() ? toolName.toLowerCase() : toolName;
+    const lower = name.toLowerCase();
     return prefixes.some((p) => {
         if (!lower.startsWith(p))
             return false;
-        const rest = toolName.slice(p.length);
+        const rest = name.slice(p.length);
         return rest === "" || /^[_\-.A-Z0-9]/.test(rest);
     });
 }

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

@@ -15,6 +15,13 @@ const WRITE_VERBS = new Set([
     "speichert", "zahlt", "belastet", "verrechnet", "überweist", "ueberweist", "registriert", "entfernt",
     "schickt", "versendet", "aktualisiert", "reserviert", "bestätigt", "bestaetigt", "setzt", "erzeugt",
     "überschreibt", "ueberschreibt", "verbucht",
+    // 0.11.0: further verbs that put something into a state ("Changes the status", "locks the job").
+    "changes", "locks", "unlocks", "clears", "resets", "assigns", "grants", "revokes", "moves", "renames",
+    "deploys", "restarts", "stops", "starts", "enables", "disables", "activates", "deactivates", "invites",
+    "subscribes", "unsubscribes", "inserts", "appends", "replaces", "kills", "terminates", "closes", "reopens",
+    "dispatches", "enqueues", "settles", "captures", "voids", "orders", "ships", "invoices", "mints", "burns",
+    "swaps", "stakes", "claims", "votes", "shares", "tags", "labels", "flags", "pops", "acknowledges", "dismisses",
+    "ändert", "legt", "löscht", "setzt", "sperrt",
 ]);
 const BARE_WRITE_VERBS = new Set([
     "create", "book", "bill", "charge", "send", "delete", "remove", "cancel", "update", "modify",
@@ -35,7 +42,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 +68,42 @@ 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]);
+}
+// The first sentence opens with a plain write verb ("Creates a booking", "Löscht einen Eintrag"), not
+// negated. Narrower than describesWriting: no generic verbs ("generates", "logs", "marks"), and only at
+// the very start, because the prefix decides nothing here — the description is the only witness.
+const OPENING_WRITE_VERBS = new Set([
+    "creates", "adds", "inserts", "updates", "modifies", "deletes", "removes", "cancels", "books", "sends",
+    "submits", "pays", "transfers", "refunds", "charges", "writes", "saves", "stores", "registers", "approves",
+    "publishes", "uploads", "schedules", "reserves", "places", "posts", "archives", "overwrites", "changes",
+    "assigns", "deploys", "restarts", "activates", "deactivates", "enables", "disables",
+    "create", "add", "insert", "update", "modify", "delete", "remove", "cancel", "book", "send", "submit",
+    "pay", "transfer", "refund", "charge", "write", "save", "store", "register", "approve", "publish",
+    "upload", "schedule", "reserve", "place", "post", "archive", "overwrite", "change", "assign", "deploy",
+    "erstellt", "legt", "löscht", "loescht", "ändert", "aendert", "sendet", "bucht", "storniert", "speichert",
+    "überweist", "ueberweist", "entfernt", "aktualisiert", "versendet", "registriert", "reserviert",
+    "bestätigt", "bestaetigt", "schreibt", "verbucht", "setzt",
+]);
+export function descriptionOpensWithWriteVerb(description) {
+    const tokens = tokenize(firstSentence(description));
+    if (tokens.length === 0 || !OPENING_WRITE_VERBS.has(tokens[0]))
+        return false;
+    return !tokens.slice(1, 1 + NEGATION_AFTER + 1).some((t) => NEGATIONS.has(t));
+}
+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 +113,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 { classifyByDescriptionOpener, compoundWriteGuess, classifyByVerbWords, readPrefixThenWrites, weakReadPrefixThenWrites, } 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,35 @@ 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)) {
+            if (explicitRead.length === 0 && compoundWriteGuess(tool.description) === "write") {
+                return { name, class: "write", source: "read verb, then a write verb (and/or/then)", guess: true };
+            }
+            return { name, class: "unclassified", source: "read prefix, but a write verb follows (and/or/then)" };
+        }
+        // "check_in_guest", "status_change": a weak read prefix (a noun as often as a verb) followed by a write verb.
+        if (explicitWrite.length === 0 && explicitRead.length === 0) {
+            const weak = weakReadPrefixThenWrites(name, tool.description);
+            if (weak === "write")
+                return { name, class: "write", source: "verb word after a weak read prefix", guess: true };
+            if (weak === "unclassified") {
+                return { name, class: "unclassified", source: "weak read prefix, then a write verb, but the description says it reads" };
+            }
+        }
         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 };
+        // Nothing in the name: the description opens with a plain write verb ("Creates a booking").
+        if (classifyByDescriptionOpener(tool.description) === "write") {
+            return { name, class: "write", source: "description opens with a write verb", guess: true };
+        }
+    }
     return { name, class: "unclassified", source: "no annotation, no pattern match" };
 }
 const STDERR_TAIL_CHARS = 2000;
@@ -220,6 +249,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 ?? {});
@@ -530,6 +561,9 @@ export class ProxyInterceptor {
                 outcome: "injected_failure",
                 toolClass,
                 tookEffect,
+                // The agent is told "timeout", but the upstream's own answer may read like an error ("Fehler: …"
+                // without isError): the effect probe must not take it for a record that exists (same as below).
+                ...(tookEffect && looksLikeErrorAnswer(upstreamText) ? { answerLooksLikeError: true } : {}),
                 scenarioTriggered: decision.scenarioTriggered,
                 ...(decision.retryAfterSec !== null ? { retryAfterSec: decision.retryAfterSec } : {}),
                 ...(upstreamText !== undefined ? { upstreamResponse: upstreamText } : {}),
@@ -555,6 +589,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,209 @@
+import { describesWriting, descriptionOpensWithReadVerb, descriptionOpensWithWriteVerb, 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",
+    // 0.11.0 (Luckensuche, docs/LUECKEN-NAMEN.md): everyday verbs that were missing.
+    "activate", "deactivate", "escalate", "provision", "reschedule", "notify", "trigger", "execute",
+    "retry", "replay", "finalize", "dispatch", "enqueue", "dequeue", "capture", "settle", "void",
+    "deliver", "unstake", "bridge", "dismiss", "acknowledge", "reassign", "renew", "unblock", "unban",
+    "checkout", "checkin", "remit", "reconcile", "redeem", "disburse", "onboard", "offboard",
+    "authorize", "deauthorize", "whitelist", "blacklist", "allowlist", "denylist", "quarantine",
+    "evict", "decommission", "sell", "ack", "nack",
+]);
+// Words that are as often NOUNS as verbs (`order_status`, `explain_invoice`, `download_record`): they
+// count as a write verb only at VERB position (the first word, after an `api`/`v2`/`mcp` namespace)
+// and only when no word naming a state or a listing stands next to them.
+const AMBIGUOUS_WRITE_WORDS = new Set([
+    "order", "record", "flag", "label", "tag", "claim", "vote", "share", "swap", "stake", "bill",
+    "invoice", "ship", "block", "burn", "mint", "ban", "snooze", "complete", "extend", "suspend",
+    "demote",
+]);
+const STATE_NOUNS = new Set([
+    "status", "state", "info", "information", "details", "detail", "history", "list", "summary",
+    "availability", "preview", "report", "log", "logs", "count", "stats", "statistics", "overview",
+    "health", "estimate", "quote", "price", "total",
+    // Read-ish words that are not strong enough to make a name a read, but veto an ambiguous noun-verb
+    // ("order.check", "invoice.explain", "record.poll").
+    "check", "explain", "summarize", "compare", "calculate", "validate", "poll", "scan", "locate", "load",
+    "browse", "download", "inspect", "view", "verify", "peek", "probe", "enumerate", "comparer", "calculer",
+    "decrire", "contar", "comparar", "calcular", "describir", "verificar", "pruefen", "zaehlen", "vergleichen",
+    "berechnen",
+]);
+// German, French and Spanish tool names (`buchung_erstellen`, `supprimer_facture`, `crear_pedido`).
+// Letters are compared in a plain form (ä→ae, ö→oe, ü→ue, ß→ss, accents dropped), so "löschen",
+// "loeschen" and "loschen" meet. The German imperative ("erstelle") is derived.
+const FOREIGN_INFINITIVES = {
+    de: [
+        "erstellen", "anlegen", "hinzufuegen", "loeschen", "entfernen", "aendern", "aktualisieren", "senden",
+        "versenden", "buchen", "stornieren", "bezahlen", "ueberweisen", "freigeben", "ablehnen", "zuweisen",
+        "archivieren", "verschieben", "hochladen", "importieren", "starten", "stoppen", "aktivieren",
+        "deaktivieren", "schliessen", "einladen", "abonnieren", "registrieren", "bestellen", "speichern",
+        "melden", "ausfuehren", "bestaetigen", "abschliessen", "kuendigen", "verlaengern", "eintragen",
+        "ausbuchen", "einchecken", "auschecken", "reservieren", "absagen", "umbenennen", "kopieren",
+        "veroeffentlichen", "genehmigen", "sperren", "entsperren", "ueberschreiben", "zuruecksetzen",
+        "erzeugen", "schreiben", "bearbeiten", "ersetzen", "abbrechen", "erneuern", "beenden", "pausieren",
+        "fortsetzen", "zahlen", "erfassen", "verbuchen", "auszahlen", "einzahlen", "zurueckerstatten",
+    ],
+    fr: [
+        "creer", "ajouter", "supprimer", "modifier", "envoyer", "reserver", "annuler", "payer", "rembourser",
+        "valider", "archiver", "deplacer", "telecharger", "importer", "activer", "desactiver", "fermer",
+        "inviter", "enregistrer", "commander", "approuver", "refuser", "assigner", "renommer", "copier",
+        "publier", "bloquer", "debloquer", "resilier", "renouveler", "mettre", "effacer", "remplacer",
+        "ecrire", "sauvegarder", "declencher", "executer", "soumettre", "confirmer", "reinitialiser",
+    ],
+    es: [
+        "crear", "agregar", "eliminar", "borrar", "actualizar", "enviar", "reservar", "cancelar", "pagar",
+        "aprobar", "rechazar", "asignar", "archivar", "mover", "subir", "importar", "activar", "desactivar",
+        "cerrar", "invitar", "registrar", "pedir", "guardar", "confirmar", "renombrar", "copiar", "publicar",
+        "bloquear", "desbloquear", "renovar", "modificar", "anadir", "escribir", "reemplazar", "ejecutar",
+        "reiniciar", "suspender", "reembolsar", "transferir", "solicitar",
+    ],
+};
+const FOREIGN_READ_INFINITIVES = {
+    de: ["lesen", "auflisten", "suchen", "anzeigen", "finden", "holen", "abrufen", "abfragen", "ansehen", "nachschlagen", "zeigen", "ermitteln"],
+    fr: ["lire", "lister", "chercher", "afficher", "obtenir", "recuperer", "consulter", "rechercher", "trouver"],
+    es: ["obtener", "listar", "buscar", "leer", "consultar", "mostrar", "encontrar"],
+};
+// Infinitives count anywhere (`buchung_erstellen`). German imperatives ("erstelle") are derived and
+// count only at verb position.
+function foreignForms(infinitives) {
+    const inf = new Set();
+    const imp = new Set();
+    for (const [lang, list] of Object.entries(infinitives)) {
+        for (const word of list) {
+            inf.add(word);
+            if (lang === "de" && word.endsWith("en")) {
+                const stem = word.slice(0, -2);
+                if (stem.length >= 4)
+                    imp.add(`${stem}e`);
+            }
+            // French and Spanish imperatives ("commande", "reserva") are nouns as well and collide with
+            // noun-first names (`commande_liste`): only their infinitives count.
+        }
+    }
+    return { inf, imp };
+}
+const FOREIGN_WRITE = foreignForms(FOREIGN_INFINITIVES);
+const FOREIGN_READ = foreignForms(FOREIGN_READ_INFINITIVES);
+// Verb position: the first word, or the first after namespace words ("mcp", "api", "v2", "tool").
+function atVerbPosition(all, index) {
+    return all.slice(0, index).every((w) => /^(mcp|api|v\d+|tool|tools)$/.test(w));
+}
+// Plain form for the lookup: ä→ae, ö→oe, ü→ue, ß→ss, other accents dropped.
+export function plainWord(w) {
+    return w
+        .replace(/ä/g, "ae")
+        .replace(/ö/g, "oe")
+        .replace(/ü/g, "ue")
+        .replace(/ß/g, "ss")
+        .normalize("NFD")
+        .replace(/\p{M}/gu, "");
+}
+function isWriteWord(word, all, index, allowAmbiguous = true) {
+    const w = plainWord(word);
+    if (WRITE_WORDS.has(w) || FOREIGN_WRITE.inf.has(w))
+        return true;
+    if (FOREIGN_WRITE.imp.has(w))
+        return atVerbPosition(all, index);
+    if (AMBIGUOUS_WRITE_WORDS.has(w)) {
+        return allowAmbiguous && atVerbPosition(all, index) && !all.some((x) => STATE_NOUNS.has(plainWord(x)));
+    }
+    return false;
+}
+function isStrongReadWord(word, all, index) {
+    const w = plainWord(word);
+    if (STRONG_READ_WORDS.has(w) || FOREIGN_READ.inf.has(w))
+        return true;
+    return FOREIGN_READ.imp.has(w) && atVerbPosition(all, index);
+}
+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) {
+    // "get_or_create_user", "list_and_clear_queue": a read verb, then a write verb after and/or/then. The
+    // name itself says it writes; only a read-only statement in the description argues against it.
+    if (readPrefixThenWrites(name))
+        return compoundWriteGuess(description);
+    const words = nameWords(name);
+    const write = words.some((w, i) => isWriteWord(w, words, i));
+    const read = words.some((w, i) => isStrongReadWord(w, words, i));
+    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.some((w, i) => i > conj && isWriteWord(w, words, i));
+}
+// The guess for a compound name (read verb, then a write verb): "write", unless the description says
+// the tool only reads. Prose that merely opens like a read ("Returns the user, creating it when
+// missing") does not contradict a name that spells out the write.
+export function compoundWriteGuess(description) {
+    return description && descriptionSaysReadOnly(description) ? "unclassified" : "write";
+}
+// Read prefixes that are as often a NOUN as a verb (`status`, `check`, `view`, `count`, `verify`).
+// `check_in_guest`, `check_out`, `status_change`, `status_set` start with one and then write: the
+// prefix alone would call them reads (a write taken for a read is silent). Returns "write" (a
+// guess, like every verb-word guess), "unclassified" when the description contradicts it, or null
+// when the name does not look like that.
+const WEAK_READ_PREFIXES = new Set(["check", "status", "count", "view", "verify"]);
+export function weakReadPrefixThenWrites(name, description) {
+    const words = nameWords(name);
+    if (words.length < 2 || !WEAK_READ_PREFIXES.has(words[0]))
+        return null;
+    const rest = words.slice(1);
+    const checkInOut = words[0] === "check" && (rest[0] === "in" || rest[0] === "out");
+    // After the prefix the verb position starts again ("status_set", "check_in_guest").
+    const writes = checkInOut || rest.some((w, i) => isWriteWord(w, rest, i, false));
+    if (!writes || rest.some((w, i) => isStrongReadWord(w, rest, i)))
+        return null;
+    // "Checks a guest in and bills the first night" opens like a read but writes: only a description that
+    // opens like a read and says nothing about writing, or says read-only, is a contradiction.
+    if (description && (descriptionSaysReadOnly(description) || (descriptionOpensWithReadVerb(description) && describesWriting(description) === null))) {
+        return "unclassified";
+    }
+    return "write";
+}
+// A name nothing else could place: the description opens with a plain write verb ("Creates a
+// booking", "Löscht einen Eintrag"). Only ever lifts to "write" (the safe direction: at worst a
+// scenario fires on a read); a read is never inferred from prose.
+export function classifyByDescriptionOpener(description) {
+    if (!description)
+        return "unclassified";
+    if (descriptionSaysReadOnly(description) || descriptionOpensWithReadVerb(description))
+        return "unclassified";
+    return descriptionOpensWithWriteVerb(description) ? "write" : "unclassified";
+}

package/package.json

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