humanish 0.80.0 → 0.81.0

package/dist/cua-actor-lab.d.ts

@@ -793,10 +793,11 @@ export declare function captureDesktopBrowserGeometry(args: {
  */
 export declare function resolveSelfReportedBlocker(session: CuaLoopResult | undefined): string | undefined;
 /**
- * The friction read of the same narrative (#453): everything the verdict scan counts PLUS
- * resolved arcs — a participant who hit a wall, got past it, and said so has reported friction
- * worth a tally count and a feedback candidate, without costing the lane its pass. Same
- * quoted-copy and stopWhen discipline as the verdict resolver. Exported for testing.
+ * Friction is independent of how a completed session ended (#657). Read the participant's
+ * redacted messages, including earlier reports, rather than the harness-owned reason that
+ * stopWhen/dwell writes. Reasoning, observations, and notices are not participant reports.
+ * Resolved arcs still count (#453); quoted copy and negated reports still do not. This read
+ * never changes the verdict. Exported for testing.
  */
 export declare function resolveSelfReportedFriction(session: CuaLoopResult | undefined): string | undefined;
 /**
@@ -939,8 +940,8 @@ export declare function buildCuaCostSummary(args: {
  * trying. A clean pass files nothing here — feedback exists to carry findings, and a run without
  * any falls back to an honest live summary in the draft layer instead of a template.
  *
- * Everything quoted is already scrub+redacted — `session.reason` passes through redactNarration in
- * the loop before it ever lands on a trace — and passes redactText again here as defense-in-depth.
+ * Everything quoted is already scrub+redacted — participant messages and `session.reason` pass
+ * through redactNarration in the loop — and passes redactText again here as defense-in-depth.
  */
 export declare function participantFeedbackCandidates(args: {
     runId: string;

package/dist/cua-actor-lab.js

@@ -1063,7 +1063,11 @@ export async function applyMobileEmulation(desktop, requestTimeoutMs, endpoint,
         throw new Error(`mobile emulation could not be applied (${announced.unavailable}); applied before failing: ${(announced.applied ?? []).join(", ") || "nothing"}`);
     }
     const applied = announced;
-    const warnings = [];
+    // Viewport/touch read-back proves context settings, not gesture equivalence. Two hosted
+    // replicas and a native-X conversion-toggle control reproduced reset click counts (#676).
+    const warnings = request.touch
+        ? ["Mobile emulation uses desktop pointer-to-touch conversion, which can differ for repeated taps. Confirm gesture failures with direct or native touch input before attributing them to the app."]
+        : [];
     // The reload inside the applier takes a moment; the read-back is retried until the page reports
     // the requested viewport and user agent, so a slow page does not read as "no proof".
     let readBack = await read();
@@ -1335,14 +1339,56 @@ const REPORTED_DEFECT_LANGUAGE = /\b(defects?|bugs?|accessibilit(y|ies)|inaccess
 // counted as reported friction and became a feedback candidate whose "actual" was a sentence
 // reporting no problem. Only the report-shaped adjectives are negatable here: "no visible focus",
 // "not keyboard-accessible" and "did nothing" are defects and stay.
-const NEGATED_REPORT_LANGUAGE = /\b(?:nothing|no|not|never|without|none)\s+(?:was\s+|were\s+|felt\s+|seemed\s+|really\s+|particularly\s+|especially\s+|major\s+|real\s+|obvious\s+|noticeable\s+)*(?:confus(?:ed|ing|ion)|unclear|unexpected(?:ly)?|hesitat(?:ed|ion|ions)|surpris(?:ed|ing|es)|defects?|bugs?|overlap(?:ped|ping|s)?|truncat(?:ed|es|ion)|hard to (?:find|tell|see|read|reach))\b/g;
+const NEGATED_REPORT_ITEM = String.raw `(?:confus(?:ed|ing|ion)|unclear(?:\s+error\s+output)?|unexpected(?:ly)?|hesitat(?:ed|ion|ions)|surpris(?:ed|ing|es)|defects?|bugs?|overlap(?:ped|ping|s)?|truncat(?:ed|es|ion)|hard to (?:find|tell|see|read|reach)|blockers?|blocking issues?|errors?(?:\s+output)?|failures?|problems?|issues?)`;
+const NEGATED_REPORT_QUALIFIERS = String.raw `(?:(?:really|particularly|especially|major|minor|real|actual|remaining|functional|obvious|noticeable|significant|any|a|an)\s+)*`;
+const NEGATED_REPORT_MODIFIERS = String.raw `(?:(?:was|were|felt|seemed|really|particularly|especially|major|minor|real|actual|remaining|functional|obvious|noticeable|significant|any|a|an|encounter(?:ed)?|experience(?:d)?|notice(?:d)?|observe(?:d)?|feel|find|found|have|had)\s+)*`;
+const NEGATED_REPORT_LANGUAGE = new RegExp(String.raw `\b(?:nothing|no|not|never|without|none|(?:did|do|does|was|were|has|have|had)n['’]t)\s+${NEGATED_REPORT_MODIFIERS}${NEGATED_REPORT_ITEM}\b`
+    // Negation scopes over a coordinated report list, not the rest of the sentence. In
+    // particular, leave "but the label was confusing" and "and Save did nothing" intact.
+    + String.raw `(?:\s*,?\s+(?:or|nor|and)\s+${NEGATED_REPORT_QUALIFIERS}${NEGATED_REPORT_ITEM}\b)*`
+    // Keep the predicate inside its negation: "No errors blocked me" reports no blocker.
+    + String.raw `(?:\s+(?:blocked|stopped|prevented)\s+(?:me|us|it)\b)?`, "g");
 function stripNegatedReportLanguage(text) {
-    return text.replace(NEGATED_REPORT_LANGUAGE, " ");
+    // "Not without hesitation" reports hesitation; do not let the inner "without" erase it.
+    return text.replace(/\b(?:not|never)\s+without\b/g, "with").replace(NEGATED_REPORT_LANGUAGE, " ");
 }
 function completionReasonContradictsGoal(reason) {
-    const text = stripQuotedSpans(stripNegatedReportLanguage(stripNegatedNonBlockerPhrases(reason.toLowerCase())));
+    // Preserve the full negated list before the older blocker-specific rules remove its first
+    // noun ("no issues or hesitation"). Matching reports first also avoids their broad encounter
+    // clause rule swallowing a genuine subsequent observation.
+    const text = stripQuotedSpans(stripNegatedNonBlockerPhrases(stripNegatedReportLanguage(stripCodeExamples(reason).toLowerCase())));
     return hasBlockerLanguage(text) || REPORTED_DEFECT_LANGUAGE.test(text);
 }
+/** Code/documentation excerpts are quoted material, not participant observations. */
+function stripCodeExamples(text) {
+    return text
+        // Include an unterminated fence: copied text is not promoted just because its closing fence
+        // was omitted. Match the same marker so backticks inside a tilde fence cannot end it early.
+        .replace(/^[ \t]*(`{3,}|~{3,})[^\n]*\n[\s\S]*?(?:^[ \t]*\1[ \t]*$|(?![\s\S]))/gm, " ")
+        .replace(/(`+)[^`\n]*\1/g, " ");
+}
+/** Interim messages also contain plans and hypotheses. Admit observed-report clauses only;
+ * the established closing-report scan remains separate. This is a conservative text heuristic,
+ * not an assertion that every mention of a defect is evidence that one happened. */
+function interimMessageReportsFriction(message) {
+    const prose = stripQuotedSpans(stripCodeExamples(message).toLowerCase());
+    const clauses = prose.split(/(?<=[.!?])\s+|[;\n]+|,\s*(?:but|so|however|yet)\s+|\s+so\s+(?=i\b|we\b)/);
+    return clauses.some((clause) => {
+        // A condition, question, intention, or conjecture does not assert an observed result.
+        // Clause splitting above keeps "Save did nothing, so I will try Enter" observable.
+        if (/\?|\b(?:if|unless|whether|maybe|perhaps|suppose|hypothetically|might|may|would|should)\b|\bcould\b(?!\s+not\b)/.test(clause)
+            || /\b(?:i|we)(?:['’]ll|\s+(?:will|plan|intend|want|hope|suspect|wonder))\b|\bgoing to\b|\blet['’]s\b/.test(clause)
+            || /\b(?:task|goal|mission|objective|plan)\s+(?:(?:is|was)\s+)?to\b|^\s*(?:check|test|look|checking|testing)\b/.test(clause))
+            return false;
+        // A topic is not a defect ("the accessibility guide is open", "shows error-handling docs").
+        // Actual friction in those surfaces still qualifies: "the error guide was confusing".
+        const observation = clause
+            .replace(/\baccessibilit(?:y|ies)\b/g, " ")
+            .replace(/\berror[- ]handling\b|\berror\s+(?:documentation|docs?|guides?|reference|examples?)\b/g, " ");
+        const assertsObservation = /\b(?:is|are|was|were|has|had|did|does|shows?|showed|seems?|seemed|looks?|looked|found|noticed|saw|hit|encountered|felt|got|failed|returned|cannot|can['’]?t|unable|could not)\b|\b(?:overlap(?:ped|ping|s)?|truncat(?:ed|es)|cut off|nothing happened|no (?:visible )?focus)\b/.test(observation);
+        return assertsObservation && completionReasonContradictsGoal(observation);
+    });
+}
 /** The verdict scan (strict): like the friction scan, but resolved-arc segments are stripped
  *  first — failure narration the participant itself reports as overcome is friction on the
  *  road, not a blocker at the destination (#453). */
@@ -1438,21 +1484,39 @@ export function resolveSelfReportedBlocker(session) {
         : undefined;
 }
 /**
- * The friction read of the same narrative (#453): everything the verdict scan counts PLUS
- * resolved arcs — a participant who hit a wall, got past it, and said so has reported friction
- * worth a tally count and a feedback candidate, without costing the lane its pass. Same
- * quoted-copy and stopWhen discipline as the verdict resolver. Exported for testing.
+ * Friction is independent of how a completed session ended (#657). Read the participant's
+ * redacted messages, including earlier reports, rather than the harness-owned reason that
+ * stopWhen/dwell writes. Reasoning, observations, and notices are not participant reports.
+ * Resolved arcs still count (#453); quoted copy and negated reports still do not. This read
+ * never changes the verdict. Exported for testing.
  */
 export function resolveSelfReportedFriction(session) {
+    if (session?.completionReason !== "goal_satisfied")
+        return undefined;
     // Friction stays a read of the narrative even when the outcome was declared: a participant who
     // reached the goal and described what was hard on the way has reported friction.
-    if (session?.trace.declaredOutcome === "blocked" && session.completionReason === "goal_satisfied")
+    if (session.trace.declaredOutcome === "blocked")
         return session.reason;
-    return session?.completionReason === "goal_satisfied"
-        && completionReasonContradictsGoal(session.reason)
-        && !traceHasStopWhenMatch(session)
-        ? session.reason
-        : undefined;
+    const messages = session.trace.items
+        .filter((item) => item.kind === "message" && item.id !== session.trace.debrief?.messageId)
+        .map((item) => item.text?.trim() ?? "")
+        .filter((text) => text.length > 0);
+    // A custom session may keep its closing report only in reason even when earlier messages exist.
+    // Structured stop/dwell reasons are controller text and never enter this closing-report path.
+    const closingReport = traceHasStopWhenMatch(session) ? undefined : session.reason.trim();
+    // One candidate per participant, with exact repeats removed (the closing report often repeats
+    // a prior turn). Earlier turns require observed-report clauses, not arbitrary defect mentions.
+    const typedReports = session.trace.debrief?.status === "completed"
+        ? session.trace.debrief.report?.frictionReports ?? [] : [];
+    const reports = [...new Set([...typedReports, ...messages.filter((message) => message === closingReport
+                ? completionReasonContradictsGoal(message)
+                : interimMessageReportsFriction(message))])];
+    if (closingReport && completionReasonContradictsGoal(closingReport) && !reports.includes(closingReport)) {
+        reports.push(closingReport);
+    }
+    if (reports.length > 0)
+        return reports.join("\n\n");
+    return undefined;
 }
 /**
  * Run ONE E2B desktop lane end-to-end: create the sandbox (per-lane metadata + the lane's device
@@ -1607,13 +1671,11 @@ export async function runCuaLane(spec, deps) {
             dpi: 96,
             lifecycle: { onTimeout: "kill" }
         }, config.execution?.desktop?.template, {
-            // One retry on a transient provider error (a sandbox whose envd was not routable yet, an
-            // API reply without a body). The failed attempt may have allocated a sandbox this process
-            // never learned the id of; its own timeoutMs is what reclaims it, so the warning says so.
+            // The default loader reclaims an acquired handle before retrying failed desktop startup.
+            // Its error names the cleanup outcome; pre-construction allocation failures remain unowned.
             onRetry: (reason) => {
                 const named = redactText(deps.scrubKnownValues(reason));
-                warnings.push(`Sandbox create for lane ${spec.laneId} retried once after a transient provider error (${named}); ` +
-                    `a sandbox the first attempt may have allocated is not known to this run and expires on the provider's ${Math.round(deps.perLaneSandboxMs / 60_000)}-minute timeout.`);
+                warnings.push(`Sandbox create for lane ${spec.laneId} retried once after a transient provider error (${named}).`);
                 onSubjectPhase({ at: new Date(deps.now()).toISOString(), type: "cua-lab.sandbox.create.retry", message: `sandbox create retried once (${named})` });
             }
         });
@@ -3849,6 +3911,18 @@ export function buildCuaCostSummary(args) {
             sumInput += usage.input ?? 0;
             sumOutput += usage.output ?? 0;
         }
+        // An attempted closing request can fail after provider work without reporting usage.
+        // Keep the known interaction estimate and make the additional unknown explicit.
+        if (lane.trace.debrief?.usageReported === false) {
+            breakdown.push({
+                kind: "model-tokens",
+                ...(lane.laneId === undefined ? {} : { laneId: lane.laneId }),
+                ...(lane.trace.providerVersion === undefined ? {} : { modelId: lane.trace.providerVersion }),
+                estimatedCostUsd: null,
+                reason: "closing_usage_unreported",
+                ratesAsOf: null
+            });
+        }
         const est = lane.trace.estimatedCost;
         if (!est) {
             continue;
@@ -3929,8 +4003,8 @@ function desktopSpanToMinutes(desktopDurationMs) {
  * trying. A clean pass files nothing here — feedback exists to carry findings, and a run without
  * any falls back to an honest live summary in the draft layer instead of a template.
  *
- * Everything quoted is already scrub+redacted — `session.reason` passes through redactNarration in
- * the loop before it ever lands on a trace — and passes redactText again here as defense-in-depth.
+ * Everything quoted is already scrub+redacted — participant messages and `session.reason` pass
+ * through redactNarration in the loop — and passes redactText again here as defense-in-depth.
  */
 export function participantFeedbackCandidates(args) {
     const candidates = [];