humanish 0.65.0 → 0.67.0

package/dist/cua-actor-lab.js

@@ -31,8 +31,9 @@ import { adapterScoreFailureMessage, applyBrowserAdapterHooks } from "./adapter-
 import { actorRegistry, isCuaActorDescriptor } from "./actor-registry.js";
 import { CHROMIUM_EVIDENCE_HYGIENE_FLAGS, chromiumEvidenceProfilePreferencesJson } from "./browser-evidence-hygiene.js";
 import { DEFAULT_OPENAI_CU_MODEL } from "./openai-responses-cu.js";
-import { createLocalAgentProvider, detectLocalAgents } from "./local-agent-cli.js";
+import { detectLocalAgents } from "./local-agent-cli.js";
 import { startAppServerSession } from "./local-agent-appserver.js";
+import { startClaudeSession } from "./local-agent-claude-session.js";
 import { createDesktopSandbox, loadE2BDesktopModule } from "./e2b-desktop-launch.js";
 import { probeUrl, readDetachedLog, runDetachedStep, startDetachedProcess } from "./e2b-detached.js";
 import { DEFAULT_SANDBOX_CATCH_PORT, collectCommsThread, collectExternalCommsThread, deployCommsCatch, externalCatchHealthy, externalInboxUrl, refreshInboxSurface, writeInboxSurface } from "./comms-sandbox-catch.js";
@@ -1149,7 +1150,7 @@ async function openDesktopTerminal(desktop, requestTimeoutMs, workdir) {
             // a study that measures our own mojibake against an unconfigured template would be measuring
             // the template. The PRODUCT-side fix (an ASCII fallback when the locale is not UTF-8) is in
             // src/terminal-encoding.ts, and it is the one that matters for real users.
-            `    (cd ${shellSingleQuote(dir)} 2>/dev/null || cd /home/user; DISPLAY=:0 LANG=C.UTF-8 LC_ALL=C.UTF-8 nohup "$candidate" >/dev/null 2>&1 &)`,
+            `    (cd ${shellSingleQuote(dir)} 2>/dev/null || cd /home/user; DISPLAY=:0 LANG=C.UTF-8 LC_ALL=C.UTF-8 HUMANISH_STUDY_PARTICIPANT=1 nohup "$candidate" >/dev/null 2>&1 &)`,
             "    sleep 3",
             '    echo "humanish: opened $candidate"',
             "    exit 0",
@@ -1178,6 +1179,16 @@ async function startDesktopStream(desktop, browserWindowId) {
         await desktop.stream.start({ requireAuth: true });
     }
 }
