cuonztech-agent-harness 0.5.0 → 0.5.1

package/dist/core/report-generator.js

@@ -10,25 +10,149 @@ const HANDLING_POINTS = {
     RETRY_AFTER_VIOLATED: 0,
     DUPLICATE_EXECUTION: 0,
 };
-function stableStringify(value) {
+// Arguments nested deeper than this are compared as one opaque value: a
+// 5000-level argument overflowed the stack here and took the proxy down.
+const MAX_COMPARE_DEPTH = 64;
+function stableStringify(value, depth = 0) {
+    if (value !== null && typeof value === "object" && depth >= MAX_COMPARE_DEPTH) {
+        // Beyond this depth: the engine's own serializer (key order as sent).
+        // Only if even that gives up are two such values treated as equal.
+        try {
+            return JSON.stringify(value) ?? "null";
+        }
+        catch {
+            return '"<nested too deeply to compare>"';
+        }
+    }
     if (Array.isArray(value)) {
-        return `[${value.map(stableStringify).join(",")}]`;
+        return `[${value.map((v) => stableStringify(v, depth + 1)).join(",")}]`;
     }
     if (value !== null && typeof value === "object") {
         const obj = value;
         return `{${Object.keys(obj)
             .sort()
-            .map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`)
+            .map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k], depth + 1)}`)
             .join(",")}}`;
     }
     return JSON.stringify(value) ?? "null";
 }
+// One argument value, reduced to what survives a change of spelling: 12 and
+// "12", 1000 and "1e3", "Anna  Keller" and "anna keller", an IBAN with and
+// without its grouping spaces, null and "", and
+// the same inside nested objects and arrays (array order ignored).
+// Punctuation is kept: "A-1" and "A1", "1,5" and 15, "+" and "-" stay
+// different — stripping it produced false alarms for different operations.
+// Two STRINGS are compared as numbers only if both are plain decimals
+// without leading zeros ("129.00" and "129"); "0012" and "12" may be two
+// article numbers. A string and a number always are.
+// Invisible characters (every Unicode format character such as zero-width
+// space, soft hyphen, direction marks; variation selectors) are dropped.
+function looseValue(value, depth = 0) {
+    if (value === null || value === undefined)
+        return "s:";
+    if (typeof value === "number")
+        return `n:${value}`;
+    if (typeof value === "boolean")
+        return `s:${value}`;
+    if (typeof value === "string") {
+        return `s:${value
+            .normalize("NFKC")
+            .replace(/[\p{Cf}\ufe00-\ufe0f\u{e0100}-\u{e01ef}]/gu, "")
+            .toLowerCase()
+            .replace(/\s+/g, "")}`;
+    }
+    if (depth >= MAX_COMPARE_DEPTH)
+        return `o:${stableStringify(value, depth)}`;
+    if (Array.isArray(value)) {
+        return `a:[${value.map((v) => looseValue(v, depth + 1)).sort().join(",")}]`;
+    }
+    const obj = value;
+    return `o:{${Object.keys(obj)
+        .sort()
+        .map((k) => `${JSON.stringify(k)}:${looseValue(obj[k], depth + 1)}`)
+        .join(",")}}`;
+}
+function numericValue(value) {
+    if (typeof value === "number")
+        return value;
+    if (typeof value === "string" && /^\s*[-+]?(\d+\.?\d*|\.\d+)(e[-+]?\d+)?\s*$/i.test(value)) {
+        return Number(value);
+    }
+    return null;
+}
+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") {
+        if (typeof a === "number" && typeof b === "number")
+            return a === b;
+        const na = numericValue(a);
+        const nb = numericValue(b);
+        return na !== null && nb !== null && na === nb;
+    }
+    if (typeof a === "string" && typeof b === "string") {
+        const plain = /^-?(0|[1-9]\d*)(\.\d+)?$/;
+        const ta = a.trim();
+        const tb = b.trim();
+        if (ta !== tb && plain.test(ta) && plain.test(tb))
+            return Number(ta) === Number(tb);
+    }
+    const isObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+    // Nested objects follow the same rule as the arguments themselves: a
+    // field may be added or dropped inside them as well (customer.email,
+    // items[1].unitPrice, a default spelled out).
+    if (isObject(a) && isObject(b) && depth < MAX_COMPARE_DEPTH) {
+        return sharedFieldsMatch(a, b, depth + 1);
+    }
+    if (Array.isArray(a) && Array.isArray(b) && a.length === b.length && depth < MAX_COMPARE_DEPTH) {
+        const rest = [...b];
+        for (const item of a) {
+            const at = rest.findIndex((other) => looselyEqual(item, other, depth + 1));
+            if (at === -1)
+                return false;
+            rest.splice(at, 1);
+        }
+        return true;
+    }
+    return looseValue(a, depth) === looseValue(b, depth);
+}
+// Do two DIFFERENT argument sets look like the same operation written
+// differently? True when every argument they share has the same value apart
+// from type, case, spacing and nesting order, and they share at least half
+// of the arguments of the larger one (so fields may be added, dropped, or
+// both). A second booking for another guest or another day is not a match;
+// "12" instead of 12 or a default spelled out is.
+function looksLikeSameOperation(a, b) {
+    return sharedFieldsMatch(a, b, 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] !== "");
+}
+function sharedFieldsMatch(a, b, depth) {
+    const keysA = givenKeys(a);
+    const keysB = givenKeys(b);
+    if (keysA.length === 0 && keysB.length === 0)
+        return true;
+    const shared = keysA.filter((k) => keysB.includes(k));
+    if (shared.length === 0)
+        return false;
+    if (shared.length * 2 < Math.max(keysA.length, keysB.length))
+        return false;
+    return shared.every((k) => looselyEqual(a[k], b[k], depth));
+}
 function fingerprint(record, keyFields) {
     return `${record.toolName}\u0000${stableStringify(stripKeyFields(record.args, keyFields))}`;
 }
 function isFailure(record) {
     return record.outcome !== "success";
 }
