@bivy/bivy 0.10.1-staging.294 → 0.10.1-staging.296

package/dist/agents/pi/background-shell.js

@@ -0,0 +1,87 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Petter André Sjulstad
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { createLocalBashOperations } from "@earendil-works/pi-coding-agent";
+/** Tracks process groups left behind by a completed shell tool call. In a
+ * non-interactive POSIX shell, `command &` remains in the detached shell's
+ * process group after the shell exits, which gives us an observable lifecycle
+ * without trying to infer state from the assistant's prose. */
+export class BackgroundShellTracker {
+    groups = new Set();
+    listeners = new Set();
+    timer;
+    get count() { return this.groups.size; }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    track(groupId) {
+        if (!groupId || !processGroupAlive(groupId) || this.groups.has(groupId))
+            return;
+        this.groups.add(groupId);
+        this.emit();
+        this.timer ??= setInterval(() => this.sweep(), 1_000);
+        this.timer.unref?.();
+    }
+    dispose() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = undefined;
+        this.groups.clear();
+    }
+    sweep() {
+        let changed = false;
+        for (const id of this.groups) {
+            if (!processGroupAlive(id)) {
+                this.groups.delete(id);
+                changed = true;
+            }
+        }
+        if (changed)
+            this.emit();
+        if (this.groups.size === 0 && this.timer) {
+            clearInterval(this.timer);
+            this.timer = undefined;
+        }
+    }
+    emit() {
+        for (const listener of this.listeners)
+            listener(this.groups.size);
+    }
+}
+export function processGroupAlive(groupId) {
+    if (process.platform === "win32")
+        return false;
+    try {
+        process.kill(-groupId, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+/** Wrap pi's normal shell backend. The tiny, output-free prefix records the
+ * detached shell's process-group id; after the foreground shell returns, a
+ * still-live group means it deliberately left background work behind. */
+export function createBackgroundAwareBashOperations(tracker, base = createLocalBashOperations()) {
+    return {
+        async exec(command, cwd, options) {
+            if (process.platform === "win32")
+                return base.exec(command, cwd, options);
+            const marker = path.join(os.tmpdir(), `bivy-bg-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`);
+            const quotedMarker = `'${marker.replace(/'/g, `'\\''`)}'`;
+            try {
+                const result = await base.exec(`printf '%s' "$$" > ${quotedMarker}\n${command}`, cwd, options);
+                const groupId = Number.parseInt(await fs.promises.readFile(marker, "utf8").catch(() => ""), 10);
+                if (Number.isSafeInteger(groupId) && groupId > 0)
+                    tracker.track(groupId);
+                return result;
+            }
+            finally {
+                void fs.promises.unlink(marker).catch(() => { });
+            }
+        },
+    };
+}

package/dist/agents/pi/runtime.js

@@ -9,7 +9,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { completeSimple } from "@earendil-works/pi-ai/compat";
-import { ModelRuntime, createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, SessionManager, SettingsManager, } from "@earendil-works/pi-coding-agent";
+import { ModelRuntime, createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, createBashToolDefinition, SessionManager, SettingsManager, } from "@earendil-works/pi-coding-agent";
 import { createPiModelRuntime } from "../../runtime/pi-oauth.js";
 import { toModelInfo as sharedToModelInfo } from "../../runtime/normalize.js";
 import { provisionPiAuthJson } from "../../runtime/credential-provisioning.js";
@@ -17,6 +17,7 @@ import { isNativeOAuthProvider } from "../../runtime/oauth/model-oauth-providers
 import { bivySessionEnv } from "../../runtime/session-env.js";
 import { withExactCapabilitySurface } from "../../runtime/types.js";
 import { mapToolCall, mapToolResult } from "../../runtime/tool-call-map.js";
+import { BackgroundShellTracker, createBackgroundAwareBashOperations } from "./background-shell.js";
 /**
  * Extract Pi's own slash commands from a live AgentSession: extension commands
  * (`pi.registerCommand`, exposed via `extensionRunner.getRegisteredCommands()`),
@@ -146,10 +147,12 @@ function toolProviderFactory(provider) {
 class PiSession {
     runtime;
     tui;
+    backgroundShells;
     toolDetails = new Map();
-    constructor(runtime, tui) {
+    constructor(runtime, tui, backgroundShells) {
         this.runtime = runtime;
         this.tui = tui;
+        this.backgroundShells = backgroundShells;
     }
     get session() {
         return this.runtime.session;
@@ -206,13 +209,17 @@ class PiSession {
         return this.session.abort();
     }
     dispose() {
+        this.backgroundShells.dispose();
         void this.runtime.dispose();
     }
     getMessages() {
         return this.session.state.messages;
     }
     subscribe(listener) {
-        return this.session.subscribe((event) => {
+        const unsubscribeBackground = this.backgroundShells.subscribe((count) => {
+            listener({ type: "background_tasks_changed", count });
+        });
+        const unsubscribeSession = this.session.subscribe((event) => {
             const type = String(event?.type ?? "");
             const callId = String(event?.toolCallId ?? event?.toolUseId ?? event?.tool_use_id ?? event?.id ?? "");
             if (type === "tool_call" || type === "tool_execution_start") {
@@ -232,6 +239,10 @@ class PiSession {
             }
             listener(event);
         });
+        return () => {
+            unsubscribeBackground();
+            unsubscribeSession();
+        };
     }
     /**
      * Pi's own slash commands for this session: extension commands (pi.register
@@ -420,6 +431,7 @@ export class PiRuntime {
                 allowModelNetwork: true,
             })
             : await createPiModelRuntime({ credsDir, piDir, allowModelNetwork: true });
+        const backgroundShells = new BackgroundShellTracker();
         const createRuntime = async ({ cwd, agentDir, sessionManager, sessionStartEvent }) => {
             const sessionId = sessionManager.getSessionId();
             const providedTools = options.toolProvider ? [toolProviderFactory(options.toolProvider)] : [];
@@ -431,7 +443,13 @@ export class PiRuntime {
                     extensionFactories: [guardianFactory(sessionId, options.toolInterceptor), ...providedTools],
                 },
             });
-            const result = await createAgentSessionFromServices({ services, sessionManager, sessionStartEvent });
+            // Override only the built-in bash definition. Pi still owns rendering,
+            // truncation and execution; the operations wrapper observes process groups
+            // that remain alive after a `command &` shell call returns.
+            const bash = createBashToolDefinition(cwd, {
+                operations: createBackgroundAwareBashOperations(backgroundShells),
+            });
+            const result = await createAgentSessionFromServices({ services, sessionManager, sessionStartEvent, customTools: [bash] });
             return { ...result, services, diagnostics: services.diagnostics };
         };
         const runtime = await createAgentSessionRuntime(createRuntime, {
@@ -446,7 +464,7 @@ export class PiRuntime {
             piCommand: resolvePiCommand(),
             credentialOwner: this.options.credentialOwner ?? "bivy",
         };
-        return { session: new PiSession(runtime, tui), warning: runtime.modelFallbackMessage };
+        return { session: new PiSession(runtime, tui, backgroundShells), warning: runtime.modelFallbackMessage };
     }
     createSession(options) {
         const sessionManager = SessionManager.create(options.workspace, this.options.sessionsDir);

package/dist/server.js

@@ -6009,6 +6009,7 @@ function sessionState(record) {
         transportReachable: clients.size > 0 || Boolean(relay?.connected),
         processAlive,
         working: sessionBusy(record),
+        waitingBackground: (record.backgroundTaskCount ?? 0) > 0,
         awaitingInput: sessionHasPendingApproval(record),
         workspace: record.workspaceState ?? "clean",
         lastTurnFailed: Boolean(record.lastFailureAt),
@@ -7131,6 +7132,28 @@ function attachSessionListeners(record) {
             persistSessionMetadata(record);
             broadcast({ type: "session.updated", sessionId: record.id, sessionFile: record.sessionFile, bivySession: bivySessionEnvelope(record) });
         }
+        if (event.type === "background_tasks_changed") {
+            const previous = record.backgroundTaskCount ?? 0;
+            const countValue = Number(event.count);
+            const count = Number.isSafeInteger(countValue) && countValue > 0 ? countValue : 0;
+            record.backgroundTaskCount = count;
+            touchSession(record);
+            persistSessionMetadata(record);
+            broadcastSessionState(record);
+            scheduleAdvertise();
+            // A background process ending is the real completion boundary when the
+            // agent already ended its turn. Do not claim the session finished while
+            // tests/builds it launched are still running.
+            if (previous > 0 && count === 0 && !sessionBusy(record)) {
+                void sendNotificationHint({
+                    kind: "session_done",
+                    sessionId: record.id,
+                    targetSessionId: record.id,
+                    title: "Background work finished",
+                    body: `${sessionNotifyLabel(record)} finished its background tasks — tap to review the result.`,
+                });
+            }
+        }
         if ([
             "agent_start",
             "turn_start",
@@ -7296,7 +7319,7 @@ function attachSessionListeners(record) {
                     body: `${sessionNotifyLabel(record)} failed its last turn — tap to see what went wrong.`,
                 });
             }
-            else if (!record.isWorking && !record.remoteActive) {
+            else if (!record.isWorking && !record.remoteActive && (record.backgroundTaskCount ?? 0) === 0) {
                 void sendNotificationHint({
                     kind: "session_done",
                     sessionId: record.id,

package/dist/session/session-state.js

@@ -16,7 +16,9 @@ export function deriveSessionState(evidence) {
         ? "awaiting-input"
         : evidence.working
             ? "working"
-            : "idle";
+            : evidence.waitingBackground
+                ? "waiting"
+                : "idle";
     let displayStatus;
     if (agent === "awaiting-input")
         displayStatus = "needs_attention";
@@ -26,7 +28,7 @@ export function deriveSessionState(evidence) {
     // 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")
+    else if (agent === "working" || agent === "waiting")
         displayStatus = "working";
     else if (evidence.lastTurnFailed)
         displayStatus = "failed";

package/package.json

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