+// "can't" followed by a PERCEPTION verb describes what the screen showed, not an inability to
+// proceed: "the canvas truncates it so you can't even read the whole thing", "I can't tell from
+// the screen whether the rename is persisted", "so I could not read its full description". Five
+// of five completed live runs on 2026-09-01 (two on drawDB, three on the planted benchmark app)
+// were refused as "not a credible pass" on exactly these sentences, every one a defect report
+// written AFTER the participant reached the goal. The more precisely a participant describes a
+// display defect, the more likely the scan was to refuse the run — the incentive inversion #453
+// fixed for resolved arcs, back in a new shape. "could not complete", "could not connect",
+// "unable to get focus" still count: those name an inability to act.
+const PERCEPTION_AFTER_MODAL = /\b(can'?t|cannot|could ?not|couldn'?t|unable to|wasn'?t able to)\s+(even\s+|quite\s+|really\s+|fully\s+)?(read|see|tell|view|make out|verify|confirm|be sure|be certain|judge|know)\b/g;
 function hasBlockerLanguage(text) {
     return /\b(can'?t|cannot|could not|unable|blocked|blocker|failed|invalid|not set)\b/.test(text)
         || /\b(shows|showing|hit|encountered|returned|got)\b.{0,80}\berror\b/.test(text)
@@ -1193,7 +1204,11 @@ function completionReasonContradictsGoal(reason) {
  *  first — failure narration the participant itself reports as overcome is friction on the
  *  road, not a blocker at the destination (#453). */
 function completionReasonBlocksVerdict(reason) {
-    return hasBlockerLanguage(stripResolvedArcSegments(stripQuotedSpans(stripNegatedNonBlockerPhrases(reason.toLowerCase()))));
+    // Perception phrases are stripped for the VERDICT only: "I could not read the full description"
+    // is friction worth a tally count and a feedback candidate (the friction scan above keeps it),
+    // and it is not a reason to refuse the pass.
+    return hasBlockerLanguage(stripResolvedArcSegments(stripQuotedSpans(stripNegatedNonBlockerPhrases(reason.toLowerCase())))
+        .replace(PERCEPTION_AFTER_MODAL, ""));
 }
 // A failure segment counts as a resolved arc when the recovery is self-reported either in the
 // SAME segment ("the import failed but then went through") or — the common report shape — in the
@@ -1221,6 +1236,10 @@ function stripResolvedArcSegments(text) {
 }
 function stripNegatedNonBlockerPhrases(text) {
     return text
+        // FIRST, before the narrower rules eat the "no blockers" and leave "encountered ... error"
+        // behind: "I encountered no blockers or unclear error output." refused a clean passing run on
+        // 2026-09-01. A verb of encounter followed by "no" negates the whole clause, so drop the clause.
+        .replace(/\b(?:encountered|hit|saw|found|met|had|got|ran into)\s+no\s+[^.!?\n]*/g, " ")
         .replace(/\bno\s+(?:real\s+|remaining\s+|actual\s+)?(?:blocker|blockers|blocking issue|blocking issues|error|errors|failure|failures)\s+(?:was\s+|were\s+)?(?:encountered|observed|found|hit|seen|reported|detected)\b/g, "")
         .replace(/\bwithout\s+(?:a\s+|any\s+)?(?:real\s+|remaining\s+|actual\s+)?(?:blocker|blockers|blocking issue|blocking issues|error|errors|failure|failures)\b/g, "")
         .replace(/\bnot\s+(?:blocked|a blocker|an error|failed)\b/g, "")
@@ -1286,8 +1305,10 @@ export function resolveSelfReportedFriction(session) {
 export async function runCuaLane(spec, deps) {
     const { config, appUrl, cloneRoute, localTreeRoute, serve, subjectRepo, subjectEnvNames } = deps;
     const desktopCliRoute = deps.desktopCliRoute === true;
-    // The local brain, when there is one. `appServer` owns a process, so the lane closes it.
+    // The local brain, when there is one. `appServer` / `claudeSession` own a process, so the lane
+    // closes it.
     let appServer;
+    let claudeSession;
     let localAgentProvider;
     const subjectEnvValues = config.subject.envValues ?? {};
     const targetUrl = spec.targetUrl ?? appUrl;
@@ -1588,11 +1609,14 @@ export async function runCuaLane(spec, deps) {
                 localAgentProvider = appServer.provider;
             }
             else if (deps.localAgent === "claude") {
-                localAgentProvider = createLocalAgentProvider({
-                    agent: "claude",
+                // One session for the whole run, like the codex thread above (#520). The one-shot
+                // provider (createLocalAgentProvider) spawned `claude -p` per turn, and every turn
+                // started with no memory of the last.
+                claudeSession = await startClaudeSession({
                     ...(spec.reasoningEffort === undefined ? {} : { reasoningEffort: spec.reasoningEffort }),
                     ...(config.actors[0]?.model === undefined ? {} : { model: config.actors[0].model })
                 });
+                localAgentProvider = claudeSession.provider;
             }
             // World is ready: release the pipeline gate so the remaining lanes may start.
             provisioned = true;
@@ -1728,6 +1752,7 @@ export async function runCuaLane(spec, deps) {
         // The local brain owns a process. Close it before anything else can throw: a leaked
         // app-server per lane would outlive the run and keep a thread open on the operator's plan.
         appServer?.close();
+        await claudeSession?.close();
         // Stop the mid-run inbox-surface loop FIRST — before the teardown evidence drain below — so the two
         // `cat`s never overlap and the final surface state is deterministic. A surface failure can never
         // block teardown (the loop body is fully try/caught and this await is on its already-caught promise).
@@ -2963,13 +2988,17 @@ async function runCuaActorLabInScope(options) {
                 message: outcome?.sessionError
                     ?? (outcome?.noEngagement
                         ? "Actor took no actions and produced no message (likely a blank/still-loading screen); not a credible goal_satisfied."
-                        : observer.ok
-                            ? outcome?.session?.completionReason === "harness_error"
-                                ? `Computer-use session ended with a harness error: ${outcome.session.reason}`
-                                : outcome?.session?.status !== "passed"
-                                    ? `Computer-use session ended with ${outcome?.session?.status ?? "unknown"}: ${outcome?.session?.reason ?? "no terminal reason"}`
-                                    : "Computer-use lab did not produce a terminal session."
-                            : observer.error?.message ?? "Observer failed for the computer-use lab run.")
+                        // The lane result (toLaneResult) named this refusal; the N=1 envelope fell through to
+                        // "did not produce a terminal session", which is false — it produced one and refused it.
+                        : outcome?.selfReportedBlocker
+                            ? "Actor reported goal_satisfied while its final message described a blocker or asked for missing instructions; not a credible pass."
+                            : observer.ok
+                                ? outcome?.session?.completionReason === "harness_error"
+                                    ? `Computer-use session ended with a harness error: ${outcome.session.reason}`
+                                    : outcome?.session?.status !== "passed"
+                                        ? `Computer-use session ended with ${outcome?.session?.status ?? "unknown"}: ${outcome?.session?.reason ?? "no terminal reason"}`
+                                        : "Computer-use lab did not produce a terminal session."
+                                : observer.error?.message ?? "Observer failed for the computer-use lab run.")
             };
         }
         const failingLane = (outcomes ?? []).find((outcome) => !laneOk(outcome));
@@ -3117,6 +3146,15 @@ function buildSingleLaneBundle(args) {
         captureRedaction: args.redactScreenshots ? "blurred" : "raw",
         ...(outcome?.session ? { session: outcome.session } : {}),
         ...(outcome?.sessionError ? { sessionError: outcome.sessionError } : {}),
+        ...(outcome === undefined
+            ? {}
+            : {
+                credibility: {
+                    noEngagement: outcome.noEngagement === true,
+                    selfReportedBlocker: outcome.selfReportedBlocker === true,
+                    reportedFriction: outcome.reportedFriction === true
+                }
+            }),
         source: args.source,
         ...(args.inProgress === undefined ? {} : { inProgress: args.inProgress }),
         ...(args.subjectProvenance === undefined ? {} : { subjectProvenance: args.subjectProvenance }),
@@ -3871,22 +3909,36 @@ export function buildCuaBundle(args) {
     const singleStudyTasks = args.inProgress !== true && args.session?.trace.taskFunnel !== undefined
         ? aggregateTaskFunnels([args.session.trace.taskFunnel])
         : undefined;
+    // What happened to the participant, as the LANE judged it — the same rule the fan-out roll-up
+    // applies (participantStatusForOutcome). Before #476 this read the actor's own status, so a
+    // run the lane refused as "not a credible pass" was written up as verdict pass, 1/1 reached
+    // the goal, and every projection of the bundle (Observer tally, `runs`, the status index)
+    // repeated it. Found on a real drawDB run whose participant wrote "Blocked after partial
+    // completion".
+    const participantStatus = args.session === undefined
+        ? undefined
+        : participantStatusForCredibility(args.session.status, args.credibility);
+    const credibilityNote = args.session === undefined || participantStatus === args.session.status
+        ? undefined
+        : args.credibility?.noEngagement === true
+            ? "Not counted as a pass: the participant took no actions and said nothing."
+            : "Not counted as a pass: the participant's final message described a blocker.";
     const review = {
         schema: REVIEW_SCHEMA,
         verdict: args.inProgress === true
             ? "contract_proof_only"
-            : args.session
-                ? verdictForStatus(args.session.status)
+            : participantStatus !== undefined
+                ? verdictForStatus(participantStatus)
                 : args.sessionError
                     ? "fail"
                     : "contract_proof_only",
         // One lane is still a study with a denominator of one, and saying so keeps a single-lane
         // result from being read as though it generalized.
-        ...(args.session && args.inProgress !== true
-            ? { participants: tallyParticipantOutcomes([args.session.status]) }
+        ...(participantStatus !== undefined && args.inProgress !== true
+            ? { participants: tallyParticipantOutcomes([participantStatus], [args.credibility?.reportedFriction === true]) }
             : {}),
         ...(singleStudyTasks === undefined ? {} : { tasks: singleStudyTasks }),
-        summary: reason,
+        summary: credibilityNote === undefined ? reason : `${credibilityNote} ${reason}`,
         gaps: args.session || args.sessionError
             ? []
             : args.inProgress === true
@@ -4309,7 +4361,10 @@ export function buildCuaFanoutBundle(args) {
         // it — but `reachedGoal` was reading the trace status directly, so one run could be both
         // "not a passed lane" AND "1/1 reached the goal". The headline number a researcher reads
         // first was the dishonest one. Found by a provider bug that ended a study on turn one.
-        terminalOutcomes.map((outcome) => (outcome.noEngagement === true ? "incomplete" : outcome.session.status)), 
+        terminalOutcomes.map((outcome) => participantStatusForCredibility(outcome.session.status, {
+            noEngagement: outcome.noEngagement === true,
+            selfReportedBlocker: outcome.selfReportedBlocker === true
+        })), 
         // A participant who reached the goal AND told you the road there was broken is the most
         // useful result a study produces; reporting only the outcome would bury it.
         terminalOutcomes.map((outcome) => outcome.reportedFriction === true))
@@ -4486,6 +4541,22 @@ function providerResourcesForOutcome(args) {
             }
         }];
 }
+/**
+ * The status a participant is TALLIED under, given what the lane made of the session. A
+ * goal_satisfied claim with zero engagement is a session that ran out before anything happened;
+ * one whose final message describes a blocker is a participant who could not proceed and said so.
+ * Both keep their trace status (the claim is evidence); neither is a participant who reached the
+ * goal. One rule for the single lane and the fan-out roll-up (#476).
+ */
+export function participantStatusForCredibility(status, credibility) {
+    if (status !== "passed" || credibility === undefined)
+        return status;
+    if (credibility.noEngagement)
+        return "incomplete";
+    if (credibility.selfReportedBlocker)
+        return "blocked";
+    return status;
+}
 function verdictForStatus(status) {
     switch (status) {
         case "passed":