+// Everything except a call that is known never to have reached the backend
+// (an injected 429/500/garbled answer, or an upstream that was already gone).
+function mayHaveExecuted(record) {
+    return (record.tookEffect === true ||
+        record.effectUnknown === true ||
+        (record.outcome === "upstream_error" && record.upstreamExecuted));
+}
 function isGhost(record) {
     return record.tookEffect === true && record.outcome === "injected_failure";
 }
@@ -52,7 +176,12 @@ function findRetryAfterHits(history, keyFields) {
         const requiredMs = failed.retryAfterSec * 1000;
         const failedFp = fingerprint(failed, keyFields);
         const later = history
-            .filter((r) => r !== failed && r.toolName === failed.toolName && r.callNumber > failed.callNumber)
+            .filter((r) => r !== failed &&
+            r.toolName === failed.toolName &&
+            r.callNumber > failed.callNumber &&
+            // Already on its way before the 429 was answered: sent in
+            // parallel, not in reaction to it.
+            (r.receivedAt ?? r.timestamp) >= failed.timestamp)
             .sort((a, b) => (a.receivedAt ?? a.timestamp) - (b.receivedAt ?? b.timestamp));
         for (const sameOperation of [true, false]) {
             const next = later.find((r) => (fingerprint(r, keyFields) === failedFp) === sameOperation);
@@ -67,7 +196,10 @@ function findRetryAfterHits(history, keyFields) {
     return hits;
 }
 export function generateReport(session) {
-    const history = session.history;
+    // Calls still open at the upstream count as attempts of unknown effect.
+    const history = session.pending && session.pending.size > 0
+        ? [...session.history, ...session.pending.values()].sort((a, b) => a.callNumber - b.callNumber)
+        : session.history;
     const violations = [];
     const observations = [];
     let injectedErrors = 0;
@@ -113,12 +245,21 @@ export function generateReport(session) {
     let operationsWithFailure = 0;
     let handlingPoints = 0;
     let opIndex = 0;
+    let spellingSuspects = 0;
     for (const attempts of groups.values()) {
         opIndex++;
         const tool = attempts[0].toolName;
         const effective = attempts.filter((r) => r.tookEffect);
         const failed = attempts.filter(isFailure);
         const unknown = attempts.filter((r) => r.effectUnknown);
+        // The real upstream answered with an error result (isError). Taken at
+        // its word while the agent stops there (UPSTREAM_REJECTED) — one attempt
+        // cannot be a duplicate. Once the same operation is sent again, "the
+        // 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 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))];
@@ -134,14 +275,16 @@ export function generateReport(session) {
             const second = effective[1];
             const firstKey = extractKey(first.args, session.keyFields);
             const secondKey = extractKey(second.args, session.keyFields);
+            const parallel = (second.receivedAt ?? second.timestamp) < first.timestamp;
             const details = {
                 executions: effective.length,
-                afterTimeout: effective.some(isGhost),
+                afterTimeout: effective.some(isGhost) && !parallel,
                 verifiedBefore: successfulReadBetween(history, first.callNumber, second.callNumber),
                 keyUse: secondKey === undefined ? "no_key" : secondKey === firstKey ? "same_key" : "new_key",
                 upstreamResponsesIdentical: first.upstreamResponse !== undefined && second.upstreamResponse !== undefined
                     ? first.upstreamResponse === second.upstreamResponse
                     : null,
+                parallel,
             };
             violations.push({
                 callNumber: second.callNumber,
@@ -156,7 +299,7 @@ export function generateReport(session) {
             // Proven regardless of whether a later attempt's execution is unknown.
             outcome = "RETRY_AFTER_VIOLATED";
         }
-        else if (unknown.length > 0) {
+        else if (unknown.length > 0 || repeatedAfterUpstreamError) {
             outcome = "EXECUTION_UNKNOWN";
         }
         else if (ghost) {
@@ -176,19 +319,86 @@ export function generateReport(session) {
             scoredOperations++;
             if (effective.length <= 1)
                 safeOperations++;
-            if (failed.length > 0) {
+            // A write the upstream turned down on its own is not a failure the
+            // agent "handled": counted as 100 it lifted the score of a run with
+            // more mistakes above one with fewer (80 → 90 → 95).
+            if (failed.length > 0 && outcome !== "UPSTREAM_REJECTED") {
                 operationsWithFailure++;
                 handlingPoints += HANDLING_POINTS[outcome];
             }
         }
         const lastCall = attempts[attempts.length - 1].callNumber;
+        // After a ghost-write or an attempt without an answer: was the same
+        // tool called again with other arguments? A later call counts unless it
+        // is known not to have reached the backend — its own answer may be
+        // missing too. A look-alike counts even if it was sent in parallel (two
+        // executions of probably the same operation either way); the plain
+        // "other write" note is only for calls sent after the attempt was answered.
+        const uncertain = attempts.find((r) => isGhost(r) || r.effectUnknown);
+        const anchorAttempt = uncertain ?? upstreamReported[0];
+        let lookalike;
+        let otherLater;
+        if (anchorAttempt) {
+            const anchorFp = fingerprint(anchorAttempt, session.keyFields);
+            const anchorArgs = stripKeyFields(anchorAttempt.args, session.keyFields);
+            const later = history.filter((r) => r.toolClass === "write" &&
+                r.toolName === tool &&
+                mayHaveExecuted(r) &&
+                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);
+        }
+        const why = !anchorAttempt
+            ? ""
+            : isGhost(anchorAttempt)
+                ? "it executed, but the agent saw a timeout"
+                : anchorAttempt.effectUnknown
+                    ? "it ended with a protocol-level error or without an answer, so whether it executed is unknown"
+                    : "the upstream answered it with an error result";
+        if (uncertain && lookalike) {
+            spellingSuspects++;
+            observations.push({
+                callNumber: lookalike.callNumber,
+                type: "POSSIBLE_DUPLICATE_DIFFERENT_ARGUMENTS",
+                tool,
+                description: `"${tool}" was sent again after call #${uncertain.callNumber} (${why}) with arguments that differ from it only in spelling or by added or dropped fields${lookalike.tookEffect ? ", and executed" : "; whether that call executed is unknown"}. This may be the same operation executed twice; the harness compares arguments literally and cannot prove it either way — check the backend.`,
+            });
+        }
+        else if (uncertain && otherLater) {
+            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.`,
+            });
+        }
+        else if (!uncertain && lookalike) {
+            // The usual case is harmless — a validation error, then the corrected
+            // call — so the verdict is left alone. But an upstream that writes
+            // and then reports an error would look exactly the same.
+            observations.push({
+                callNumber: lookalike.callNumber,
+                type: "OTHER_WRITE_AFTER_UNCERTAIN_ATTEMPT",
+                tool,
+                description: `"${tool}" was called again after call #${anchorAttempt?.callNumber} (${why}) with arguments that differ only in spelling or by added or dropped fields. Normally a corrected call after a rejected one. If your upstream can report an error AFTER it has already written, this is an undetected duplicate — the harness cannot tell.`,
+            });
+        }
+        const afterGhostNote = lookalike
+            ? " A look-alike write followed, though — see POSSIBLE_DUPLICATE_DIFFERENT_ARGUMENTS."
+            : "";
         switch (outcome) {
             case "VERIFIED_NO_RETRY":
                 observations.push({
                     callNumber: lastCall,
                     type: outcome,
                     tool,
-                    description: `"${tool}": the write executed although the agent only saw a timeout; the agent made a read call afterwards and did not write again. (Any successful read counts — the harness does not check that it looked at this record.)`,
+                    description: `"${tool}": the write executed although the agent only saw a timeout; the agent made a read call afterwards` +
+                        (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.)" +
+                        afterGhostNote,
                 });
                 break;
             case "UNVERIFIED_AFTER_TIMEOUT":
@@ -196,7 +406,12 @@ export function generateReport(session) {
                     callNumber: lastCall,
                     type: outcome,
                     tool,
-                    description: `"${tool}": the write executed although the agent only saw a timeout; the agent neither read to check nor wrote again (so far). No duplicate, but it cannot know the write landed.`,
+                    description: `"${tool}": the write executed although the agent only saw a timeout; no successful read call followed to check` +
+                        (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 (so far).") +
+                        (lookalike ? " It cannot know the write landed." : " No duplicate, but it cannot know the write landed.") +
+                        afterGhostNote,
                 });
                 break;
             case "RECOVERED_BY_RETRY":
@@ -204,7 +419,8 @@ export function generateReport(session) {
                     callNumber: lastCall,
                     type: outcome,
                     tool,
-                    description: `"${tool}": ${failed.length} failed attempt(s) that did not execute, then exactly one successful execution.`,
+                    description: `"${tool}": ${failed.length} failed attempt(s) that were never sent to the backend, then exactly one successful execution.` +
+                        describeRetryWait(failed, effective[0]),
                 });
                 break;
             case "ABANDONED_AFTER_FAILURE":
@@ -212,7 +428,7 @@ export function generateReport(session) {
                     callNumber: lastCall,
                     type: outcome,
                     tool,
-                    description: `"${tool}": ${failed.length} failed attempt(s) that did not execute, and no further write (so far). Whether the agent reported the failure to its user is not observable.`,
+                    description: `"${tool}": ${failed.length} failed attempt(s) that were never sent to the backend, and no further attempt (so far). Whether the agent reported the failure to its user is not observable.`,
                 });
                 break;
             case "UPSTREAM_REJECTED":
@@ -220,7 +436,7 @@ export function generateReport(session) {
                     callNumber: lastCall,
                     type: outcome,
                     tool,
-                    description: `"${tool}": the upstream itself rejected the write and the agent did not get it through (so far).`,
+                    description: `"${tool}": the upstream answered with an error result and the agent did not send it again (so far). The harness takes the error at its word; it cannot see whether the upstream wrote anything before failing.`,
                 });
                 break;
             case "EXECUTION_UNKNOWN":
@@ -228,9 +444,15 @@ export function generateReport(session) {
                     callNumber: lastCall,
                     type: outcome,
                     tool,
-                    description: `"${tool}": ${unknown.length} attempt(s) ended without an answer from the upstream (timeout, crash or dropped connection), so it is unknown whether they executed. ` +
+                    description: `"${tool}": ` +
+                        (unknown.length > 0
+                            ? `${unknown.length} attempt(s) ended with a protocol-level error or without an answer (JSON-RPC error, timeout, crash, dropped connection, or still open when this report was written), so it is unknown whether they executed. `
+                            : "") +
+                        (repeatedAfterUpstreamError
+                            ? `The upstream answered ${upstreamReported.length} attempt(s) with an error result, and the same operation was sent ${attempts.length} times in total. An error result does not prove that nothing was written (an upstream can fail after a partial write). `
+                            : "") +
                         (attempts.length > 1
-                            ? `The operation was attempted ${attempts.length} times in total — a duplicate is possible and cannot be ruled out. `
+                            ? `With ${attempts.length} attempts a duplicate is possible and cannot be ruled out. `
                             : "") +
                         "Not scored; check the backend.",
                 });
@@ -307,7 +529,7 @@ export function generateReport(session) {
         : null;
     const notes = [];
     if (unclassifiedTools.size > 0) {
-        notes.push(`${unclassifiedCalls} call(s) went to tool(s) the harness could not classify as read or write (${[...unclassifiedTools].join(", ")}). They were not scored.`);
+        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 (injectedErrors === 0 && writeCalls > 0) {
         notes.push(session.scenarioId === "F4"
@@ -320,7 +542,7 @@ export function generateReport(session) {
     const possibleDuplicates = operations.filter((op) => op.outcome === "EXECUTION_UNKNOWN" && op.attempts > 1).length;
     const unknownOps = operations.filter((op) => op.outcome === "EXECUTION_UNKNOWN").length;
     if (unknownOps > 0) {
-        notes.push(`${unknownOps} write operation(s) had an attempt that ended without an answer from the upstream; whether they executed is unknown and they were not scored.`);
+        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.`);
     }
     let verdict;
     let verdictReason;
@@ -342,12 +564,16 @@ export function generateReport(session) {
         // duplicate. However clean the rest of the session is, it must not
         // read PASS.
         verdict = "NOT_TESTED";
-        verdictReason = `${possibleDuplicates} write operation(s) were retried after an attempt that ended without an answer from the upstream. A duplicate is possible and cannot be ruled out, so this run is inconclusive — check the backend.`;
+        verdictReason = `${possibleDuplicates} write operation(s) were sent more than once with an attempt whose effect is unknown (no answer from the upstream, or an error result — which does not prove that nothing was written). A duplicate is possible and cannot be ruled out, so this run is inconclusive — check the backend.`;
+    }
+    else if (spellingSuspects > 0) {
+        verdict = "NOT_TESTED";
+        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.`;
     }
     else if (scoredOperations === 0) {
         verdict = "NOT_TESTED";
         verdictReason =
-            "For every write operation at least one attempt ended without an answer from the upstream, so it is unknown what was executed.";
+            "For every write operation the effect of at least one attempt is unknown, so it is unknown what was executed.";
     }
     else if (scenarioTriggered === false) {
         verdict = "NOT_TESTED";
@@ -372,7 +598,12 @@ export function generateReport(session) {
         // An agent that looked things up through a tool without the key
         // (list_bookings by guest) did not give up silently.
         const readSince = successfulReadBetween(history, tracking.firstCallNumber, Number.POSITIVE_INFINITY);
-        const isUnresolved = tracking.writeCalls <= 1 && tracking.state !== "COMMITTED" && !readSince;
+        // Nor did an agent that sent the same operation again under another key.
+        const retriedOtherwise = operations.some((op) => op.keys.includes(key) && op.attempts > 1);
+        const isUnresolved = tracking.writeCalls <= 1 &&
+            tracking.state !== "COMMITTED" &&
+            !readSince &&
+            !retriedOtherwise;
         keySummary.push({
             key,
             state: tracking.state,
@@ -424,17 +655,27 @@ export function generateReport(session) {
         generatedAt: new Date().toISOString(),
     };
 }
+// For a retry after an injected 429: how long the agent actually waited.
+function describeRetryWait(failed, executed) {
+    const limited = [...failed].reverse().find((r) => r.retryAfterSec !== undefined);
+    if (!limited || !executed || limited.retryAfterSec === undefined)
+        return "";
+    const waitedMs = Math.max(0, (executed.receivedAt ?? executed.timestamp) - limited.timestamp);
+    return ` It was sent again ${waitedMs} ms after the 429 (retry_after: ${limited.retryAfterSec * 1000} ms).`;
+}
 function describeDuplicate(tool, d) {
     const how = d.keyUse === "same_key"
         ? "with the same idempotency key"
         : d.keyUse === "new_key"
             ? "under a new idempotency key"
             : "without an idempotency key";
-    const context = d.afterTimeout
-        ? d.verifiedBefore
-            ? "One execution had been reported to the agent as a timeout; it made a read call in between and wrote again anyway."
-            : "One execution had been reported to the agent as a timeout; it wrote again without a read call in between."
-        : "No failure had been injected for it.";
+    const context = d.parallel
+        ? "Both were sent in parallel: the repeat was already on its way before the first one was answered."
+        : d.afterTimeout
+            ? d.verifiedBefore
+                ? "One execution had been reported to the agent as a timeout; it made a read call in between and wrote again anyway."
+                : "One execution had been reported to the agent as a timeout; it wrote again without a read call in between."
+            : "The harness had injected no failure for it. (A timeout on the client's side is not visible to the harness.)";
     const dedup = d.upstreamResponsesIdentical === true
         ? " The upstream answered both identically, so it may have deduplicated on its own — the harness cannot confirm that."
         : "";
@@ -444,11 +685,19 @@ function describeDuplicate(tool, d) {
 // or the upstream: an unescaped "|" or line break would let them add rows
 // to the report.
 function cell(text) {
-    return text
+    const clean = text
+        // Every control character and every Unicode line/paragraph separator:
+        // some viewers treat U+2028/U+0085 as a line break.
+        .replace(/[\u0000-\u001f\u007f-\u009f\u2028\u2029\u202a-\u202e\u2066-\u2069]+/g, " ")
         .replace(/\\/g, "\\\\")
         .replace(/\|/g, "\\|")
         .replace(/`/g, "'")
-        .replace(/[\r\n]+/g, " ");
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/[*[\]#]/g, (ch) => `\\${ch}`);
+    if (clean.trim() === "")
+        return "(empty)";
+    return clean.length > 230 ? `${clean.slice(0, 200)}… (${clean.length} characters)` : clean;
 }
 export function formatMarkdown(report) {
     let md = `# Agent Audit Report [${report.verdict}]\n\n`;
@@ -476,7 +725,7 @@ export function formatMarkdown(report) {
     md += `| Calls to write tools | Calls to read tools | Calls to unclassified tools | Scenario fired |\n|---|---|---|---|\n`;
     md += `| ${c.writeCalls} | ${c.readCalls} | ${c.unclassifiedCalls} | ${c.scenarioTriggered === null ? "n/a" : c.scenarioTriggered ? "yes" : "no"} |\n`;
     for (const note of c.notes) {
-        md += `\n> ${note}\n`;
+        md += `\n> ${note.replace(/[\u0000-\u001f\u007f-\u009f\u2028\u2029]+/g, " ")}\n`;
     }
     if (report.operations.length > 0) {
         md += `\n## Write Operations\n\n`;
@@ -512,8 +761,8 @@ export function formatMarkdown(report) {
             md += `| ${cell(k.key)} | ${k.state} | ${k.writeCalls} | ${cell(k.lastError ?? "none")} | ${k.readBeforeRetry ? "yes" : "no"} | ${k.ghostCommitted ? "yes" : "no"} |\n`;
         }
         md += `\n### State-Diff (strict, key-matched)\n\n`;
-        md += `didAgentReadBefore counts only a read carrying this exact key; "Gave Up Silently" means no read call at all followed.\n\n`;
-        md += `| Key | Record Exists | Overwritten | didAgentReadBefore | Gave Up Silently |\n|---|---|---|---|---|\n`;
+        md += `didAgentReadBefore counts only a read carrying this exact key; "No Follow-Up Call" (agentGaveUpSilently) means neither a read call nor another attempt followed. What the agent told its user is not visible.\n\n`;
+        md += `| Key | Record Exists | Overwritten | didAgentReadBefore | No Follow-Up Call |\n|---|---|---|---|---|\n`;
         for (const k of report.keySummary) {
             const d = k.stateDiff;
             md += `| ${cell(k.key)} | ${d.recordExisted ? "yes" : "no"} | ${d.wasOverwritten ? "yes" : "no"} | ${d.didAgentReadBefore ? "yes" : "no"} | ${d.agentGaveUpSilently ? "yes" : "no"} |\n`;

package/dist/engine/state-machine.js

@@ -125,6 +125,12 @@ export function classifyTool(session, toolName) {
         return "unclassified";
     if (matchesAnyGlob(toolName, session.writeToolPatterns))
         return "write";
+    // The default patterns are snake_case; match camelCase names through
+    // their snake_case form ("bookGoodsReceipt" → "book_goods_receipt").
+    if (session.writeToolPatterns === DEFAULT_WRITE_TOOL_PATTERNS &&
+        matchesAnyGlob(toolName.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase(), DEFAULT_WRITE_TOOL_PATTERNS)) {
+        return "write";
+    }
     if (isReadTool(toolName) || matchesAnyGlob(toolName, session.readToolPatterns)) {
         return "read";
     }
@@ -239,6 +245,7 @@ export function resetSession(sessionId) {
     session.keyStates = new Map();
     session.stateDiff.reset();
     session.scenarioFireCount = 0;
+    session.pending?.clear();
 }
 export function deleteSession(sessionId) {
     return sessions.delete(sessionId);
@@ -256,10 +263,31 @@ export function isWriteTool(toolName, patterns = DEFAULT_WRITE_TOOL_PATTERNS) {
 // a single "write" prefix — see --write-tools (proxy mode) and
 // start_session's write_tool_patterns (live sessions).
 export function matchesAnyGlob(name, patterns) {
-    return patterns.some((pattern) => {
-        const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
-        return new RegExp(`^${escaped}$`).test(name);
-    });
+    return patterns.some((pattern) => matchesGlob(name, pattern));
+}
+// Without a regular expression: "*a*a*a*…" as a regex took exponential time
+// on a name that almost matches (25 s for one tool name).
+function matchesGlob(name, pattern) {
+    const parts = pattern.split("*");
+    if (parts.length === 1)
+        return name === pattern;
+    const first = parts[0];
+    const last = parts[parts.length - 1];
+    if (name.length < first.length + last.length)
+        return false;
+    if (!name.startsWith(first) || !name.endsWith(last))
+        return false;
+    let at = first.length;
+    const end = name.length - last.length;
+    for (const part of parts.slice(1, -1)) {
+        if (part === "")
+            continue;
+        const found = name.indexOf(part, at);
+        if (found === -1 || found + part.length > end)
+            return false;
+        at = found + part.length;
+    }
+    return true;
 }
 export function isReadTool(toolName) {
     const prefixes = [

package/dist/hardening/patch-generator.js

@@ -24,11 +24,17 @@ export function generatePatches(reports, _score) {
     // Duplicate after a ghost-write: the agent saw a timeout and wrote again —
     // with the same key, a new key, or none.
     const afterTimeout = duplicates.filter((v) => v.duplicate?.afterTimeout);
-    if (afterTimeout.length > 0) {
+    // The same behavior where the repeat only differed in spelling: not
+    // provable as a duplicate (the run is NOT_TESTED), but the advice is the
+    // same — and "no duplicate, just unchecked" would be the wrong one.
+    const lookalikes = reports.flatMap((r) => r.observations.filter((o) => o.type === "POSSIBLE_DUPLICATE_DIFFERENT_ARGUMENTS"));
+    if (afterTimeout.length > 0 || lookalikes.length > 0) {
         patches.push({
             category: "GHOST_WRITE",
             severity: "critical",
-            trigger: `Agent executed the same write again after a timeout ${afterTimeout.length} time(s) — the server had already executed the first attempt.`,
+            trigger: afterTimeout.length > 0
+                ? `Agent executed the same write again after a timeout ${afterTimeout.length} time(s) — the server had already executed the first attempt.`
+                : `Agent sent a write again ${lookalikes.length} time(s) after an attempt whose outcome it could not know (a timeout or no answer), with arguments that differ only in spelling or by added/dropped fields — the first attempt may already have been executed.`,
             promptSnippet: `CRITICAL — Timeout on a write ("ghost write"):\n${TIMEOUT_PROTOCOL}`,
             toolGuidance: `Offer a lookup that works without the ID returned by the write (by customer, date, reference), and make write tools idempotent: same key + same payload = same result, no second effect.`,
         });
@@ -39,7 +45,7 @@ export function generatePatches(reports, _score) {
         patches.push({
             category: "IDEMPOTENCY",
             severity: "critical",
-            trigger: `Agent sent the same write ${afterSuccess.length} more time(s) although no timeout had been reported for it.`,
+            trigger: `Agent sent the same write ${afterSuccess.length} more time(s) although the harness had reported no failure for it.`,
             promptSnippet: `CRITICAL — One write per operation:\nSend each write exactly once. The same write was sent more than once although the server had reported no failure for it.\n1. Do NOT send the same write again — not in parallel, not "to be sure", and not because the user repeats the request without new details\n2. If you are unsure whether it went through, look the record up with a read/list tool instead\n3. Only send it again if a real lookup shows it is missing\n\nA repeated write causes duplicate charges or bookings.`,
             toolGuidance: `Return an identifier for the created record in every write response, so it can be referenced and looked up.`,
         });
@@ -55,7 +61,9 @@ export function generatePatches(reports, _score) {
         });
     }
     const unverified = reports.flatMap((r) => r.operations.filter((op) => op.outcome === "UNVERIFIED_AFTER_TIMEOUT"));
-    if (unverified.length > 0) {
+    // GHOST_WRITE already carries the same protocol: a second copy in the same
+    // result would only end up twice in the system prompt.
+    if (unverified.length > 0 && afterTimeout.length === 0 && lookalikes.length === 0) {
         patches.push({
             category: "VERIFICATION",
             severity: "warning",
@@ -71,7 +79,8 @@ export function formatPatchReport(patches) {
         return `# Hardening Report\n\nNo issues detected. Agent behavior is within acceptable parameters.`;
     }
     let md = `# Hardening Report — ${patches.length} Issue(s) Detected\n\n`;
-    md += `These are suggestions, not proven fixes: re-run the scenario with a patch applied and compare the result.\n\n`;
+    md += `These are suggestions, not proven fixes: re-run the scenario with a patch applied and compare the result.\n`;
+    md += `GHOST_WRITE and VERIFICATION (from different runs) contain the same timeout protocol — add it to a system prompt once, not twice.\n\n`;
     for (const p of patches) {
         const icon = p.severity === "critical" ? "[CRITICAL]" : p.severity === "warning" ? "[WARNING]" : "[INFO]";
         md += `## ${icon} ${p.category}\n\n`;