@peakflo/agent-harness 0.2.11-rc.2 → 0.2.11-rc.4

package/dist/runtime/session-runner.js

@@ -634,6 +634,18 @@ class SessionRunner {
      */
     approvalWaitMs = 0;
     approvalWaitStartedAt = null;
+    /**
+     * Total wall-clock this turn has spent with its browser call HELD because a
+     * person controls the chat browser (takeover). Excluded from the idle guard
+     * and added back onto the hard ceiling exactly like approval time, but it
+     * never opens an approval and the approval timeout never applies: a takeover
+     * lasts as long as the person needs (owner decision), and the turn's abort
+     * and hard ceiling (minus the pause) still end it.
+     */
+    browserPauseMs = 0;
+    browserPauseStartedAt = null;
+    /** When the last browser pause ended; the idle clock restarts from here. */
+    browserPauseEndedAt = null;
     constructor(deps) {
         this.deps = deps;
         this.logger = deps.logger ?? console;
@@ -650,6 +662,44 @@ class SessionRunner {
     isAwaitingApproval() {
         return this.openApproval !== null || this.openQuestionPartId !== null;
     }
+    /** True while a browser call is held because a person controls the browser. */
+    isBrowserPaused() {
+        return this.browserPauseStartedAt !== null;
+    }
+    /**
+     * Start or stop the browser-takeover pause clock. Called by the harness from
+     * the loopback MCP proxy's hold hook. Returns false when this runner has no
+     * live turn for `sessionId` — the caller should then cancel the hold rather
+     * than keep an agent call parked for a turn that is gone.
+     */
+    setBrowserPaused(sessionId, paused) {
+        if (paused) {
+            if (!this.turnContext || this.turnContext.sessionId !== sessionId) {
+                return false;
+            }
+            if (this.browserPauseStartedAt === null) {
+                this.browserPauseStartedAt = Date.now();
+                this.deps.onBrowserPauseChange?.(sessionId, true);
+            }
+            return true;
+        }
+        this.closeBrowserPause(sessionId);
+        return true;
+    }
+    closeBrowserPause(sessionId) {
+        if (this.browserPauseStartedAt === null)
+            return;
+        const now = Date.now();
+        this.browserPauseMs += now - this.browserPauseStartedAt;
+        this.browserPauseStartedAt = null;
+        this.browserPauseEndedAt = now;
+        this.deps.onBrowserPauseChange?.(sessionId, false);
+    }
+    /** Wall-clock spent in the browser pause we are in RIGHT NOW, if any. */
+    liveBrowserPauseMs() {
+        const startedAt = this.browserPauseStartedAt;
+        return startedAt === null ? 0 : Date.now() - startedAt;
+    }
     /**
      * Run the leased turn to completion, or until `signal` aborts it.
      *
@@ -1305,6 +1355,9 @@ class SessionRunner {
             this.turnContext = null;
             this.deferredSteers.length = 0;
             this.closeApproval(session.sessionId);
+            // A held browser call cannot outlive its turn; the harness cancels the
+            // proxy hold on its side too.
+            this.closeBrowserPause(session.sessionId);
             this.deps.knowledge?.host.bindTurn(session.sessionId, null);
             this.closeQuestion(session.sessionId);
             this.emittedApprovals.clear();
@@ -1577,6 +1630,7 @@ class SessionRunner {
         const idleLimitMs = session.limits.maxTurnIdleMs ?? DEFAULT_MAX_TURN_IDLE_MS;
         let lastProgressAt = Date.now();
         let approvalWaitAtLastProgress = this.approvalWaitMs;
+        let browserPauseAtLastProgress = this.browserPauseMs;
         try {
             while (!signal.aborted) {
                 const now = Date.now();
@@ -1640,7 +1694,11 @@ class SessionRunner {
                 // turn stopped to ask a person something is blocked on them, not
                 // running away, and ten minutes is an entirely ordinary time for a
                 // person to be away from their desk.
-                const pausedMs = this.approvalWaitMs + this.liveApprovalWaitMs();
+                // A browser takeover is the same kind of intentional pause.
+                const pausedMs = this.approvalWaitMs +
+                    this.liveApprovalWaitMs() +
+                    this.browserPauseMs +
+                    this.liveBrowserPauseMs();
                 if (hardDeadline !== null && now > hardDeadline + pausedMs) {
                     timedOut = true;
                     break;
@@ -1743,6 +1801,7 @@ class SessionRunner {
                     // here, not double-counting wait time already excluded once.
                     lastProgressAt = Date.now();
                     approvalWaitAtLastProgress = this.approvalWaitMs;
+                    browserPauseAtLastProgress = this.browserPauseMs;
                     continue;
                 }
                 const status = await adapter.getStatus(backendSessionId, config);
@@ -1780,9 +1839,27 @@ class SessionRunner {
                 const approvalWaitSinceProgress = this.approvalWaitMs -
                     approvalWaitAtLastProgress +
                     this.liveApprovalWaitMs();
-                const idleElapsed = Date.now() - lastProgressAt - approvalWaitSinceProgress;
+                // A handback restarts the idle clock: the agent gets a full idle
+                // window after the person returns control, as after real progress.
+                if (this.browserPauseEndedAt !== null &&
+                    this.browserPauseEndedAt > lastProgressAt) {
+                    lastProgressAt = this.browserPauseEndedAt;
+                    approvalWaitAtLastProgress = this.approvalWaitMs;
+                    browserPauseAtLastProgress = this.browserPauseMs;
+                }
+                // Browser takeover time since the last progress, by the same rule.
+                // Skipped outright while held: the idle clock restarts when the
+                // person hands back, never mid-hold.
+                const browserPauseSinceProgress = this.browserPauseMs -
+                    browserPauseAtLastProgress +
+                    this.liveBrowserPauseMs();
+                const idleElapsed = Date.now() -
+                    lastProgressAt -
+                    approvalWaitSinceProgress -
+                    browserPauseSinceProgress;
                 if (this.approvalWaitStartedAt === null &&
                     this.openQuestionPartId === null &&
+                    this.browserPauseStartedAt === null &&
                     idleElapsed > idleLimitMs) {
                     this.logger.warn(`[SessionRunner] session ${session.sessionId} had no progress for ` +
                         `${Math.round(idleElapsed / 1000)}s (limit ${Math.round(idleLimitMs / 1000)}s)`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peakflo/agent-harness",
-  "version": "0.2.11-rc.2",
+  "version": "0.2.11-rc.4",
   "description": "Headless Peakflo coding-agent harness. One codebase, three hosting modes: a Daytona cloud sandbox, a customer VM, and the 20x desktop.",
   "license": "MIT",
   "type": "commonjs",