cuonztech-agent-harness 0.10.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 |
@@ -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. 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.
+- **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`.

package/dist/core/report-generator.js

@@ -237,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] !== "");
@@ -511,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
             ? ""

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/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",
@@ -72,6 +79,27 @@ 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));

package/dist/proxy/interceptor.js

@@ -7,7 +7,7 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { VERSION } from "../version.js";
 import { classificationDoubt } from "./classification-doubt.js";
-import { classifyByVerbWords, readPrefixThenWrites } from "./verb-words.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";
@@ -57,8 +57,20 @@ function classifyByRules(tool, config) {
     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`).
@@ -67,6 +79,10 @@ function classifyByRules(tool, config) {
         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" };
 }
@@ -545,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 } : {}),

package/dist/proxy/verb-words.js

@@ -1,4 +1,4 @@
-import { describesWriting, descriptionOpensWithReadVerb, descriptionSaysReadOnly } from "./classification-doubt.js";
+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",
@@ -13,7 +13,120 @@ const WRITE_WORDS = new Set([
     "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",
 ]);
@@ -27,9 +140,13 @@ export function nameWords(name) {
         .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) => WRITE_WORDS.has(w));
-    const read = words.some((w) => STRONG_READ_WORDS.has(w));
+    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";
@@ -49,5 +166,44 @@ export function classifyByVerbWords(name, description) {
 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));
+    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.10.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.10.0",
+  "version": "0.11.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "cuonztech-agent-harness",
-      "version": "0.10.0",
+      "version": "0.11.0",
       "transport": {
         "type": "stdio"
       }