@bivy/bivy 0.9.1-staging.124 → 0.9.1-staging.126

package/dist/server.js

@@ -46,6 +46,7 @@ import { readEphemeralTeardownConfig, shouldSelfTeardown, performSelfTeardown }
 import { buildSessionSnapshot, applySessionSnapshot } from "./session/snapshot.js";
 import { createCheckpointBundle, applyCheckpointBundle, materializeCheckpoint } from "./session/checkpoint-pack.js";
 import { configuredTurnTimeoutMs } from "./session/turn-watchdog.js";
+import { forceAbortTurn } from "./session/abort-recovery.js";
 import { runRequiredAutomationChecks } from "./automation-checks.js";
 import { PolicyEngine } from "./policy/policy-engine.js";
 import { TerminalManager } from "./terminal.js";
@@ -2798,8 +2799,28 @@ const RELAY_COMMANDS = {
         ctx.broadcast({ type: "session.renamed", sessionId: rec.id, sessionFile: rec.sessionFile, name: newName });
         scheduleAdvertise();
     },
-    async abort(msg) {
-        await resolveSession(msg.sessionId)?.session.abort();
+    abort(msg, ctx) {
+        const record = resolveSession(msg.sessionId);
+        if (!record || !sessionBusy(record))
+            return;
+        // A wedged runtime may never resolve abort() or emit agent_end. Settle the
+        // daemon and client first, then make the SDK abort best-effort. The synthetic
+        // agent_end also closes running tool cards and drains visible follow-ups.
+        forceAbortTurn({
+            settle: () => {
+                questionManager.cancelForSession(record.id);
+                approvals.cancelForSession(record.id);
+                clearSessionWorking(record, "idle");
+            },
+            notifySettled: () => ctx.broadcast({
+                type: "session.event",
+                sessionId: record.id,
+                event: { type: "agent_end", aborted: true },
+            }),
+            abort: () => record.session.abort(),
+            onAbortError: (error) => console.warn(`[session-abort] runtime abort failed for ${record.id}:`, error),
+        });
+        record.abortRecovery = recoverRecordAfterAbort(record);
     },
     async "session.command.invoke"(msg, ctx) {
         // Invoke a protocol-mode agent command (AgentCommand.mode === "protocol")
@@ -3549,6 +3570,7 @@ const RELAY_COMMANDS = {
             broadcast({ type: "session.error", sessionId: requestedSessionId, error: error instanceof Error ? error.message : String(error) });
             return;
         }
+        await record.abortRecovery;
         record.remoteActive = true;
         if (record.tuiTermId || record.tuiRefreshing) {
             broadcast({ type: "session.error", sessionId: record.id, error: record.tuiRefreshing ? "This session is returning from the terminal. Try again in a moment." : "This session is open in the terminal (TUI). Close the TUI to chat here." });
@@ -7169,7 +7191,7 @@ function armTurnWatchdog(record) {
         // Clear/persist first so the session and an ephemeral runner cannot remain
         // pinned in a false working state if the runtime's abort path fails to emit
         // agent_end. abort() is still invoked to kill the underlying process group.
-        clearSessionWorking(record);
+        clearSessionWorking(record, "idle");
         metadata.touchSession(record.id, "failed");
         broadcast({ type: "session.outcome", sessionId: record.id, status: "timed_out", completedAt: new Date().toISOString(), error: message });
         broadcast({ type: "session.error", sessionId: record.id, error: message });
@@ -7208,7 +7230,7 @@ function markSessionWorking(record, activity) {
     if (!wasWorking)
         scheduleAdvertise(); // idle → working transition
 }
-function clearSessionWorking(record) {
+function clearSessionWorking(record, forcedStatus) {
     clearTurnWatchdog(record);
     touchSession(record);
     record.isWorking = false;
@@ -7217,7 +7239,10 @@ function clearSessionWorking(record) {
     // A completed turn clears any pending manual-resume offer: the session has now
     // moved on (whether it was the resume itself or an unrelated new message).
     metadata.setResumePending(record.id, false);
-    persistSessionMetadata(record, sessionStatus(record));
+    // A stuck runtime can keep its own isStreaming bit true forever. Recovery
+    // callers explicitly force idle so that stale SDK state is not persisted as
+    // a permanently-working session after Bivy has settled the turn.
+    persistSessionMetadata(record, forcedStatus ?? sessionStatus(record));
     scheduleAdvertise(); // working → idle transition
 }
 /**
@@ -8117,6 +8142,68 @@ async function tryAttachLiveRemote(sessionId, options) {
         return { result: undefined, gone, error };
     }
 }
+/** Re-open a runtime that still reports streaming shortly after a manual Stop.
+ * The client is settled immediately by the abort handler; prompts arriving from
+ * its follow-up queue await this promise and therefore cannot be steered into the
+ * stale in-process Pi turn. */
+async function recoverRecordAfterAbort(record) {
+    const oldSession = record.session;
+    try {
+        await new Promise((resolve) => setTimeout(resolve, 250));
+        if (record.session !== oldSession || !oldSession.isStreaming)
+            return;
+        if (!record.sessionFile) {
+            broadcast({ type: "session.error", sessionId: record.id, error: "The stopped agent did not settle. Reopen this chat to continue." });
+            return;
+        }
+        const rt = await ensureRuntimeAvailable(record.runtimeId, record.sandbox);
+        const workspace = record.worktree?.path || oldSession.cwd || record.workspace;
+        const runtimeSessionOptions = {
+            workspace,
+            toolProvider: integrations.toolProvider({ current: record.id }),
+            ...(rt.capabilities.toolInterception ? { toolInterceptor: guardianInterceptor } : {}),
+        };
+        const { session, warning } = await runtimeHost.openSession(rt, {
+            ...runtimeSessionOptions,
+            sessionFile: record.sessionFile,
+        });
+        // The original abort may have completed while openSession was in flight.
+        if (record.session !== oldSession || !oldSession.isStreaming) {
+            session.dispose();
+            return;
+        }
+        if (session.id !== record.id) {
+            session.dispose();
+            throw new Error(`runtime reopened session as ${session.id} instead of ${record.id}`);
+        }
+        record.unsubscribe?.();
+        record.unsubscribe = undefined;
+        record.session = session;
+        record.sessionFile = session.sessionFile ?? record.sessionFile;
+        record.workspace = session.cwd || workspace;
+        record.warning = warning;
+        oldSession.dispose();
+        attachSessionListeners(record);
+        persistSessionMetadata(record, "idle");
+        broadcast(buildHistoryEvent({
+            sessionId: record.id,
+            workspace: record.workspace,
+            source: record.source,
+            runtimeId: record.runtimeId,
+            isStreaming: false,
+            messages: conversationMessages(record),
+        }));
+        if (warning)
+            broadcast({ type: "session.warning", sessionId: record.id, warning });
+        console.warn(`[session-abort] reopened stuck runtime for ${record.id}`);
+    }
+    catch (error) {
+        broadcast({ type: "session.error", sessionId: record.id, error: `Could not recover the stopped agent: ${error instanceof Error ? error.message : String(error)}` });
+    }
+    finally {
+        record.abortRecovery = undefined;
+    }
+}
 async function createSession(workspace = defaultWorkspace, sessionFile, opts = {}) {
     const makeActive = opts.makeActive !== false;
     // Normalize the resume ref into the token the owning runtime actually expects.
@@ -10803,6 +10890,7 @@ app.post("/api/session/prompt", async (req, res, next) => {
         if (!record) {
             record = await createWorkspaceSession(requestedWorkspace ?? defaultWorkspace, { title: titleText, runtimeId: agentFrom(req.body ?? {}) });
         }
+        await record.abortRecovery;
         if (record.tuiTermId || record.tuiRefreshing) {
             return res.status(409).json({ error: record.tuiRefreshing ? "This session is returning from the terminal. Try again in a moment." : "This session is open in the terminal (TUI). Close the TUI to chat here." });
         }

package/dist/session/abort-recovery.js

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+/**
+ * Settle Bivy's view of a turn before asking the runtime to abort it.
+ *
+ * Runtime aborts are deliberately best-effort: an in-process SDK can be wedged
+ * in the very operation abort is meant to interrupt.  Stop must therefore not
+ * await that SDK before the client is allowed to leave its working state.
+ */
+export function forceAbortTurn(options) {
+    options.settle();
+    options.notifySettled();
+    void Promise.resolve()
+        .then(options.abort)
+        .catch((error) => options.onAbortError?.(error));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bivy/bivy",
-  "version": "0.9.1-staging.124",
+  "version": "0.9.1-staging.126",
   "type": "module",
   "license": "FSL-1.1-ALv2",
   "description": "Run coding agents on machines you own. Source-available, self-hostable agent workspace.",