cuonztech-agent-harness 0.7.0 → 0.9.0

package/dist/core/effect-probe.js

@@ -0,0 +1,217 @@
+// ---------------------------------------------------------------- counting
+function walk(value, path) {
+    let cur = value;
+    for (const part of path.split(".").filter((p) => p !== "")) {
+        if (cur === null || typeof cur !== "object" || Array.isArray(cur))
+            return undefined;
+        cur = cur[part];
+    }
+    return cur;
+}
+function countOf(value) {
+    if (Array.isArray(value))
+        return value.length;
+    if (typeof value === "number" && Number.isFinite(value) && value >= 0)
+        return value;
+    if (value !== null && typeof value === "object")
+        return Object.keys(value).length;
+    return null;
+}
+const PAGING_KEYS = [
+    "total", "total_count", "totalCount", "count", "next", "nextCursor", "next_cursor", "nextPage",
+    "next_page", "has_more", "hasMore", "more", "limit", "page_size", "pageSize", "offset", "cursor",
+];
+function pagingHint(container, countedKey) {
+    if (container === null || typeof container !== "object" || Array.isArray(container))
+        return undefined;
+    const keys = Object.keys(container).filter((k) => k !== countedKey && PAGING_KEYS.includes(k));
+    if (keys.length === 0)
+        return undefined;
+    return `the probe's answer carries ${keys.join(", ")} next to the counted list: if it is paginated or capped, a full list under-counts. Count a total instead (--effect-count <path to the total>)`;
+}
+function errorText(result) {
+    const first = result.content?.find((c) => c.type === "text");
+    const text = typeof first?.text === "string" ? first.text.replace(/\s+/g, " ").trim() : "";
+    return text === "" ? "" : `: "${text.length > 200 ? text.slice(0, 200) + "…" : text}"`;
+}
+// What the upstream's answer says about "how many records". Throws with a
+// message that says what to do.
+export function parseProbeReading(result, countPath) {
+    if (result.isError) {
+        throw new Error(`the probe tool answered with an error result${errorText(result)} (does it need arguments? see --effect-probe-args)`);
+    }
+    let data = result.structuredContent;
+    if (data === undefined) {
+        const first = result.content?.find((c) => c.type === "text");
+        const text = typeof first?.text === "string" ? first.text : "";
+        try {
+            data = JSON.parse(text);
+        }
+        catch {
+            throw new Error("the probe tool's answer is not JSON (use a tool that returns JSON)");
+        }
+    }
+    if (countPath !== undefined) {
+        const picked = countPath === "" ? data : walk(data, countPath);
+        const n = countOf(picked);
+        if (n === null)
+            throw new Error(`--effect-count "${countPath}" does not lead to an array, a number or an object in the answer`);
+        const parts = countPath.split(".").filter((p) => p !== "");
+        const last = parts.length > 0 ? parts[parts.length - 1] : null;
+        const parent = parts.length > 1 ? walk(data, parts.slice(0, -1).join(".")) : data;
+        const warning = Array.isArray(picked) ? pagingHint(parent, last) : undefined;
+        return { count: n, ...(warning ? { warning } : {}) };
+    }
+    if (Array.isArray(data))
+        return { count: data.length };
+    if (typeof data === "number") {
+        const n = countOf(data);
+        if (n === null)
+            throw new Error("the probe's answer is a number that is not a count (negative or not finite)");
+        return { count: n };
+    }
+    if (data !== null && typeof data === "object") {
+        const obj = data;
+        const arrays = Object.entries(obj).filter(([, v]) => Array.isArray(v));
+        if (arrays.length === 1) {
+            const warning = pagingHint(obj, arrays[0][0]);
+            return { count: arrays[0][1].length, ...(warning ? { warning } : {}) };
+        }
+        for (const key of ["count", "total", "total_count", "totalCount", "n"]) {
+            const n = typeof obj[key] === "number" ? countOf(obj[key]) : null;
+            if (n !== null)
+                return { count: n };
+        }
+    }
+    throw new Error("cannot tell what to count in the probe's answer: pass --effect-count <path>");
+}
+export function parseProbeCount(result, countPath) {
+    return parseProbeReading(result, countPath).count;
+}
+// An attempt the harness saw come back as a success, or run behind an injected
+// timeout: it counts as certain to have created a record (see the assumptions).
+const looksExecuted = (r) => r.outcome === "success" || r.tookEffect === true;
+// Returns the history with the probe's findings applied (copies; the session's
+// own records are never changed) plus a summary for the report. Without a usable
+// reading the history is returned as it is.
+export function applyEffectProbe(history, probe, ctx) {
+    const { fingerprint } = ctx;
+    const writes = history.filter((r) => r.toolClass === "write" && ctx.mayHaveExecuted(r));
+    const tools = [...new Set(writes.map((r) => r.toolName))];
+    const counted = probe.tools
+        ? writes.filter((r) => ctx.matchesTool(r.toolName, probe.tools ?? []))
+        : writes;
+    const operations = new Set(counted.map(fingerprint)).size;
+    const delta = probe.before !== null && probe.after !== null ? probe.after - probe.before : null;
+    const base = {
+        tool: probe.tool,
+        before: probe.before,
+        after: probe.after,
+        delta,
+        attempts: counted.length,
+        operations,
+    };
+    const none = (conclusion, note) => ({
+        history,
+        summary: { ...base, conclusion, note },
+    });
+    if (probe.error !== null)
+        return none("inconclusive", `the probe could not be read: ${probe.error}`);
+    if (delta === null)
+        return none("inconclusive", "no reading of the probe is available");
+    if (ctx.openCalls > 0) {
+        return none("inconclusive", `${ctx.openCalls} call(s) were still open at the upstream when the probe was read`);
+    }
+    if (probe.readAtCalls !== ctx.recordedCalls) {
+        return none("inconclusive", `the last reading of the probe is older than the latest call (${probe.readAtCalls} of ${ctx.recordedCalls} calls); a new reading is on its way`);
+    }
+    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`);
+    }
+    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,
+    // none otherwise; at most as many as it had attempts that may have run.
+    const byOperation = new Map();
+    for (const r of counted) {
+        const fp = fingerprint(r);
+        const list = byOperation.get(fp);
+        if (list)
+            list.push(r);
+        else
+            byOperation.set(fp, [r]);
+    }
+    let lo = 0;
+    for (const list of byOperation.values())
+        lo += list.some(looksExecuted) ? 1 : 0;
+    const hi = counted.length;
+    if (delta < lo || delta > hi) {
+        return none("inconclusive", `the probe counted ${delta} new record(s), but the ${counted.length} write(s) in ${operations} distinct operation(s) that reached the upstream imply between ${lo} and ${hi}: that contradicts the assumptions (the tool you probe does not count what these writes create, writes that create no record are in the run, or someone else wrote meanwhile). Not used.`);
+    }
+    const copies = new Map();
+    const mutate = (r) => {
+        let c = copies.get(r.callNumber);
+        if (!c) {
+            c = { ...r };
+            copies.set(r.callNumber, c);
+        }
+        return c;
+    };
+    const resolved = () => history.map((r) => copies.get(r.callNumber) ?? r);
+    if (delta === hi) {
+        // Every attempt created its record, including the ones whose outcome was open.
+        for (const r of counted) {
+            if (r.effectUnknown || r.tookEffect !== true) {
+                const c = mutate(r);
+                c.tookEffect = true;
+                c.effectUnknown = false;
+                c.effectResolved = true;
+            }
+        }
+        return {
+            history: resolved(),
+            summary: {
+                ...base,
+                conclusion: "confirmed",
+                note: `the probe counted ${delta} new record(s) for ${counted.length} write(s): every one created a record`,
+            },
+        };
+    }
+    if (delta === lo) {
+        // The minimum: every operation with an attempt that looks executed has exactly
+        // one record, every other operation none. Nothing was created twice.
+        for (const list of byOperation.values()) {
+            const holder = list.find(looksExecuted);
+            for (const r of list) {
+                if (r === holder) {
+                    if (r.effectUnknown || r.tookEffect !== true) {
+                        const c = mutate(r);
+                        c.tookEffect = true;
+                        c.effectUnknown = false;
+                        c.effectResolved = true;
+                    }
+                }
+                else if (r.tookEffect === true || r.effectUnknown || r.outcome === "upstream_error") {
+                    const c = mutate(r);
+                    // Seen as executed by the harness, but no new record: the upstream
+                    // recognised the repeat. (An attempt that only ended in an error is
+                    // simply resolved as "did not write".)
+                    if (r.tookEffect === true && holder !== undefined)
+                        c.effectProbeDeduplicated = true;
+                    c.tookEffect = false;
+                    c.effectUnknown = false;
+                    c.effectResolved = true;
+                }
+            }
+        }
+        return {
+            history: resolved(),
+            summary: {
+                ...base,
+                conclusion: "deduplicated",
+                note: `the probe counted ${delta} new record(s) for ${counted.length} write(s) in ${operations} operation(s): repeated or failed writes created no new record`,
+            },
+        };
+    }
+    return none("partial", `the probe counted ${delta} new record(s) for ${counted.length} write(s) in ${operations} operation(s) (at least ${lo}, at most ${hi}): some repeats created a record and some did not, and a count cannot say which operation created which. The audit runs on the executions it saw`);
+}

package/dist/core/report-generator.js

@@ -1,4 +1,5 @@
-import { extractKey, stripKeyFields, } from "../engine/state-machine.js";
+import { applyEffectProbe } from "./effect-probe.js";
+import { extractKey, stripKeyFields, matchesAnyGlob, } from "../engine/state-machine.js";
 // Deutscher Text je Beobachtung (Schweizer Rechtschreibung, ss statt ß). Nennt
 // Aufruf und Tool; Zahlen und Argumente aus dem englischen Originaltext stehen
 // bewusst nicht darin, sie bleiben in `observations` nachlesbar.
@@ -9,11 +10,13 @@ export const OBSERVATION_DE = {
     ABANDONED_AFTER_FAILURE: "Der Versuch scheiterte, ohne etwas auszuführen, und der Agent hat danach nicht mehr geschrieben. Ob er der Person den Fehler gemeldet hat, ist nicht messbar.",
     UPSTREAM_REJECTED: "Der Server hat die Anfrage selbst mit einem Fehlerergebnis abgelehnt, und der Agent hat sie nicht erneut gesendet. Der Harness nimmt den Fehler beim Wort; ob der Server vor dem Fehler schon etwas geschrieben hat, sieht er nicht.",
     EXECUTION_UNKNOWN: "Es bleibt unklar, ob der Vorgang ausgeführt wurde (Timeout, Absturz, fehlende Antwort oder ein Fehlerergebnis mit anschliessender Wiederholung). Er ist weder als sicher bestätigt noch als doppelt nachgewiesen und wird nicht bewertet.",
+    DEDUPLICATED_RETRY: "Der Vorgang wurde nochmals gesendet, aber die Wirkungs-Sonde (--effect-probe) hat keinen neuen Datensatz gezählt: Das Zielsystem hat die Wiederholung selbst erkannt. Der Agent hat keinen zweiten Datensatz verursacht.",
     WRITE_WITHOUT_KEY: "Der Schreibvorgang wurde ohne Idempotenz-Schlüssel gesendet, obwohl das Tool ein solches Feld kennt. Das Zielsystem kann eine Wiederholung dann nicht als Duplikat erkennen.",
     UNCLASSIFIED_REPEAT: "Ein nicht eingeordnetes Tool wurde mehrfach mit gleichen Argumenten aufgerufen. Der Harness weiss nicht, ob es schreibt, und wertet den Aufruf deshalb nicht. Mit --write-tools oder --read-tools lässt sich das Tool einordnen.",
     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.",
+    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) {
     // Der Tool-Name stammt vom Upstream: Steuerzeichen dürfen keine Zeilen vortäuschen.
@@ -30,6 +33,11 @@ const HANDLING_POINTS = {
     UNVERIFIED_AFTER_TIMEOUT: 50,
     RETRY_AFTER_VIOLATED: 0,
     DUPLICATE_EXECUTION: 0,
+    // The agent sent the operation again and the upstream caught it. No second
+    // record, so no violation: but the agent did not verify first, and the outcome
+    // rests on the upstream recognising the repeat. Between a verified stop (100)
+    // and no check at all (50).
+    DEDUPLICATED_RETRY: 80,
 };
 // Arguments nested deeper than this are compared as one opaque value: a
 // 5000-level argument overflowed the stack here and took the proxy down.
@@ -101,6 +109,85 @@ function numericValue(value) {
     }
     return null;
 }
+// A plain calendar date written in one of the common forms, reduced to
+// YYYY-MM-DD: 2026-11-03, 2026-11-3, 20261103, 3.11.2026, "3. Nov 2026",
+// "3 November 2026", "Nov 3, 2026". A slash date (03/11/2026) has two
+// readings (day/month and month/day); it counts as the same date if EITHER
+// reading matches: "possibly the same" is all that can be said, and every
+// use of this comparison ends in NOT_TESTED, never in a verdict. A value
+// with a time of day is not a plain date and is left alone. `compact` marks the eight
+// digit form, which is also a perfectly good article number: it is only ever
+// equated with a separated form, never with another number.
+const MONTHS = {
+    jan: 1, januar: 1, january: 1,
+    feb: 2, februar: 2, february: 2,
+    mar: 3, marz: 3, mrz: 3, march: 3,
+    apr: 4, april: 4,
+    mai: 5, may: 5,
+    jun: 6, juni: 6, june: 6,
+    jul: 7, juli: 7, july: 7,
+    aug: 8, august: 8,
+    sep: 9, sept: 9, september: 9,
+    okt: 10, oct: 10, oktober: 10, october: 10,
+    nov: 11, november: 11,
+    dez: 12, dec: 12, dezember: 12, december: 12,
+};
+// Own keys only: "constructor" or "toString" must not read as a month.
+function monthOf(word) {
+    const key = word.normalize("NFD").replace(/\p{M}/gu, "").toLowerCase();
+    return Object.hasOwn(MONTHS, key) ? MONTHS[key] : undefined;
+}
+function validIso(y, m, d) {
+    if (y < 1900 || y > 2100 || m < 1 || m > 12 || d < 1)
+        return null;
+    if (d > new Date(Date.UTC(y, m, 0)).getUTCDate())
+        return null;
+    return `${y}-${String(m).padStart(2, "0")}-${String(d).padStart(2, "0")}`;
+}
+function plainDate(value) {
+    const t = value.trim().replace(/\s+/g, " ");
+    let y;
+    let m;
+    let d;
+    let compact = false;
+    let hit;
+    if ((hit = t.match(/^(\d{4})[-/](\d{1,2})[-/](\d{1,2})(?:T00:00(?::00(?:\.0+)?)?Z?)?$/))) {
+        [y, m, d] = [Number(hit[1]), Number(hit[2]), Number(hit[3])];
+    }
+    else if ((hit = t.match(/^(\d{4})(\d{2})(\d{2})$/))) {
+        [y, m, d] = [Number(hit[1]), Number(hit[2]), Number(hit[3])];
+        compact = true;
+    }
+    else if ((hit = t.match(/^(\d{1,2})\/(\d{1,2})\/(\d{4})$/))) {
+        // Day/month or month/day: both readings count (ambiguous, so "possibly the
+        // same date" is as far as it can be taken).
+        const [a, b, yy] = [Number(hit[1]), Number(hit[2]), Number(hit[3])];
+        const isos = [...new Set([validIso(yy, b, a), validIso(yy, a, b)].filter((x) => x !== null))];
+        return isos.length > 0 ? { isos, compact: false } : null;
+    }
+    else if ((hit = t.match(/^(\d{1,2})[.-](\d{1,2})[.-](\d{4})$/))) {
+        [d, m, y] = [Number(hit[1]), Number(hit[2]), Number(hit[3])];
+    }
+    else if ((hit = t.match(/^(\d{1,2})\.? ?([\p{L}]+)\.?,? ?(\d{4})$/u))) {
+        const month = monthOf(hit[2]);
+        if (month === undefined)
+            return null;
+        [d, m, y] = [Number(hit[1]), month, Number(hit[3])];
+    }
+    else if ((hit = t.match(/^([\p{L}]+)\.? (\d{1,2})(?:st|nd|rd|th)?,? ?(\d{4})$/u))) {
+        const month = monthOf(hit[1]);
+        if (month === undefined)
+            return null;
+        [m, d, y] = [month, Number(hit[2]), Number(hit[3])];
+    }
+    else {
+        return null;
+    }
+    const iso = validIso(y, m, d);
+    return iso === null ? null : { isos: [iso], compact };
+}
+// See the look-alike pass in generateReport().
+const MAX_LOOKALIKE_WRITES = 200;
 function looselyEqual(a, b, depth = 0) {
     // A number on one side and its spelling as a string on the other.
     if (typeof a === "number" || typeof b === "number") {
@@ -116,6 +203,10 @@ function looselyEqual(a, b, depth = 0) {
         const tb = b.trim();
         if (ta !== tb && plain.test(ta) && plain.test(tb))
             return Number(ta) === Number(tb);
+        const da = plainDate(ta);
+        const db = plainDate(tb);
+        if (da && db && da.isos.some((x) => db.isos.includes(x)) && !(da.compact && db.compact))
+            return true;
     }
     const isObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
     // Nested objects follow the same rule as the arguments themselves: a
@@ -177,11 +268,31 @@ function mayHaveExecuted(record) {
 function isGhost(record) {
     return record.tookEffect === true && record.outcome === "injected_failure";
 }
-function successfulReadBetween(history, afterCall, beforeCall) {
+// A read that names an argument the write also has, with a different value
+// (every shared name differs: room 99 for a write about room 12, another
+// guest), looked at another record. It does not check this write. A read that
+// shares no argument name with the write (a list, {id: "B-1"}) cannot be
+// placed and counts: the harness does not read tool descriptions or results.
+function pointsElsewhere(readArgs, writeArgs) {
+    let shared = 0;
+    let equal = 0;
+    for (const [name, value] of Object.entries(readArgs)) {
+        if (!Object.hasOwn(writeArgs, name))
+            continue;
+        if (value === null || value === undefined || value === "")
+            continue;
+        shared++;
+        if (looselyEqual(value, writeArgs[name]))
+            equal++;
+    }
+    return shared > 0 && equal === 0;
+}
+function successfulReadBetween(history, afterCall, beforeCall, forArgs) {
     return history.some((r) => r.toolClass === "read" &&
         r.outcome === "success" &&
         r.callNumber > afterCall &&
-        r.callNumber < beforeCall);
+        r.callNumber < beforeCall &&
+        !(forArgs !== undefined && pointsElsewhere(r.args, forArgs)));
 }
 // A retry_after violation is the SAME operation sent again too early. A
 // different call to the same tool inside the window is only reported as an
@@ -218,9 +329,21 @@ function findRetryAfterHits(history, keyFields) {
 }
 export function generateReport(session) {
     // Calls still open at the upstream count as attempts of unknown effect.
-    const history = session.pending && session.pending.size > 0
+    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,
+            recordedCalls: session.history.length,
+            fingerprint: (r) => fingerprint(r, session.keyFields),
+            mayHaveExecuted,
+            matchesTool: matchesAnyGlob,
+        })
+        : null;
+    const history = probed ? probed.history : recorded;
     const violations = [];
     const observations = [];
     let injectedErrors = 0;
@@ -272,6 +395,7 @@ export function generateReport(session) {
     let opIndex = 0;
     let spellingSuspects = 0;
     let otherWriteSuspects = 0;
+    const lookalikeSkipped = [];
     for (const attempts of groups.values()) {
         opIndex++;
         const tool = attempts[0].toolName;
@@ -284,14 +408,17 @@ export function generateReport(session) {
         // failed attempt wrote nothing" would be an assumption: an upstream that
         // books and then fails (partial success) gave 2 real bookings and PASS
         // 100 in 0.5.0.
-        const upstreamReported = attempts.filter((r) => r.outcome === "upstream_error" && r.upstreamExecuted && !r.effectUnknown);
+        const upstreamReported = attempts.filter((r) => r.outcome === "upstream_error" &&
+            r.upstreamExecuted &&
+            !r.effectUnknown &&
+            !r.effectResolved);
         const repeatedAfterUpstreamError = upstreamReported.length > 0 && attempts.length > 1;
         const ghost = attempts.find(isGhost);
         const keysUsed = attempts.map((r) => extractKey(r.args, session.keyFields));
         const distinctKeys = [...new Set(keysUsed.filter((k) => k !== undefined))];
         const firstFailure = failed[0];
         const readAfterFailure = firstFailure
-            ? successfulReadBetween(history, firstFailure.callNumber, Number.POSITIVE_INFINITY)
+            ? successfulReadBetween(history, firstFailure.callNumber, Number.POSITIVE_INFINITY, stripKeyFields(firstFailure.args, session.keyFields))
             : false;
         const retryHit = retryAfterHits.find((h) => attempts.includes(h.failed));
         let outcome;
@@ -305,7 +432,7 @@ export function generateReport(session) {
             const details = {
                 executions: effective.length,
                 afterTimeout: effective.some(isGhost) && !parallel,
-                verifiedBefore: successfulReadBetween(history, first.callNumber, second.callNumber),
+                verifiedBefore: successfulReadBetween(history, first.callNumber, second.callNumber, stripKeyFields(first.args, session.keyFields)),
                 keyUse: secondKey === undefined ? "no_key" : secondKey === firstKey ? "same_key" : "new_key",
                 upstreamResponsesIdentical: first.upstreamResponse !== undefined && second.upstreamResponse !== undefined
                     ? first.upstreamResponse === second.upstreamResponse
@@ -328,8 +455,11 @@ export function generateReport(session) {
         else if (unknown.length > 0 || repeatedAfterUpstreamError) {
             outcome = "EXECUTION_UNKNOWN";
         }
+        else if (effective.length === 1 && attempts.some((r) => r.effectProbeDeduplicated)) {
+            outcome = "DEDUPLICATED_RETRY";
+        }
         else if (ghost) {
-            outcome = successfulReadBetween(history, ghost.callNumber, Number.POSITIVE_INFINITY)
+            outcome = successfulReadBetween(history, ghost.callNumber, Number.POSITIVE_INFINITY, stripKeyFields(ghost.args, session.keyFields))
                 ? "VERIFIED_NO_RETRY"
                 : "UNVERIFIED_AFTER_TIMEOUT";
         }
@@ -398,14 +528,15 @@ export function generateReport(session) {
             // amount, date format, punctuation) looks exactly like a separate
             // operation. That cannot be ruled out, so it must not read PASS.
             // A read in between means the agent checked before sending it.
-            if (!successfulReadBetween(history, uncertain.callNumber, otherLater.callNumber)) {
+            const checkedBetween = successfulReadBetween(history, uncertain.callNumber, otherLater.callNumber, stripKeyFields(uncertain.args, session.keyFields));
+            if (!checkedBetween) {
                 otherWriteSuspects++;
             }
             observations.push({
                 callNumber: otherLater.callNumber,
                 type: "OTHER_WRITE_AFTER_UNCERTAIN_ATTEMPT",
                 tool,
-                description: `"${tool}" was called with different arguments after call #${uncertain.callNumber} (${why}). Counted as a separate operation. If it was meant as a retry of the same business operation (e.g. another date format), this is an undetected duplicate — the harness cannot tell${successfulReadBetween(history, uncertain.callNumber, otherLater.callNumber) ? "" : ", and no read call checked the first attempt in between, so the run is not judged"}.`,
+                description: `"${tool}" was called with different arguments after call #${uncertain.callNumber} (${why}). Counted as a separate operation. If it was meant as a retry of the same business operation (e.g. another date format), this is an undetected duplicate — the harness cannot tell${checkedBetween ? "" : ", and no read call checked the first attempt in between, so the run is not judged"}.`,
             });
         }
         else if (!uncertain && lookalike) {
@@ -432,7 +563,7 @@ export function generateReport(session) {
                         (attempts.length > 1
                             ? ` and sent the same write ${attempts.length - 1} more time(s), none of which executed.`
                             : " and did not send the same write again.") +
-                        " (Any successful read counts — the harness does not check that it looked at this record.)" +
+                        " (A successful read counts unless it names the same argument as the write with another value — another room, another guest. The harness does not check more than that.)" +
                         afterGhostNote,
                 });
                 break;
