humanish 0.133.1 → 0.134.0

package/CHANGELOG.md

@@ -8,6 +8,19 @@ The Unreleased section holds the full notes for the next version until it is tag
 
 ## Unreleased
 
+## 0.134.0: Participants held to an end keep reloading until it (2026-10-14)
+
+humanish 0.134.0 keeps a participant held to a scheduled end running when it reloads a page that
+changes only on reload. 20 reloads in a row on an unchanged screen ended its session as `gave_up`.
+Now humanish watches the screen after each further reload, as after a wait, so a participant that
+reloads every few seconds costs about what one that waits costs. In 60-minute live runs with a
+persona that refreshes every few seconds, 0.133.1 ended 3 of 4 within 7 minutes; this release ran
+all 4 to their end at a median $3.23 an hour. Trace files are now written as compact JSON, about a
+quarter smaller, and a run whose trace still passes the 32 MiB read limit finishes and grades
+`local_only` where it failed.
+
+[Release notes](https://github.com/danielgwilson/humanish/releases/tag/v0.134.0)
+
 ## 0.133.1: Hosted runs keep writing run.json past 512 MiB of traces (2026-10-14)
 
 humanish 0.133.1 keeps a hosted run writing run.json once its finished participants' traces

package/dist/actors/computer-use/loop/actions.d.ts

@@ -21,6 +21,8 @@ export interface ActionBatch {
      * stopped the batch.
      */
     readonly hint: string | undefined;
+    /** An action of the batch other than a wait or screenshot may have reached the desktop. */
+    readonly sent: boolean;
 }
 /**
  * The waits of a turn the loop watched in place of sending them to the desktop (watch.ts): the

package/dist/actors/computer-use/loop/actions.js

@@ -128,6 +128,12 @@ export async function runActionBatch(session, actions, watched) {
     const { actionHistory, trace } = session;
     const notes = [];
     const hint = () => (notes.length === 0 ? undefined : notes.join(" "));
+    const attemptsBefore = trace.counts.materialActions;
+    const done = () => ({
+        execution,
+        hint: hint(),
+        sent: trace.counts.materialActions > attemptsBefore,
+    });
     const idleTurn = isIdleTurn(actions);
     let waits = 0;
     for (const [index, requested] of actions.entries()) {
@@ -187,13 +193,13 @@ export async function runActionBatch(session, actions, watched) {
                 const { reason } = error;
                 trace.record("notice", () => notice("warn", "action rejected before dispatch", session.redactNarration(`action: ${title}; code: action_rejected; disposition: not_dispatched;${reason === undefined ? "" : ` reason: ${reason};`} remaining batch actions not dispatched: ${actions.length - index - 1}`)));
                 notes.push(rejectedActionHint(title, reason));
-                return { execution, hint: hint() };
+                return done();
             }
             if (isComputerUseExecutorError(error) || !isCommandExitError(error))
                 throw error;
-            // A skipped action changes nothing on screen, so a persistently-failing run makes no
-            // progress and still terminates via the idle/no-progress backstop (gave_up),
-            // never a silent actor_error and never an infinite loop.
+            // A skipped action changes nothing on screen, so a run that repeats a failing action makes
+            // no progress and ends through the no-progress backstop (gave_up), also when the
+            // participant is held to its scheduled end (backstop.ts consecutiveUnsent).
             recordCommandFailure(session, title, error);
             continue;
         }
@@ -212,7 +218,7 @@ export async function runActionBatch(session, actions, watched) {
             ...(requested.kind === "wait" && requested.ms !== undefined ? { namedMs: requested.ms } : {}),
         }));
     }
-    return { execution, hint: hint() };
+    return done();
 }
 function countAttempt(session, action, title, status) {
     if (!isMaterialAttempt(action, status))

package/dist/actors/computer-use/loop/backstop.d.ts

@@ -24,9 +24,27 @@ export interface Backstop {
     readonly recentFingerprints: readonly string[];
     readonly consecutiveIdle: number;
     readonly consecutiveNoProgress: number;
+    /**
+     * No-progress turns in a row whose actions all failed or were refused before reaching the
+     * desktop. They end a held participant's session at noProgressSteps, since a reload that never
+     * reached the desktop is not how it waits; one such turn in a longer streak does not.
+     */
+    readonly consecutiveUnsent: number;
     readonly idleProgressForgivenessUsed: number;
+    /** A no-progress streak in this session reached noProgressSteps. */
+    readonly reachedLimit: boolean;
 }
 export declare function startBackstop(observation: CuaObservation): Backstop;
