@bivy/bivy 0.10.1-staging.243 → 0.10.1-staging.244

package/dist/server.js

@@ -385,6 +385,15 @@ function replayPendingInteractions(sessionId) {
             broadcast({ type: "approval.created", approval: a });
         }
     }
+    const record = resolveSession(sessionId);
+    if (record?.turnAttention) {
+        const { trigger, idleMs, at } = record.turnAttention;
+        const mins = Math.max(1, Math.round(idleMs / 60_000));
+        const message = trigger === "wedged"
+            ? `A tool call has run for ${mins} min without making progress. Stop it or keep waiting?`
+            : `The agent has been quiet for ${mins} min. Stop it or keep waiting?`;
+        broadcast({ type: "session.turn_attention", sessionId, trigger, idleMs, at, message });
+    }
 }
 function persistApprovalRequest(request, resolvedAt) {
     metadata.recordApproval({
@@ -1909,7 +1918,17 @@ const RELAY_COMMANDS = {
         const record = resolveSession(msg.sessionId);
         if (!record || !sessionBusy(record))
             return;
-        abortSessionRecord(record, ctx.broadcast);
+        if (record.turnAttention)
+            turnWatchdog.resolveTurnAttention(record, "stop");
+        else
+            abortSessionRecord(record, ctx.broadcast);
+    },
+    "session.turn_attention.resolve"(msg) {
+        const record = resolveSession(msg.sessionId);
+        const action = msg.action === "stop" ? "stop" : msg.action === "continue" ? "continue" : undefined;
+        if (!record || !action)
+            return;
+        turnWatchdog.resolveTurnAttention(record, action);
     },
     async "session.command.invoke"(msg, ctx) {
         // Invoke a protocol-mode agent command (AgentCommand.mode === "protocol")
@@ -2064,6 +2083,7 @@ const RELAY_COMMANDS = {
             // (SessionList.tsx's periodic safety-net poll) clobbering the correct
             // needs_action the live session.question broadcast had just set.
             const pendingApproval = rec ? sessionHasPendingApproval(rec) : approvals.list().some((a) => a.sessionId === s.id && a.status === "pending");
+            const needsAction = pendingApproval || Boolean(rec?.turnAttention);
             return {
                 path: s.path,
                 id: s.id,
@@ -2079,10 +2099,10 @@ const RELAY_COMMANDS = {
                 sandbox: rec?.sandbox ?? normalizeSandboxTier(meta?.sandbox),
                 prUrl: rec?.prUrl ?? meta?.prUrl,
                 prs: rec?.prs ?? meta?.prs,
-                status: pendingApproval ? "needs_action" : (rec ? sessionState(rec).displayStatus : "saved"),
+                status: needsAction ? "needs_action" : (rec ? sessionState(rec).displayStatus : "saved"),
                 sessionState: rec ? sessionState(rec) : undefined,
                 open: Boolean(rec),
-                needsAction: pendingApproval,
+                needsAction,
                 bivySession: bivySessionEnvelopeFromSummary(s, rec, meta),
             };
         });
@@ -5873,6 +5893,7 @@ function sessionState(record) {
         awaitingInput: sessionHasPendingApproval(record),
         workspace: record.workspaceState ?? "clean",
         lastTurnFailed: Boolean(record.lastFailureAt),
+        turnNeedsAttention: Boolean(record.turnAttention),
     });
 }
 /** Push axis-only transitions (checkpointing, question/approval changes) that
@@ -6627,11 +6648,25 @@ const stallSweepMs = stallSweepBasis.length ? Math.max(15_000, Math.min(60_000,
 // The stall/timeout orchestration lives in ./session/turn-watchdog-runtime; its
 // whole coupling surface to the daemon is this deps object. The narrow
 // WatchdogSession it operates on is structurally satisfied by SessionRecord.
+const stallAction = process.env.BIVY_TURN_STALL_ACTION?.trim().toLowerCase() === "recover" ? "recover" : "notify";
 const turnWatchdog = createTurnWatchdog({
     turnTimeoutMs,
     turnStallMs,
     turnActivityStallMs,
+    stallAction,
     broadcast,
+    broadcastSessionState: (record) => broadcastSessionState(record),
+    notifyTurnAttention: (record, message) => {
+        const session = record;
+        void sendNotificationHint({
+            kind: "agent_stalled",
+            sessionId: session.id,
+            targetSessionId: session.id,
+            attentionId: session.id,
+            title: `${sessionNotifyLabel(session)} may be stuck`,
+            body: message,
+        });
+    },
     markSessionFailed: (id) => metadata.touchSession(id, "failed"),
     abortSessionRecord: (record) => abortSessionRecord(record),
     evaluateEphemeralTeardown,
@@ -6662,8 +6697,10 @@ function markSessionWorking(record, activity, opts) {
     // separately anchors the wedged band. Raw subprocess output (tool_execution_
     // update) bumps lastProgressAt above but NOT this, so a chatty-but-hung tool
     // still trips the wedged watchdog. Non-event callers default to structural.
-    if (opts?.structural !== false)
+    const structural = opts?.structural !== false;
+    if (structural)
         record.lastStructuralProgressAt = now;
+    turnWatchdog.clearTurnAttentionOnProgress(record, structural);
     // A new attempt resolves the prior turn's failure condition at its source.
     record.lastFailureAt = undefined;
     metadata.touchSession(record.id, "working");
@@ -6673,6 +6710,7 @@ function markSessionWorking(record, activity, opts) {
     }
 }
 function clearSessionWorking(record, forcedStatus) {
+    turnWatchdog.clearTurnAttentionOnProgress(record, true);
     turnWatchdog.clearTurnWatchdog(record);
     touchSession(record);
     record.isWorking = false;
@@ -10188,8 +10226,27 @@ app.post("/api/session/abort", (req, res, next) => {
         const record = resolveSession(req.body?.sessionId);
         if (!record)
             return res.status(404).json({ error: "No active session" });
-        if (sessionBusy(record))
-            abortSessionRecord(record);
+        if (sessionBusy(record)) {
+            if (record.turnAttention)
+                turnWatchdog.resolveTurnAttention(record, "stop");
+            else
+                abortSessionRecord(record);
+        }
+        res.json({ ok: true });
+    }
+    catch (error) {
+        next(error);
+    }
+});
+app.post("/api/session/turn-attention", (req, res, next) => {
+    try {
+        const record = resolveSession(req.body?.sessionId);
+        if (!record)
+            return res.status(404).json({ error: "No active session" });
+        const action = req.body?.action === "stop" ? "stop" : req.body?.action === "continue" ? "continue" : undefined;
+        if (!action)
+            return res.status(400).json({ error: "Action must be stop or continue" });
+        turnWatchdog.resolveTurnAttention(record, action);
         res.json({ ok: true });
     }
     catch (error) {

package/dist/session/session-state.js

@@ -22,6 +22,10 @@ export function deriveSessionState(evidence) {
         displayStatus = "needs_attention";
     else if (process === "exited")
         displayStatus = "failed";
+    // A working turn the watchdog flagged for review is actionable even though the
+    // agent is still technically "working" — surface it so the user sees the card.
+    else if (agent === "working" && evidence.turnNeedsAttention)
+        displayStatus = "needs_attention";
     else if (agent === "working")
         displayStatus = "working";
     else if (evidence.lastTurnFailed)

package/dist/session/turn-watchdog-runtime.js

@@ -63,6 +63,12 @@ export function createTurnWatchdog(deps) {
             return `A tool call ran for ${mins} min without making progress and was recovered. Send a message to continue.`;
         return `The agent stopped responding (no activity for ${mins} min) and was recovered. Send a message to continue.`;
     }
+    function turnAttentionMessage(idleMs, trigger) {
+        const mins = Math.max(1, Math.round(idleMs / 60_000));
+        if (trigger === "wedged")
+            return `A tool call has run for ${mins} min without making progress. Stop it or keep waiting?`;
+        return `The agent has been quiet for ${mins} min. Stop it or keep waiting?`;
+    }
     /** Idle used for a stall's diagnostic/message. A `wedged` turn is measured from
      *  the last STRUCTURAL progress (raw output kept flowing), every other trigger
      *  from the last progress of any kind. */
@@ -97,6 +103,10 @@ export function createTurnWatchdog(deps) {
         if (record.turnTimedOut)
             return; // already recovering this turn
         record.turnTimedOut = true;
+        // A real recovery (user hit Stop, wall-clock cap, or a dead subprocess)
+        // supersedes any pending "needs your decision" card — drop it so the client
+        // closes it and the failed/outcome events below take over.
+        record.turnAttention = undefined;
         record.lastFailureAt = now();
         const trigger = diag?.trigger ?? "stalled";
         const turnMs = record.workingStartedAt ? record.lastFailureAt - record.workingStartedAt : undefined;
@@ -152,9 +162,53 @@ export function createTurnWatchdog(deps) {
             activityStallMs: turnActivityStallMs,
         });
     }
-    /** Periodic sweep: recover any working session whose turn has stalled. This is
-     *  what makes a hang self-heal without the user hitting Stop or waiting out the
-     *  hour-long cap. */
+    function clearTurnAttention(record) {
+        if (!record.turnAttention)
+            return;
+        record.turnAttention = undefined;
+        deps.broadcast({ type: "session.turn_attention.resolved", sessionId: record.id });
+        deps.broadcastSessionState(record);
+    }
+    function flagTurnForReview(record, trigger, idleMs, at) {
+        if (record.turnAttention)
+            return;
+        const message = turnAttentionMessage(idleMs, trigger);
+        record.turnAttention = { trigger, idleMs, at };
+        deps.broadcast({ type: "session.turn_attention", sessionId: record.id, trigger, idleMs, at, message });
+        deps.broadcastSessionState(record);
+        deps.notifyTurnAttention(record, message);
+    }
+    function resolveTurnAttention(record, action) {
+        const attention = record.turnAttention;
+        if (!attention)
+            return;
+        if (action === "stop") {
+            recoverStuckTurn(record, turnStallMessage(attention.idleMs, attention.trigger), attention);
+            // recoverStuckTurn clears the field, but it intentionally emits failure
+            // frames rather than the ordinary resolved frame. Emit this one too so a
+            // client can deterministically remove its card before those frames arrive.
+            deps.broadcast({ type: "session.turn_attention.resolved", sessionId: record.id });
+            deps.broadcastSessionState(record);
+            return;
+        }
+        const at = now();
+        record.lastProgressAt = at;
+        record.lastStructuralProgressAt = at;
+        clearTurnAttention(record);
+    }
+    function clearTurnAttentionOnProgress(record, structural) {
+        const attention = record.turnAttention;
+        if (!attention)
+            return;
+        // Silence means any activity disproves the warning. A wedged tool can keep
+        // producing raw output forever, so only structural progress dismisses it.
+        if (attention.trigger === "wedged" && !structural)
+            return;
+        clearTurnAttention(record);
+    }
+    /** Periodic sweep: dead subprocesses are always recovered. Time-based soft
+     *  stalls normally ask the user instead; operators can opt into the legacy
+     *  automatic recovery with stallAction="recover". */
     function sweepStalledTurns() {
         if (turnStallMs <= 0 && turnActivityStallMs <= 0)
             return;
@@ -164,7 +218,12 @@ export function createTurnWatchdog(deps) {
             if (!trigger)
                 continue;
             const idleMs = stallIdleMs(record, trigger, at);
-            recoverStuckTurn(record, turnStallMessage(idleMs, trigger), { trigger, idleMs });
+            if (trigger === "pid_dead" || deps.stallAction === "recover") {
+                recoverStuckTurn(record, turnStallMessage(idleMs, trigger), { trigger, idleMs });
+            }
+            else {
+                flagTurnForReview(record, trigger, idleMs, at);
+            }
         }
     }
     /**
@@ -216,5 +275,7 @@ export function createTurnWatchdog(deps) {
         stallTriggerFor,
         sweepStalledTurns,
         turnRecoveryStats,
+        resolveTurnAttention,
+        clearTurnAttentionOnProgress,
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bivy/bivy",
-  "version": "0.10.1-staging.243",
+  "version": "0.10.1-staging.244",
   "type": "module",
   "license": "AGPL-3.0-only",
   "description": "Run coding agents on machines you own. Open-source, self-hostable agent workspace.",