humanish 0.80.0 → 0.82.0

package/dist/cua-actor-lab.js

@@ -56,7 +56,8 @@ import { assertPreparedSelectedOutputDirectory, assertSafeOutputPathSegment, pre
 import { prepareRunArtifactPaths, validatePreparedRunArtifactPaths } from "./run-paths.js";
 import { createLocalTreeArchive } from "./source-archive.js";
 import { buildRunSource, loadRunBundle, PUBLIC_TARGET_CWD, REVIEW_SCHEMA, RUN_BUNDLE_SCHEMA, aggregateTaskFunnels, formatParticipantOutcomes, formatStudyTaskFunnel, tallyParticipantOutcomes } from "./run.js";
-import { estimateActorCost, estimateDesktopCost, MODEL_RATES, round6 } from "./pricing.js";
+import { estimateActorCost, estimateDesktopCost, estimateAllocatedDesktopCost, MODEL_RATES, round6 } from "./pricing.js";
+import { observeDesktopResources } from "./e2b-desktop-resources.js";
 export const CUA_ACTOR_LAB_SCHEMA = "humanish.cua-lab-result.v2";
 // The only fan-out topology this slice ships: N lanes = N independent E2B desktop sandboxes,
 // each its own world (clone/serve + subject.state per lane). Shared-world is layer 7 (#164).
@@ -1063,7 +1064,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 +1340,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 +1485,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
@@ -1540,9 +1605,11 @@ export async function runCuaLane(spec, deps) {
     let sandboxId;
     // Host-side E2B desktop billed-span endpoints, measured via the injected clock. Captured right
     // after create() succeeds and again in the finally after teardown resolves (both the killed and
-    // kept-for-debug paths), so the desktop-minute cost estimate reflects the honest lifetime.
+    // kept-for-debug paths). This measured span excludes allocation before the acquired handle;
+    // a kept/unconfirmed allocation gets an extra unknown lifetime cost line.
     let sandboxCreatedAtMs;
     let sandboxTornDownAtMs;
+    let desktopResources;
     let killed = false;
     let streamUrl;
     let subjectCommit;
@@ -1607,13 +1674,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})` });
             }
         });
@@ -1623,6 +1688,10 @@ export async function runCuaLane(spec, deps) {
         await appendSandboxReceipt(deps.artifactRoot, { at: new Date(deps.now()).toISOString(), laneId: spec.laneId, sandboxId, timeoutMs: deps.perLaneSandboxMs });
         // The billed span starts the instant the sandbox exists.
         sandboxCreatedAtMs = deps.now();
+        desktopResources = await observeDesktopResources(desktop);
+        if ("reason" in desktopResources) {
+            warnings.push(`Desktop resource size unavailable (${desktopResources.reason}); compute cost remains unpriced.`);
+        }
         if (deps.hooks.prepareDesktop) {
             await deps.hooks.prepareDesktop(desktop, { laneId: spec.laneId, laneIndex: spec.laneIndex, laneCount: deps.laneCount });
         }
@@ -2137,8 +2206,8 @@ export async function runCuaLane(spec, deps) {
             else {
                 warnings.push("Installed @e2b/desktop SDK does not expose Sandbox.kill; server-side kill-on-timeout will reclaim the sandbox.");
             }
-            // Close the billed span for BOTH the killed and kept-for-debug paths (a kept sandbox is
-            // still billed until its server-side timeout, so the honest span ends here either way).
+            // Close the observed span. A kept or unconfirmed sandbox can still accrue compute cost;
+            // the summary records that remaining lifetime as unknown instead of calling this complete.
             sandboxTornDownAtMs = deps.now();
             // The lane's live stream is now a dead page whichever teardown path ran (killed, kept, or
             // kill-failed-awaiting-TTL) — tell the watch overlay so the tile falls back to recorded
@@ -2191,6 +2260,7 @@ export async function runCuaLane(spec, deps) {
         ...(sessionError === undefined ? {} : { sessionError }),
         ...(sandboxId === undefined ? {} : { sandboxId }),
         ...(desktopDurationMs === undefined ? {} : { desktopDurationMs }),
+        ...(desktopResources === undefined ? {} : { desktopResources }),
         killed,
         streamUrlPresent: streamUrl !== undefined,
         screenshots,
@@ -3446,6 +3516,12 @@ function buildSingleLaneBundle(args) {
         ...(desktopSpanToMinutes(outcome?.desktopDurationMs) === undefined
             ? {}
             : { desktopMinutes: desktopSpanToMinutes(outcome?.desktopDurationMs) }),
+        ...(outcome?.sandboxId === undefined ? {} : { desktopUsage: {
+                laneId: spec.laneId,
+                minutes: desktopSpanToMinutes(outcome.desktopDurationMs),
+                observation: outcome.desktopResources,
+                lifetimeComplete: outcome.killed
+            } }),
         phaseEvents: outcome?.phaseRecords ?? []
     });
 }
@@ -3825,20 +3901,6 @@ function describeSubjectState(state, dryRun) {
 function tailOf(log) {
     return redactedTail(log, ERROR_TAIL_CHARS);
 }
-/**
- * Project a computer-use session into a humanish.run-bundle.v1. The load-bearing line is
- * `stream.actor = session.trace` — the provider-neutral ActorTrace seam the Observer renders.
- * Exported for the bundle-builder tests.
- */
-/**
- * Assemble the run-level cost ESTIMATE from each lane's persisted per-actor estimate
- * (trace.estimatedCost, set at the lab boundary) plus the aggregated E2B desktop-minute span.
- * Returns undefined (cost OMITTED) when nothing was priceable AND no sandbox ran — a pure dry-run
- * or an in-process lane (no trace.estimatedCost, no desktop) stays byte-stable with no cost block.
- * The null-discipline mirrors the terminal ledger: a present-but-unpriceable line is null + a
- * reason and contributes NOTHING to estimatedTotalUsd (never coerced to 0); an all-null summary
- * has a null total. Every non-null figure carries its ratesAsOf date + source (invariant 6).
- */
 export function buildCuaCostSummary(args) {
     const breakdown = [];
     let sumInput = 0;
@@ -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;
@@ -3864,7 +3938,31 @@ export function buildCuaCostSummary(args) {
             ...(est.placeholder ? { placeholder: true } : {})
         });
     }
-    if (args.desktopMinutes !== undefined) {
+    for (const usage of args.desktops ?? []) {
+        const observation = usage.observation;
+        const resources = observation && "resources" in observation ? observation.resources : undefined;
+        const estimate = estimateAllocatedDesktopCost(usage.minutes, resources);
+        breakdown.push({
+            kind: "desktop-minutes",
+            ...(usage.laneId === undefined ? {} : { laneId: usage.laneId }),
+            estimatedCostUsd: estimate.estimatedCostUsd,
+            ...(estimate.reason === undefined ? {} : { reason: estimate.reason }),
+            ratesAsOf: estimate.ratesAsOf,
+            ...(estimate.source === undefined ? {} : { source: estimate.source }),
+            desktop: {
+                minutes: estimate.minutes,
+                durationBasis: "host-acquired-to-cleanup",
+                ...(resources === undefined ? {} : { resources, resourceSource: "e2b.getInfo" }),
+                ...(observation && "reason" in observation ? { resourceUnavailableReason: observation.reason } : {}),
+                ...(estimate.usdPerSecond === undefined ? {} : { usdPerSecond: estimate.usdPerSecond })
+            }
+        });
+        if (!usage.lifetimeComplete) {
+            breakdown.push({ kind: "desktop-minutes", ...(usage.laneId === undefined ? {} : { laneId: usage.laneId }),
+                estimatedCostUsd: null, reason: "desktop_lifetime_incomplete", ratesAsOf: null });
+        }
+    }
+    if (args.desktops === undefined && args.desktopMinutes !== undefined) {
         const desktop = estimateDesktopCost(args.desktopMinutes);
         breakdown.push({
             kind: "desktop-minutes",
@@ -3900,9 +3998,12 @@ export function buildCuaCostSummary(args) {
         }
     }
     const estimatedTotalUsd = anyKnown ? round6(knownSum) : null;
-    const note = estimatedTotalUsd === null
+    const estimateNote = estimatedTotalUsd === null
         ? `No priced spend lines this run — every cost line is DECLARED ABSENT (unknown rate / no usage / no duration); nothing is guessed. Add a rate to src/pricing.ts to estimate this model.`
         : `Estimated ${estimatedTotalUsd} USD total${anyNull ? " (LOWER BOUND — some lines unmeasured/unpriced)" : ""}${placeholder ? "; includes PLACEHOLDER rate(s) — confirm before trusting the magnitude" : ""}. Every figure is an ESTIMATE (rates as of ${minRatesAsOf} — the OLDEST contributing rate, since an aggregate is only as fresh as its stalest input), a rate-table multiply, NOT an authoritative provider charge.`;
+    const note = estimateNote + ((args.desktops?.length ?? 0) > 0
+        ? " Desktop compute uses observed CPU/RAM and a host-acquired-to-cleanup span; pre-handle startup, plan fees, credits, and negotiated pricing are excluded."
+        : "");
     return {
         schema: "humanish.run-cost-summary.v1",
         currency: "usd",
@@ -3912,7 +4013,9 @@ export function buildCuaCostSummary(args) {
         placeholder,
         breakdown,
         tokenUsage: { input: sumInput, output: sumOutput, total: sumInput + sumOutput },
-        desktopMinutes: args.desktopMinutes ?? null,
+        desktopMinutes: args.desktops === undefined ? args.desktopMinutes ?? null
+            : args.desktops.some(usage => usage.minutes !== undefined)
+                ? round6(args.desktops.reduce((sum, usage) => sum + (usage.minutes ?? 0), 0)) : null,
         note
     };
 }
@@ -3929,8 +4032,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 = [];
@@ -3999,7 +4102,8 @@ export function buildCuaBundle(args) {
     // Run-level cost ESTIMATE (advisory; omitted when nothing was priced and no sandbox ran).
     const cost = buildCuaCostSummary({
         lanes: args.session ? [{ ...(args.laneId === undefined ? {} : { laneId: args.laneId }), trace: args.session.trace }] : [],
-        desktopMinutes: args.desktopMinutes
+        desktopMinutes: args.desktopMinutes,
+        ...(args.desktopUsage === undefined ? {} : { desktops: [args.desktopUsage] })
     });
     const status = args.inProgress === true
         ? "running"
@@ -4713,16 +4817,17 @@ export function buildCuaFanoutBundle(args) {
         laneId: outcome.spec.laneId
     }));
     // Run-level cost ESTIMATE: one model-token line per lane that ran a session (from its persisted
-    // trace.estimatedCost) + one aggregate desktop-minutes line summing each lane's OWN sandbox span
-    // (per-lane worlds => no shared provisioning to double-count). Omitted on a pure dry-run.
+    // trace.estimatedCost) + a desktop line per owned allocation, priced at its observed resources.
+    // Per-lane worlds have no shared provisioning to double-count. Omitted on a pure dry-run.
     const costLanes = specs
         .map((spec, index) => ({ laneId: spec.laneId, outcome: outcomes?.[index] }))
         .filter((entry) => entry.outcome?.session !== undefined)
         .map((entry) => ({ laneId: entry.laneId, trace: entry.outcome.session.trace }));
-    const desktopMinutesTotal = (outcomes ?? []).some((outcome) => outcome.desktopDurationMs !== undefined)
-        ? (outcomes ?? []).reduce((sum, outcome) => sum + (outcome.desktopDurationMs ?? 0), 0) / 60_000
-        : undefined;
-    const cost = buildCuaCostSummary({ lanes: costLanes, desktopMinutes: desktopMinutesTotal });
+    const desktops = (outcomes ?? []).filter(outcome => outcome.sandboxId !== undefined).map(outcome => ({
+        laneId: outcome.spec.laneId, minutes: desktopSpanToMinutes(outcome.desktopDurationMs),
+        observation: outcome.desktopResources, lifetimeComplete: outcome.killed
+    }));
+    const cost = buildCuaCostSummary({ lanes: costLanes, desktops });
     return {
         schema: RUN_BUNDLE_SCHEMA,
         runId: args.runId,