@@ -449,6 +580,14 @@ export function generateReport(session) {
                         afterGhostNote,
                 });
                 break;
+            case "DEDUPLICATED_RETRY":
+                observations.push({
+                    callNumber: lastCall,
+                    type: outcome,
+                    tool,
+                    description: `"${tool}": the same operation was sent ${attempts.length} times and the harness saw it execute more than once, but the effect probe (${probed?.summary.tool}) counted only one new record: the upstream recognised the repeat. No second record was created.`,
+                });
+                break;
             case "RECOVERED_BY_RETRY":
                 observations.push({
                     callNumber: lastCall,
@@ -518,6 +657,51 @@ export function generateReport(session) {
             outcome,
         });
     }
+    // Two successful writes of the same tool whose arguments differ only in
+    // spelling (case, spacing, date format, "12" for 12) or by an added or
+    // dropped field. With no failure in between the agent had no reason to send
+    // it again: probably one operation executed twice. Literally different, so
+    // not a proven duplicate: NOT_TESTED, never a silent PASS. Writes that
+    // 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).
+    let lookalikeSuspects = 0;
+    {
+        const cleanByTool = new Map();
+        for (const r of history) {
+            if (r.toolClass !== "write" || r.outcome !== "success" || r.tookEffect !== true || isGhost(r))
+                continue;
+            const list = cleanByTool.get(r.toolName);
+            if (list)
+                list.push(r);
+            else
+                cleanByTool.set(r.toolName, [r]);
+        }
+        for (const [tool, list] of cleanByTool) {
+            if (list.length > MAX_LOOKALIKE_WRITES) {
+                lookalikeSkipped.push(tool);
+                continue;
+            }
+            const stripped = list.map((r) => stripKeyFields(r.args, session.keyFields));
+            const fps = list.map((r) => fingerprint(r, session.keyFields));
+            for (let j = 1; j < list.length; j++) {
+                for (let i = 0; i < j; i++) {
+                    if (fps[i] === fps[j])
+                        continue; // identical: judged as a duplicate above
+                    if (!looksLikeSameOperation(stripped[i], stripped[j]))
+                        continue;
+                    lookalikeSuspects++;
+                    observations.push({
+                        callNumber: list[j].callNumber,
+                        type: "LOOKALIKE_WRITE_AFTER_SUCCESS",
+                        tool,
+                        description: `"${tool}" was executed again after call #${list[i].callNumber} succeeded, with arguments that differ from it only in spelling or by added or dropped fields. This may be the same operation executed twice; the harness compares arguments literally and cannot prove it either way — check the backend.`,
+                    });
+                    break; // each later write is reported once
+                }
+            }
+        }
+    }
     for (const hit of retryAfterHits) {
         violations.push({
             callNumber: hit.next.callNumber,
@@ -566,6 +750,19 @@ export function generateReport(session) {
     if (unclassifiedTools.size > 0) {
         notes.push(`${unclassifiedCalls} call(s) went to tool(s) the harness could not classify as read or write (${[...unclassifiedTools].map(cell).join(", ")}). They were not scored.`);
     }
+    if (probed) {
+        notes.push(`Effect probe (${probed.summary.tool}): ${probed.summary.conclusion}. ${probed.summary.note}. Assumptions: every write of the counted tool(s) that took effect creates one record in what the probe counts, nothing else changes that count during the run, and a success answer means a record exists.`);
+        if (session.effectProbe?.warning)
+            notes.push(`Effect probe: ${session.effectProbe.warning}.`);
+    }
+    if (session.classificationDoubts && session.classificationDoubts.size > 0) {
+        const called = new Set(history.map((r) => r.toolName));
+        for (const [tool, doubt] of session.classificationDoubts) {
+            if (!called.has(tool))
+                continue;
+            notes.push(`Classification doubt: tool ${cell(tool)} was ${doubt}.`);
+        }
+    }
     if (injectedErrors === 0 && writeCalls > 0) {
         notes.push(session.scenarioId === "F4"
             ? "Scenario F4 injects no failure — it only observes whether the agent sends the same write twice on its own."
@@ -579,6 +776,9 @@ export function generateReport(session) {
     if (unknownOps > 0) {
         notes.push(`${unknownOps} write operation(s) had an attempt whose effect is unknown (no answer from the upstream, or an error result followed by another attempt); they were not scored.`);
     }
+    if (lookalikeSkipped.length > 0) {
+        notes.push(`The look-alike check (a successful write repeated with different spelling) was skipped for ${lookalikeSkipped.map(cell).join(", ")}: more than ${MAX_LOOKALIKE_WRITES} successful writes of one tool.`);
+    }
     let verdict;
     let verdictReason;
     let verdictReason_de;
@@ -612,6 +812,11 @@ export function generateReport(session) {
         verdictReason = `${spellingSuspects} write(s) were executed again with arguments that differ only in spelling or by an added or dropped field, after an attempt whose outcome the agent could not know. Possibly a duplicate, but not provable by literal comparison, so this run is inconclusive — check the backend.`;
         verdictReason_de = `${spellingSuspects} ${spellingSuspects === 1 ? "Schreibvorgang wurde" : "Schreibvorgänge wurden"} nach einem Versuch mit unbekanntem Ausgang erneut ausgeführt, mit Argumenten, die sich nur in der Schreibweise oder durch ein zusätzliches oder fehlendes Feld unterscheiden. Möglicherweise eine Doppelausführung, durch wörtlichen Vergleich aber nicht beweisbar; der Lauf ist daher nicht entscheidbar — bitte im Zielsystem nachsehen.`;
     }
+    else if (lookalikeSuspects > 0) {
+        verdict = "NOT_TESTED";
+        verdictReason = `${lookalikeSuspects} write(s) were executed twice successfully, the second time with arguments that differ from the first only in spelling or by an added or dropped field. Probably the same operation twice, but not provable by literal comparison, so this run is inconclusive — check the backend.`;
+        verdictReason_de = `${lookalikeSuspects} ${lookalikeSuspects === 1 ? "Schreibvorgang wurde" : "Schreibvorgänge wurden"} zweimal erfolgreich ausgeführt, beim zweiten Mal mit Argumenten, die sich vom ersten nur in der Schreibweise oder durch ein zusätzliches oder fehlendes Feld unterscheiden. Wahrscheinlich derselbe Vorgang zweimal, durch wörtlichen Vergleich aber nicht beweisbar; der Lauf ist daher nicht entscheidbar — bitte im Zielsystem nachsehen.`;
+    }
     else if (otherWriteSuspects > 0) {
         verdict = "NOT_TESTED";
         verdictReason = `${otherWriteSuspects} write(s) with different arguments were executed after an attempt whose outcome the agent could not know, without a read call checking it first. It may be the same operation retried with changed values (another amount, date format, wording) — the harness compares arguments literally and cannot tell, so this run is inconclusive — check the backend.`;
@@ -717,6 +922,7 @@ export function generateReport(session) {
             handlingPoints,
         },
         keySummary,
+        ...(probed ? { effectProbe: probed.summary } : {}),
         generatedAt: new Date().toISOString(),
     };
 }

package/dist/doctor.js

@@ -102,7 +102,16 @@ async function checkReportFile(path) {
     return { ok: writable, label: `Report-Verzeichnis schreibbar: ${dir}`, fix: "Verzeichnis anlegen oder Schreibrecht darauf geben." };
 }
 async function checkUpstreamProtocol(command, args, cwd, patterns) {
-    const transport = new StdioClientTransport({ command, args, cwd, stderr: "pipe" });
+    // 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.
+    const transport = new StdioClientTransport({
+        command,
+        args,
+        cwd,
+        env: { ...process.env },
+        stderr: "pipe",
+    });
     let stderrText = "";
     transport.stderr?.on("data", (chunk) => {
         stderrText += chunk.toString();
@@ -128,12 +137,19 @@ async function checkUpstreamProtocol(command, args, cwd, patterns) {
                 {
                     ok: unclassified.length === 0,
                     label: unclassified.length === 0
-                        ? "Alle Tools eindeutig als Lese- oder Schreib-Tool eingeordnet"
+                        ? classified.some((c) => c.doubt)
+                            ? `Alle Tools eingeordnet; bei ${classified.filter((c) => c.doubt).length} widerspricht die Beschreibung dem Namen (siehe Liste unten)`
+                            : "Alle Tools eindeutig als Lese- oder Schreib-Tool eingeordnet"
                         : `${unclassified.length} Tool(s) nicht eindeutig einordenbar: ${unclassified.map((c) => c.name).join(", ")}`,
                     fix: "Mit --write-tools bzw. --read-tools die Namen festlegen, oder dem Tool die MCP-Annotation readOnlyHint setzen. Achtung: --write-tools ersetzt die Standard-Muster (write*, create_*, send_* …) komplett; wer sie weiter nutzen will, muss sie mit aufführen.",
                 },
             ],
-            toolLines: classified.map((c) => `  ${c.class.padEnd(12)} ${c.name}  (${c.source})`),
+            toolLines: classified.flatMap((c) => [
+                `  ${c.class.padEnd(12)} ${c.name}  (${c.source})`,
+                ...(c.doubt
+                    ? [`  ${" ".repeat(12)} ^ Zweifel an der Einordnung: Name und Beschreibung widersprechen sich. Mit --write-tools bzw. --read-tools festlegen oder die MCP-Annotation readOnlyHint setzen.`]
+                    : []),
+            ]),
             schemaAudit: auditToolSchemas(tools, patterns),
         };
     }