+/**
+ * Whether a turn that acts repeats a recent action past the no-progress limit: the streak before it
+ * is one short of the limit or longer, or, once a streak in the session reached the limit, the turn
+ * before it was a no-progress turn. The loop watches the screen after such a turn of a held
+ * participant, since its streak no longer ends its session. A change a reload brings, or an item
+ * the participant opens, resets the streak; without the second case each one would give the
+ * participant noProgressSteps more requests back to back. A repeat after a turn that changed the
+ * screen, such as a second scroll, is not past the limit.
+ */
+export declare function repeatsPastLimit(backstop: Backstop, actions: readonly CuaAction[], limits: BackstopLimits): boolean;
 export interface BackstopLimits {
     readonly idleSteps: number;
     readonly noProgressSteps: number;
@@ -43,8 +61,9 @@ export interface BackstopStep {
 /**
  * Fold one acted turn and the observation after it into the backstop. `waitingIsTheTask` says the
  * participant has a scheduled end still to come: waiting for it is its job, so an idle turn counts
- * toward neither streak and earns no nudge. A turn that acts is folded as usual. `screenChanged`
- * says the turn's watch woke on a change it saw, which the progress key can miss.
+ * toward neither streak and earns no nudge, and the no-progress streak does not end the session.
+ * A turn that acts is otherwise folded as usual. `screenChanged` says the turn's watch woke on a
+ * change it saw, which the progress key can miss.
  */
 export declare function advanceBackstop(previous: Backstop, turn: {
     actions: readonly CuaAction[];
@@ -52,4 +71,6 @@ export declare function advanceBackstop(previous: Backstop, turn: {
     heardNewSpeech: boolean;
     waitingIsTheTask?: boolean;
     screenChanged?: boolean;
+    /** An action of the turn may have reached the desktop (ActionBatch.sent). */
+    sent: boolean;
 }, limits: BackstopLimits): BackstopStep;

package/dist/actors/computer-use/loop/backstop.js

@@ -119,14 +119,38 @@ export function startBackstop(observation) {
         recentFingerprints: [],
         consecutiveIdle: 0,
         consecutiveNoProgress: 0,
+        consecutiveUnsent: 0,
         idleProgressForgivenessUsed: 0,
+        reachedLimit: false,
     };
 }
+function repeatsRecentAction(backstop, actions) {
+    const fingerprint = actionFingerprint(actions);
+    return fingerprint.length > 0 && backstop.recentFingerprints.includes(fingerprint);
+}
+/**
+ * Whether a turn that acts repeats a recent action past the no-progress limit: the streak before it
+ * is one short of the limit or longer, or, once a streak in the session reached the limit, the turn
+ * before it was a no-progress turn. The loop watches the screen after such a turn of a held
+ * participant, since its streak no longer ends its session. A change a reload brings, or an item
+ * the participant opens, resets the streak; without the second case each one would give the
+ * participant noProgressSteps more requests back to back. A repeat after a turn that changed the
+ * screen, such as a second scroll, is not past the limit.
+ */
+export function repeatsPastLimit(backstop, actions, limits) {
+    const limit = backstop.reachedLimit
+        ? Math.min(2, limits.noProgressSteps)
+        : limits.noProgressSteps;
+    return (!isIdleTurn(actions) &&
+        backstop.consecutiveNoProgress + 1 >= limit &&
+        repeatsRecentAction(backstop, actions));
+}
 /**
  * Fold one acted turn and the observation after it into the backstop. `waitingIsTheTask` says the
  * participant has a scheduled end still to come: waiting for it is its job, so an idle turn counts
- * toward neither streak and earns no nudge. A turn that acts is folded as usual. `screenChanged`
- * says the turn's watch woke on a change it saw, which the progress key can miss.
+ * toward neither streak and earns no nudge, and the no-progress streak does not end the session.
+ * A turn that acts is otherwise folded as usual. `screenChanged` says the turn's watch woke on a
+ * change it saw, which the progress key can miss.
  */
 export function advanceBackstop(previous, turn, limits) {
     const idle = isIdleTurn(turn.actions);
@@ -151,9 +175,11 @@ export function advanceBackstop(previous, turn, limits) {
     // just tried. An agent doing varied work is never counted stuck, however blind the hash is;
     // an agent re-clicking the same dead control trips it as fast as it did before, arguably
     // faster, since that is the actual signature of being stuck.
-    const fingerprint = actionFingerprint(turn.actions);
-    const repeatingRecentAction = fingerprint.length > 0 && previous.recentFingerprints.includes(fingerprint);
-    const recentFingerprints = [...previous.recentFingerprints, fingerprint].slice(-ACTION_REPEAT_WINDOW);
+    const repeatingRecentAction = repeatsRecentAction(previous, turn.actions);
+    const recentFingerprints = [
+        ...previous.recentFingerprints,
+        actionFingerprint(turn.actions),
+    ].slice(-ACTION_REPEAT_WINDOW);
     // Corroboration governs the frame-staleness backstop only. The idle backstop below is a direct
     // behavioral signal already (the agent took nothing but screenshots and waits), so it keeps
     // reading the frame on its own: a repeated screenshot is exactly what an idle streak is, and
@@ -177,6 +203,7 @@ export function advanceBackstop(previous, turn, limits) {
         consecutiveIdle += 1;
     }
     const consecutiveNoProgress = progressed ? 0 : previous.consecutiveNoProgress + 1;
+    const consecutiveUnsent = progressed || turn.sent ? 0 : previous.consecutiveUnsent + 1;
     // An unchanged screen can be legitimate waiting (for example, a shared-world lobby).
     // Recovery may suggest another approach, but must not instruct early abandonment while
     // the task still calls for waiting. The counters, time and spend guards own hard stops.
@@ -196,10 +223,14 @@ export function advanceBackstop(previous, turn, limits) {
             "If your task calls for waiting, you may continue within the remaining session time. " +
             "When the relevant controls become actionable, continue your task; describe any blocker you actually encounter.");
     }
+    // A held participant past the no-progress limit keeps its session: on a page that shows new items
+    // only after a reload, reloading an unchanged screen is how it waits. Repeats that never reached
+    // the desktop still end it.
+    const stuckTurns = turn.waitingIsTheTask === true ? consecutiveUnsent : consecutiveNoProgress;
     const tripReason = consecutiveIdle >= limits.idleSteps
         ? `gave up: ${consecutiveIdle} consecutive turns with no material UI action (only screenshot/wait)`
-        : consecutiveNoProgress >= limits.noProgressSteps
-            ? `gave up: ${consecutiveNoProgress} consecutive turns that repeated a recent action on an unchanged UI state`
+        : stuckTurns >= limits.noProgressSteps
+            ? `gave up: ${stuckTurns} consecutive turns that repeated a recent action on an unchanged UI state`
             : undefined;
     return {
         backstop: {
@@ -207,7 +238,9 @@ export function advanceBackstop(previous, turn, limits) {
             recentFingerprints,
             consecutiveIdle,
             consecutiveNoProgress,
+            consecutiveUnsent,
             idleProgressForgivenessUsed,
+            reachedLimit: previous.reachedLimit || consecutiveNoProgress >= limits.noProgressSteps,
         },
         idle,
         progressed,

package/dist/actors/computer-use/loop/session.d.ts

@@ -2,6 +2,7 @@ import type { ActorTraceItem, ParticipantDeclaredOutcome, ParticipantImpressions
 import type { AffordanceObservation } from "../../affordance.js";
 import { TaskTracker } from "../../../study/tasks.js";
 import type { DebriefTrigger, Stop } from "./ending.js";
+import { StreakRecord } from "./streak.js";
 import { TraceRecorder } from "./trace.js";
 import type { CuaExecutor, CuaProvider, CuaSafetyCheck, LoopRunOptions } from "./types.js";
 import { UsageLedger } from "./usage.js";
@@ -55,6 +56,8 @@ export declare class LoopSession {
     readonly trace: TraceRecorder;
     readonly usage: UsageLedger;
     readonly taskTracker: TaskTracker | undefined;
+    /** The no-progress streak a held participant is in, for the trace. */
+    readonly streak: StreakRecord;
     readonly actionHistory: ActionHistory;
     /** What the loop was doing, for failure notices. */
     phase: string;

package/dist/actors/computer-use/loop/session.js

@@ -1,4 +1,5 @@
 import { TaskTracker } from "../../../study/tasks.js";
+import { StreakRecord } from "./streak.js";
 import { TraceRecorder } from "./trace.js";
 import { UsageLedger } from "./usage.js";
 import { resolveWaitSettings } from "../wait.js";
@@ -47,6 +48,8 @@ export class LoopSession {
     usage;
     // The funnel is recorded, never consulted: task completion does not steer the loop.
     taskTracker;
+    /** The no-progress streak a held participant is in, for the trace. */
+    streak = new StreakRecord(this);
     actionHistory = {
         lastActionTitle: undefined,
         lastMaterialActionTitle: undefined,

package/dist/actors/computer-use/loop/streak.d.ts

@@ -0,0 +1,18 @@
+import type { LoopSession } from "./session.js";
+/** The title of the notice that records one streak. */
+export declare const STREAK_TITLE = "repeated an action on an unchanged screen";
+/** The streak the participant is in, recorded when a turn ends it or the session ends. */
+export declare class StreakRecord {
+    private readonly session;
+    private open;
+    constructor(session: LoopSession);
+    /**
+     * Fold one turn's streak length, the backstop's consecutiveNoProgress after the turn. A held
+     * participant's idle turn leaves the length as it was, and the streak's time span with it. Only
+     * the streak of a participant with a scheduled end is followed: any other one ends the session
+     * at noProgressSteps. The end may have passed, since the turn that reaches it is still counted.
+     */
+    fold(turns: number): void;
+    /** Record the open streak when it reached noProgressSteps. */
+    close(): void;
+}

package/dist/actors/computer-use/loop/streak.js

@@ -0,0 +1,47 @@
+import { notice } from "./trace.js";
+// The record of a held participant's no-progress streaks. Past noProgressSteps a streak no longer
+// ends the session of a participant held to its scheduled end (backstop.ts), so the trace says how
+// many turns it had and when: analysis reads the notice as friction, and the review lists it.
+/** The title of the notice that records one streak. */
+export const STREAK_TITLE = "repeated an action on an unchanged screen";
+/** The streak the participant is in, recorded when a turn ends it or the session ends. */
+export class StreakRecord {
+    session;
+    open;
+    constructor(session) {
+        this.session = session;
+    }
+    /**
+     * Fold one turn's streak length, the backstop's consecutiveNoProgress after the turn. A held
+     * participant's idle turn leaves the length as it was, and the streak's time span with it. Only
+     * the streak of a participant with a scheduled end is followed: any other one ends the session
+     * at noProgressSteps. The end may have passed, since the turn that reaches it is still counted.
+     */
+    fold(turns) {
+        const { open, session } = this;
+        const end = session.settings.clock?.end;
+        if (turns === 0)
+            this.close();
+        else if (open?.turns !== turns && end !== undefined && end.kind !== "session_cap") {
+            const now = session.now();
+            this.open = { turns, fromMs: open?.fromMs ?? now, toMs: now };
+        }
+    }
+    /** Record the open streak when it reached noProgressSteps. */
+    close() {
+        const { open, session } = this;
+        this.open = undefined;
+        if (open === undefined || open.turns < session.noProgressSteps)
+            return;
+        const at = (ms) => sessionClock(ms - session.startedAtMs);
+        session.trace.record("notice", () => notice("warn", STREAK_TITLE, `${open.turns} turns in a row repeated a recent action on an unchanged screen, from ${at(open.fromMs)} to ${at(open.toMs)} into the session. The participant is held to its scheduled end, so ${session.noProgressSteps} such turns did not end its session, and from then on the screen was watched after each one before the next request.`));
+    }
+}
+/** `40:35`, or `1:02:03` from an hour. */
+function sessionClock(ms) {
+    const seconds = Math.floor(Math.max(0, ms) / 1_000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const ss = String(seconds % 60).padStart(2, "0");
+    return hours > 0 ? `${hours}:${String(minutes % 60).padStart(2, "0")}:${ss}` : `${minutes}:${ss}`;
+}

package/dist/actors/computer-use/loop/types.d.ts

@@ -312,7 +312,11 @@ export interface CuaLoopOptions {
     signal?: AbortSignal;
     /** Idle streak (no material action) that trips the backstop. Default 24. */
     idleSteps?: number;
-    /** No-progress streak that trips the backstop. Default 20. */
+    /**
+     * No-progress streak that trips the backstop. Default 20. It does not end a participant held to
+     * its scheduled end: from this many repeats on, the screen is watched after each further one that
+     * follows a turn with no progress.
+     */
     noProgressSteps?: number;
     /**
      * The longest one `wait` action lasts, in ms: the study's actor.maxWaitMs. In a turn with another

package/dist/actors/computer-use/loop/watch.d.ts

@@ -4,7 +4,7 @@ import { type Stop } from "./ending.js";
 import type { DesktopObserver } from "./observation.js";
 import type { LoopSession } from "./session.js";
 import type { CuaAction, CuaObservation } from "./types.js";
-/** A watch that ran for one idle turn: how it ended, and what the loop does next. */
+/** A watch that ran for one turn: how it ended, and what the loop does next. */
 export interface Watched {
     readonly wake: ActorWatch["wake"];
     /**
@@ -23,20 +23,38 @@ export interface Watched {
     readonly waits: WatchedWaits;
 }
 /**
- * The watches of one participant's idle turns. Between turns it keeps the run of idle turns the
+ * The watches of one participant's turns. Between turns it keeps the run of watched turns the
  * doubling counts: a watch that ended at its limit or on a small change makes the next one in the
- * run longer, and a turn with another action ends the run.
+ * run longer, and a turn with another action that is not watched ends the run.
  */
 export declare class IdleWatcher {
     private readonly session;
     private readonly observer;
     /** The limit of the run's last watch, while that watch ended at its limit or on a small change. */
     private grownFromMs;
+    /** The last turn only waited or took screenshots. */
+    private quiet;
     constructor(session: LoopSession, observer: DesktopObserver);
     /**
      * Watch the screen in place of this turn's waits. Undefined, with nothing run, for a turn with
      * another action, which ends the run, or with no wait time (screenshots only, or waits of 0 ms),
-     * which leaves the run as it is. `reference` is the observation the participant chose to wait on.
+     * which leaves the run as it is. A participant held to its scheduled end is watched for a turn
+     * with no wait time after another turn that only waited or took screenshots, as for a wait with
+     * no length: it waits for its end, and without the watch it would send its requests back to back.
+     * The first such turn, at the start or after an action, is sent at once, so a participant that
+     * looks again after acting does not wait idleWaitMs for it. `reference` is the observation the
+     * participant chose to wait on.
      */
     watch(turnNumber: number, reference: CuaObservation, actions: readonly CuaAction[]): Promise<Watched | undefined>;
+    /**
+     * Watch the screen after a held participant's turn that repeated a recent action past its
+     * no-progress limit (repeatsPastLimit), as after a wait with no length, before its next request.
+     * The run goes on, so a participant that reloads an unchanged page turn after turn waits as long
+     * as one that only waits. `reference` is the observation the participant acted on, so a change
+     * its action made wakes it. Undefined, with nothing run, when no action of the turn reached the
+     * desktop (`sent`, ActionBatch.sent): such a repeat is not how the participant waits, and
+     * noProgressSteps of them end its session (backstop.ts consecutiveUnsent).
+     */
+    watchAfterRepeat(turnNumber: number, reference: CuaObservation, sent: boolean): Promise<Watched | undefined>;
+    private run;
 }

package/dist/actors/computer-use/loop/watch.js

@@ -2,20 +2,22 @@ import { watchFrames, } from "../../../evidence/frame-change.js";
 import { plural } from "../../../run/text.js";
 import { isIdleTurn } from "./actions.js";
 import { progressKeyOf } from "./backstop.js";
-import { clockEndStop } from "./clock.js";
+import { clockEndStop, heldToScheduledEnd } from "./clock.js";
 import { timeLimit } from "./ending.js";
 import { CuaAbortError, CuaStallError, raceSessionDeadline } from "./race.js";
 import { spendStop } from "./spend.js";
 /**
- * The watches of one participant's idle turns. Between turns it keeps the run of idle turns the
+ * The watches of one participant's turns. Between turns it keeps the run of watched turns the
  * doubling counts: a watch that ended at its limit or on a small change makes the next one in the
- * run longer, and a turn with another action ends the run.
+ * run longer, and a turn with another action that is not watched ends the run.
  */
 export class IdleWatcher {
     session;
     observer;
     /** The limit of the run's last watch, while that watch ended at its limit or on a small change. */
     grownFromMs;
+    /** The last turn only waited or took screenshots. */
+    quiet = false;
     constructor(session, observer) {
         this.session = session;
         this.observer = observer;
@@ -23,11 +25,18 @@ export class IdleWatcher {
     /**
      * Watch the screen in place of this turn's waits. Undefined, with nothing run, for a turn with
      * another action, which ends the run, or with no wait time (screenshots only, or waits of 0 ms),
-     * which leaves the run as it is. `reference` is the observation the participant chose to wait on.
+     * which leaves the run as it is. A participant held to its scheduled end is watched for a turn
+     * with no wait time after another turn that only waited or took screenshots, as for a wait with
+     * no length: it waits for its end, and without the watch it would send its requests back to back.
+     * The first such turn, at the start or after an action, is sent at once, so a participant that
+     * looks again after acting does not wait idleWaitMs for it. `reference` is the observation the
+     * participant chose to wait on.
      */
     async watch(turnNumber, reference, actions) {
         const { session } = this;
-        if (!isIdleTurn(actions)) {
+        const quietBefore = this.quiet;
+        this.quiet = isIdleTurn(actions);
+        if (!this.quiet) {
             this.grownFromMs = undefined;
             return undefined;
         }
@@ -46,9 +55,43 @@ export class IdleWatcher {
             namedMs += ms;
             return [ms];
         });
-        const plannedMs = lengths.reduce((sum, ms) => sum + ms, 0);
-        if (plannedMs === 0)
+        if (lengths.every((ms) => ms === 0) && !(quietBefore && heldToScheduledEnd(session)))
+            return undefined;
+        return this.run(turnNumber, reference, {
+            lengths,
+            askedMs: asked.reduce((sum, ms) => sum + ms, 0),
+            ...(lengths.length > 0
+                ? { lead: "Your wait" }
+                : {
+                    lead: "The wait before your screenshot",
+                    unasked: "The turn took only screenshots after a turn of only waits or screenshots, and the participant is held to its scheduled end, so the screen was watched as for a wait with no length.",
+                }),
+        });
+    }
+    /**
+     * Watch the screen after a held participant's turn that repeated a recent action past its
+     * no-progress limit (repeatsPastLimit), as after a wait with no length, before its next request.
+     * The run goes on, so a participant that reloads an unchanged page turn after turn waits as long
+     * as one that only waits. `reference` is the observation the participant acted on, so a change
+     * its action made wakes it. Undefined, with nothing run, when no action of the turn reached the
+     * desktop (`sent`, ActionBatch.sent): such a repeat is not how the participant waits, and
+     * noProgressSteps of them end its session (backstop.ts consecutiveUnsent).
+     */
+    async watchAfterRepeat(turnNumber, reference, sent) {
+        this.quiet = false;
+        if (!sent)
             return undefined;
+        return this.run(turnNumber, reference, {
+            lengths: [],
+            askedMs: 0,
+            lead: "The wait after your last action",
+            unasked: "The turn repeated a recent action on an unchanged screen past the no-progress limit and the participant is held to its scheduled end, so the screen was watched before the next request.",
+        });
+    }
+    async run(turnNumber, reference, asked) {
+        const { session } = this;
+        const { lengths, unasked } = asked;
+        const plannedMs = lengths.reduce((sum, ms) => sum + ms, 0);
         const capMs = Math.max(plannedMs, session.waits.watchMaxMs);
         // Never shorter than idleWaitMs, so a participant naming a few milliseconds on a static screen
         // does not send requests back to back, and never shorter than the turn's own planned length, so
@@ -63,21 +106,29 @@ export class IdleWatcher {
         // watch short.
         const grows = ending.wake === "limit" || (ending.seen?.verdict === "settled" && ending.seen.small);
         this.grownFromMs = grows ? limitMs : undefined;
+        const watch = {
+            limitMs,
+            askedMs: asked.askedMs,
+            wake: ending.wake,
+            looks: ending.looks,
+            ...(ending.area === undefined ? {} : { area: { ...ending.area } }),
+        };
+        if (unasked !== undefined)
+            session.trace.record("notice", () => ({
+                lifecycle: "completed",
+                title: "watched the screen",
+                text: unasked,
+                watch: { ...watch },
+            }));
         return {
             wake: ending.wake,
             ...(ending.observation === undefined ? {} : { observation: ending.observation }),
             ...(ending.stop === undefined ? {} : { stop: ending.stop }),
-            hint: hintFor(ending),
+            hint: hintFor(ending, asked.lead),
             waits: {
                 ...splitWatch(lengths, limitMs, ending.ms),
                 sessionEnded: ending.stop !== undefined,
-                watch: {
-                    limitMs,
-                    askedMs: asked.reduce((sum, ms) => sum + ms, 0),
-                    wake: ending.wake,
-                    looks: ending.looks,
-                    ...(ending.area === undefined ? {} : { area: { ...ending.area } }),
-                },
+                watch,
             },
         };
     }
@@ -198,17 +249,21 @@ function compareLook(frames, referenceKey, observation, atMs) {
 }
 /**
  * Each wait's part of a watch that lasted `ms`: the limit is shared among the waits in proportion
- * to their planned lengths, and the watch covers them in order. Later waits get 0.
+ * to their planned lengths, and the watch covers them in order. Later waits get 0. Waits that all
+ * planned 0 ms (a held participant's, watched as a wait with no length) give the first all of it.
  */
-function splitWatch(lengths, limitMs, ms) {
+function splitWatch(planned, limitMs, ms) {
+    const lengths = planned.every((length) => length === 0)
+        ? planned.map((_, index) => (index === 0 ? 1 : 0))
+        : planned;
     const plannedMs = lengths.reduce((sum, length) => sum + length, 0);
     const starts = [];
     const ends = [];
-    let planned = 0;
+    let sharedMs = 0;
     for (const length of lengths) {
-        starts.push(Math.floor((limitMs * planned) / plannedMs));
-        planned += length;
-        ends.push(Math.floor((limitMs * planned) / plannedMs));
+        starts.push(Math.floor((limitMs * sharedMs) / plannedMs));
+        sharedMs += length;
+        ends.push(Math.floor((limitMs * sharedMs) / plannedMs));
     }
     const found = ends.findIndex((shareEnd, index) => shareEnd > starts[index] && ms <= shareEnd);
     const endedOn = found === -1 ? lengths.length - 1 : found;
@@ -218,13 +273,14 @@ function splitWatch(lengths, limitMs, ms) {
     };
 }
 /**
- * The next request's note. A clock ending says only how long the wait lasted. A
- * small change is named by its place, so a participant is not told the screen changed when what
- * changed was a counter or a timestamp. The note says nothing of the next wait's length: a
- * participant told it names that length and keeps waiting.
+ * The next request's note, its subject `lead` naming the wait ("Your wait", or for a watch no wait
+ * asked for, the wait before the screenshot or after the action). A clock ending says only how
+ * long the wait lasted. A small change is named by its place, so a participant is not told the
+ * screen changed when what changed was a counter or a timestamp. The note says nothing of the next
+ * wait's length: a participant told it names that length and keeps waiting.
  */
-function hintFor(ending) {
-    const lasted = `Your wait lasted ${duration(ending.ms)}`;
+function hintFor(ending, lead) {
+    const lasted = `${lead} lasted ${duration(ending.ms)}`;
     const { seen } = ending;
     switch (ending.wake) {
         case "changed":

package/dist/actors/computer-use/loop.js

@@ -1,7 +1,7 @@
 import { closingReportSchema } from "../closing-report.js";
 import { ComputerUseProviderError } from "./provider-error.js";
 import { runActionBatch } from "./loop/actions.js";
-import { advanceBackstop, startBackstop, } from "./loop/backstop.js";
+import { advanceBackstop, repeatsPastLimit, startBackstop, } from "./loop/backstop.js";
 import { clockEndStop, clockHint, heldToScheduledEnd } from "./loop/clock.js";
 import { requestDebrief } from "./loop/debrief.js";
 import * as stops from "./loop/ending.js";
@@ -62,6 +62,7 @@ export async function runComputerUseLoopWithTaps(options) {
     catch (error) {
         stop = session.conclude(stops.stopForError(session, error));
     }
+    session.streak.close();
     // A structured stop earns the debrief even if recording its evidence then failed.
     const debrief = session.debriefTrigger === undefined
         ? undefined
@@ -144,12 +145,21 @@ async function runTurns(session, conversation) {
                 ? { ...ended, debriefTrigger: { kind: "participant_end", observation } }
                 : ended;
         }
-        const watched = await watcher.watch(turnNumber, observation, turn.actions);
-        const batch = await runActionBatch(session, turn.actions, watched?.waits);
+        const limits = { idleSteps: session.idleSteps, noProgressSteps: session.noProgressSteps };
+        const repeat = repeatsPastLimit(backstop, turn.actions, limits) && heldToScheduledEnd(session);
+        const waited = repeat ? undefined : await watcher.watch(turnNumber, observation, turn.actions);
+        const batch = await runActionBatch(session, turn.actions, waited?.waits);
+        const watched = repeat
+            ? await watcher.watchAfterRepeat(turnNumber, observation, batch.sent)
+            : waited;
         conversation.previousExecution = batch.execution;
         // An earlier reply's unknown usage still stops the session before its closing request.
-        if (watched?.stop !== undefined)
+        if (watched?.stop !== undefined) {
+            // The repeat was sent before its watch ended the session, so its streak counts it.
+            if (repeat)
+                session.streak.fold(backstop.consecutiveNoProgress + 1);
             return unknownSpendStop(session) ?? watched.stop;
+        }
         const checkpoint = await observer.checkpoint(turnNumber, watched?.observation);
         if ("stop" in checkpoint)
             return checkpoint.stop;
@@ -158,11 +168,12 @@ async function runTurns(session, conversation) {
             actions: turn.actions,
             observation,
             heardNewSpeech: observer.heardNewSpeech,
+            sent: batch.sent,
             waitingIsTheTask: heldToScheduledEnd(session),
             screenChanged: watched?.wake === "changed" ||
                 watched?.wake === "speech" ||
                 watched?.wake === "condition",
-        }, { idleSteps: session.idleSteps, noProgressSteps: session.noProgressSteps });
+        }, limits);
         backstop = step.backstop;
         const stalled = applyBackstop(session, conversation, step, [
             watched?.hint,
@@ -187,7 +198,7 @@ function keepWorking(session, conversation, backstop, observation) {
     conversation.askedToEnd = true;
     // The turn executed nothing, so the next request acknowledges nothing.
     conversation.previousExecution = undefined;
-    const step = advanceBackstop(backstop, { actions: [], observation, heardNewSpeech: false }, { idleSteps: session.idleSteps, noProgressSteps: session.noProgressSteps });
+    const step = advanceBackstop(backstop, { actions: [], observation, heardNewSpeech: false, sent: false }, { idleSteps: session.idleSteps, noProgressSteps: session.noProgressSteps });
     const stalled = applyBackstop(session, conversation, step, []);
     return stalled === undefined ? { backstop: step.backstop } : { stop: stalled };
 }
@@ -201,6 +212,7 @@ function applyBackstop(session, conversation, step, turnHints) {
         session.trace.bump("idleTurns");
     if (!step.progressed)
         session.trace.bump("noProgressTurns");
+    session.streak.fold(step.backstop.consecutiveNoProgress);
     const hints = [...turnHints.filter((hint) => hint !== undefined), ...step.hints];
     if (hints.length > 0)
         conversation.contextHint = hints.join(" ");

package/dist/actors/contract.d.ts

@@ -88,7 +88,9 @@ export interface ActorTraceItem {
      *  the observation read no URL, on other producers and in older bundles. */
     page?: TracePage;
     /** On the computer-use `ui_action` of the wait during which a watch ended: the watch the loop
-     *  ran in place of a turn that only waited. Additive: absent on plain waits, on other items and
+     *  ran in place of a turn that only waited. A watch no wait carries, which a participant held to
+     *  its scheduled end gets for a turn of only screenshots or after a repeated action, is on a
+     *  `notice` titled `watched the screen`. Additive: absent on plain waits, on other items and
      *  producers, and in older bundles. */
     watch?: ActorWatch;
     /** On a computer-use wait's `ui_action`: the length in milliseconds the participant named for