@bivy/bivy 0.15.0-staging.9 → 0.16.0-staging.1

package/bin/agent-manifest.json

@@ -22,7 +22,7 @@
       "hidden": false,
       "supportTier": "supported",
       "certification": "release-tested",
-      "testedVersion": "1.18.23",
+      "testedVersion": "1.18.25",
       "headlessFlags": [
         "run",
         "-s"

package/bin/bivy.mjs

@@ -3543,11 +3543,55 @@ function terminalQr(text) {
 
 // --- commands ---------------------------------------------------------------
 
+async function cmdTokenSetup() {
+  // A token-bearing installer command is an explicit "add this machine" flow,
+  // not a request to walk through first-run preferences. In particular, do not
+  // consume the account token after presenting the agent and login wizards:
+  // those prompts made the Connect a Machine command unusable on headless
+  // machines and made it look as if the token had been ignored.
+  if (!(await ensureDeps())) process.exit(1);
+
+  const config = loadConfig();
+  if (!config.workspace || config.workspace === repoRoot) {
+    config.workspace = firstSetupWorkspace(config);
+    if (!fs.existsSync(config.workspace)) fs.mkdirSync(config.workspace, { recursive: true });
+  }
+  const explicitPort = Number(process.env.PORT);
+  config.port = explicitPort || await findAvailablePort(Number(config.port) || 4317, nodeBindHost());
+  config.env = { ...config.env, BIVY_RUNTIME: config.env?.BIVY_RUNTIME || "pi" };
+  saveConfig(config);
+
+  const code = await run(nodeBin, [...nodeScriptArgs(relaySetupEntry)], {
+    cwd: repoRoot,
+    env: startEnv(config),
+  });
+  if (code !== 0) {
+    console.error(c.red("Machine enrollment failed; the token was not accepted."));
+    process.exitCode = code || 1;
+    return;
+  }
+
+  console.log(c.dim("\nInstalling the background service so the node keeps running…"));
+  const started = await installService(config);
+  if (!started) {
+    console.log(`Finish with ${c.cyan("bivy service install")} or start it with ${c.cyan("bivy start")}.`);
+    return;
+  }
+  console.log(c.bold(c.green("\n✓ Machine added and running. No interactive setup was needed.")));
+}
+
 async function cmdSetup(args = []) {
   if (args.includes("-h") || args.includes("--help")) {
     console.log("Usage: bivy setup\n\nFirst-run wizard: agent choice, model login, remote access + sign-in, and background service. Workspace and port get safe defaults. Re-run later to change the default agent or remote access.");
     return;
   }
+  // install.sh supplies these only for the Connect a Machine command. Keep
+  // this branch before creating a readline prompter: there may be no TTY.
+  if (process.env.BIVY_SESSION_TOKEN || process.env.BIVY_NODE_CLAIM_CODE) {
+    await cmdTokenSetup();
+    return;
+  }
+
   console.log(c.bold("\n  Bivy — node setup\n"));
   if (process.getuid?.() === 0) {
     console.log(c.yellow("You are running setup as root. For a real node, create a normal user (e.g. 'bivy') and install there."));

package/dist/agents/claude-code/integration.js

@@ -4,7 +4,7 @@ import { defineAgentIntegration } from "../definition.js";
 import { withExactCapabilitySurface } from "../../runtime/types.js";
 import { createCredentialStore } from "../../runtime/credentials.js";
 import { ClaudeCodeRuntime, claudeRuntimeFromEnv, claudeSdkInstalled, } from "./runtime.js";
-export const CLAUDE_TESTED_VERSION = "0.3.246";
+export const CLAUDE_TESTED_VERSION = "0.3.251";
 const CLAUDE_CAPABILITIES = withExactCapabilitySurface({
     toolInterception: true,
     modelSelection: true,

package/dist/agents/codex/integration.js

@@ -9,7 +9,7 @@ import { codexCredentialPreflight } from "../../runtime/codex-preflight.js";
 import { deleteCodexSession, discoverNativeCodexSessions, loadCodexTranscript, writeCodexRollout, exportCodexRollout, importCodexRollout, } from "../../runtime/codex-sessions.js";
 import { ProtocolRuntime } from "../../runtime/protocol.js";
 import { codexSlashCommands } from "../../runtime/slash-commands.js";
-export const CODEX_TESTED_VERSION = "0.150.0";
+export const CODEX_TESTED_VERSION = "0.151.0";
 const CODEX_AVAILABLE_CACHE = new Map();
 function codexCommand() {
     return process.env.BIVY_CODEX_BIN?.trim() || "codex";

package/dist/agents/pi/capabilities.js

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Petter André Sjulstad
+import { withExactCapabilitySurface } from "../../runtime/types.js";
+/**
+ * The ONE capability table for Pi, shared by the real `PiRuntime` and the
+ * `LazyPiRuntime` facade the registry hands out before the SDK is loaded.
+ *
+ * This module deliberately imports nothing from the pi SDK so the lazy facade
+ * can use it without defeating its purpose. Keeping a single source of truth is
+ * a correctness requirement, not tidiness: the daemon reads flags such as
+ * `sessionRefIsPath` off whichever runtime object the registry returns — the
+ * facade — *before* any session is opened. When the facade's copy of this table
+ * drifted from the real one and lost `sessionRefIsPath`, the daemon treated every
+ * pi resume ref as an opaque id, stripped the transcript path to its basename,
+ * and pi created a brand-new empty session for every message sent to a closed
+ * chat (the "sending to a closed session creates a new one" regression).
+ */
+export const PI_CAPABILITIES = withExactCapabilitySurface({
+    toolInterception: true,
+    modelSelection: true,
+    packages: true,
+    resume: true,
+    fork: false,
+    // pi resumes by session-file path (under the node's sessions dir), so the
+    // daemon applies its path-traversal guard to these refs.
+    sessionRefIsPath: true,
+    // pi's TUI ships with the node, so the chat<->TUI hand-off is always offered.
+    interactiveTui: true,
+    usageReporting: true,
+    // pi can find a prior on-disk session by cwd + start time, so a `bivy run`
+    // terminal with no pinned sessionId can still be continued as a governed chat.
+    sessionDiscovery: true,
+    // pi transcripts are structured messages that round-trip through the session
+    // store, so a pi->pi fork is full fidelity (see exportForFork/importForFork).
+    forkTransport: true,
+    // pi can also stand up a session from portable {role,text} history, so a fork
+    // FROM another agent INTO pi is a true replay, not a seeded summary.
+    forkHistoryImport: true,
+    // The pi-coding-agent SDK implements both explicitly: prompting mid-turn
+    // with no streamingBehavior hint throws, forcing every caller to choose.
+    streamingBehaviors: ["steer", "followUp"],
+});

package/dist/agents/pi/integration.js

@@ -4,19 +4,8 @@ import { spawnSync } from "node:child_process";
 import os from "node:os";
 import path from "node:path";
 import { defineAgentIntegration } from "../definition.js";
-import { withExactCapabilitySurface } from "../../runtime/types.js";
-export const PI_TESTED_VERSION = "0.84.3";
-const PI_CAPABILITIES = withExactCapabilitySurface({
-    toolInterception: true,
-    modelSelection: true,
-    packages: true,
-    resume: true,
-    fork: false,
-    interactiveTui: true,
-    usageReporting: true,
-    sessionDiscovery: true,
-    streamingBehaviors: ["steer", "followUp"],
-});
+import { PI_CAPABILITIES } from "./capabilities.js";
+export const PI_TESTED_VERSION = "0.84.4";
 export function piAgentDir() {
     return process.env.PI_CODING_AGENT_DIR?.trim() || path.join(os.homedir(), ".pi", "agent");
 }

package/dist/agents/pi/runtime.js

@@ -15,7 +15,7 @@ import { toModelInfo as sharedToModelInfo } from "../../runtime/normalize.js";
 import { provisionPiAuthJson } from "../../runtime/credential-provisioning.js";
 import { isNativeOAuthProvider } from "../../runtime/oauth/model-oauth-providers.js";
 import { bivySessionEnv } from "../../runtime/session-env.js";
-import { withExactCapabilitySurface } from "../../runtime/types.js";
+import { PI_CAPABILITIES } from "./capabilities.js";
 import { mapToolCall, mapToolResult } from "../../runtime/tool-call-map.js";
 import { BackgroundShellTracker, createBackgroundAwareBashOperations } from "./background-shell.js";
 /**
@@ -406,28 +406,9 @@ export class PiRuntime {
     options;
     id = "pi";
     displayName = "Pi";
-    capabilities = withExactCapabilitySurface({
-        toolInterception: true,
-        modelSelection: true,
-        packages: true,
-        resume: true,
-        fork: false,
-        // pi resumes by session-file path (under the node's sessions dir), so the
-        // daemon applies its path-traversal guard to these refs.
-        sessionRefIsPath: true,
-        // pi's TUI ships with the node, so the chat<->TUI hand-off is always offered.
-        interactiveTui: true,
-        usageReporting: true,
-        // pi transcripts are structured messages that round-trip through the session
-        // store, so a pi->pi fork is full fidelity (see exportForFork/importForFork).
-        forkTransport: true,
-        // pi can also stand up a session from portable {role,text} history, so a fork
-        // FROM another agent INTO pi is a true replay, not a seeded summary.
-        forkHistoryImport: true,
-        // The pi-coding-agent SDK implements both explicitly: prompting mid-turn
-        // with no streamingBehavior hint throws, forcing every caller to choose.
-        streamingBehaviors: ["steer", "followUp"],
-    });
+    // Shared with LazyPiRuntime (the facade the registry actually hands out) —
+    // see capabilities.ts for why the two must never drift.
+    capabilities = PI_CAPABILITIES;
     constructor(options) {
         this.options = options;
     }

package/dist/agents/profiles.js

@@ -43,7 +43,7 @@ export const AGENT_PROFILES = {
         // Approve/Deny + session/load resume + a real model picker), the same bar Pi,
         // Claude Code, and Codex clear. See `acp` below for the version fallback.
         supportTier: "supported",
-        testedVersion: "1.18.23",
+        testedVersion: "1.18.25",
         blurb: "The most widely used open-source coding harness (OpenCode CLI).",
         // `opencode run -s <id> "<prompt>"` continues a prior session by its own id
         // (`-s, --session  session id to continue`, per `opencode run --help`).

package/dist/certification/generated.js

@@ -3,9 +3,9 @@
 export const CERTIFICATION_MATRIX = {
     schemaVersion: 1,
     agents: [
-        { id: "claude-code-sdk", status: "active", executionMode: "protocol", pinnedVersion: "0.3.246", capabilities: ["toolInterception", "modelSelection", "resume"] },
-        { id: "codex-approvals", status: "active", executionMode: "protocol", pinnedVersion: "0.150.0", capabilities: ["toolInterception", "modelSelection", "resume"] },
-        { id: "pi", status: "active", executionMode: "protocol", pinnedVersion: "0.84.3", capabilities: ["toolInterception", "modelSelection", "resume"] },
-        { id: "opencode", status: "active", executionMode: "protocol", pinnedVersion: "1.18.23", capabilities: ["toolInterception", "modelSelection", "resume"] },
+        { id: "claude-code-sdk", status: "active", executionMode: "protocol", pinnedVersion: "0.3.251", capabilities: ["toolInterception", "modelSelection", "resume"] },
+        { id: "codex-approvals", status: "active", executionMode: "protocol", pinnedVersion: "0.151.0", capabilities: ["toolInterception", "modelSelection", "resume"] },
+        { id: "pi", status: "active", executionMode: "protocol", pinnedVersion: "0.84.4", capabilities: ["toolInterception", "modelSelection", "resume"] },
+        { id: "opencode", status: "active", executionMode: "protocol", pinnedVersion: "1.18.25", capabilities: ["toolInterception", "modelSelection", "resume"] },
     ]
 };

package/dist/control-plane-tasks.js

@@ -386,7 +386,17 @@ export class ControlPlaneTaskPoller {
                         ],
                     });
                     if (decision.action === "reroute") {
-                        current = { ...current, runtimeId: decision.routing.runtimeId, model: decision.routing.model };
+                        // A candidate changes only the routing dimensions it names. Preserve
+                        // the existing runtime/model for partial fallback routes (for example
+                        // a model-only fallback must not silently reset the selected agent).
+                        current = {
+                            ...current,
+                            ...(decision.routing.runtimeId !== undefined ? { runtimeId: decision.routing.runtimeId } : {}),
+                            ...(decision.routing.model !== undefined ? { model: decision.routing.model } : {}),
+                            // Account routing is not yet represented by WorkItem. Do not claim
+                            // that an account fallback was applied until the queue wire shape
+                            // and credential resolver support it end-to-end.
+                        };
                         rerouteCount = decision.rerouteCount;
                         await report({ routingReason: `fallback: ${decision.ref}` });
                     }

package/dist/metadata.js

@@ -103,7 +103,14 @@ export class MetadataStore {
         const prev = this.data.sessions[input.id];
         const createdAt = input.createdAt ?? prev?.createdAt ?? nowIso();
         const updatedAt = input.updatedAt ?? nowIso();
-        this.data.sessions[input.id] = { ...prev, ...input, createdAt, updatedAt };
+        // Runtime adapters do not all expose the same resume fields. In particular,
+        // an adapter can temporarily have no sessionFile while it is being rebuilt.
+        // Do not let that partial snapshot erase the durable resume ref (or any
+        // other field) already recorded for the session. The old object spread did
+        // exactly that: `{ path: undefined }` replaced the Pi transcript path, so
+        // reopening the saved row fell through to a fresh session.
+        const defined = Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined));
+        this.data.sessions[input.id] = { ...prev, ...defined, createdAt, updatedAt };
         this.save();
     }
     touchSession(id, status) {

package/dist/policy/ruleset.js

@@ -94,8 +94,25 @@ export const DEFAULT_RULESET = {
  * human-readable errors — never throws.
  */
 export function validateRuleset(value) {
-    if (Check(RulesetSchema, value))
-        return { ok: true, ruleset: value, errors: [] };
+    if (Check(RulesetSchema, value)) {
+        const ruleset = value;
+        const errors = [];
+        for (let ruleIndex = 0; ruleIndex < ruleset.rules.length; ruleIndex += 1) {
+            const rule = ruleset.rules[ruleIndex];
+            if (rule.action !== "reroute" || !rule.chain)
+                continue;
+            for (let candidateIndex = 0; candidateIndex < rule.chain.length; candidateIndex += 1) {
+                const candidate = rule.chain[candidateIndex];
+                const hasRoute = [candidate.runtimeId, candidate.model, candidate.account]
+                    .some((field) => typeof field === "string" && field.trim().length > 0);
+                if (!hasRoute)
+                    errors.push(`/rules/${ruleIndex}/chain/${candidateIndex}: fallback candidate must specify runtimeId, model, or account`);
+            }
+        }
+        if (errors.length)
+            return { ok: false, errors };
+        return { ok: true, ruleset, errors: [] };
+    }
     const errors = [...Errors(RulesetSchema, value)]
         .slice(0, 20)
         .map((e) => `${e.path || "/"}: ${e.message}`);

package/dist/runtime/auth-errors.js

@@ -77,3 +77,12 @@ export function authProviderForSession(runtimeId, modelProvider) {
         return provider;
     return undefined;
 }
+/** Convert a provider failure into the safe wire shape consumed by clients.
+ * Raw provider text can contain stack frames, paths, or tokens and must never
+ * be used as the user-facing auth error. */
+export function classifyModelAuthError(raw, runtimeId, modelProvider) {
+    if (!isModelAuthError(raw))
+        return null;
+    const provider = authProviderForSession(runtimeId, modelProvider);
+    return provider ? { kind: "model_auth", provider } : null;
+}

package/dist/server.js

@@ -34,7 +34,7 @@ import { InMemoryLocationRegistry } from "./runtime/location-registry.js";
 import { ControlPlaneSessionLocationRegistry, LayeredSessionLocationRegistry } from "./runtime/control-plane-location.js";
 import { attachAdoptedSessions, classifyAttachFailure } from "./runtime/adoption.js";
 import { createCredentialStore, testProviderCredential } from "./runtime/credentials.js";
-import { isModelAuthError, authProviderForSession } from "./runtime/auth-errors.js";
+import { isModelAuthError, authProviderForSession, classifyModelAuthError } from "./runtime/auth-errors.js";
 import { createCredentialVault, migrateVaultDir } from "./runtime/credential-store.js";
 import { probeAnthropicAccess } from "./runtime/anthropic-preflight.js";
 import { createSessionNamer, fallbackSessionName } from "./session/session-namer.js";
@@ -930,6 +930,7 @@ function harnessDirFor(record) {
 function harnessBeginTurn(record) {
     const dir = harnessDirFor(record);
     record.harnessTurnReady = undefined;
+    record.harnessTurnFinished = false;
     if (!dir)
         return;
     const previous = record.workspaceState === "dirty" ? "dirty" : "clean";
@@ -954,6 +955,14 @@ function harnessBeginTurn(record) {
     })();
 }
 /** After a turn, snapshot again and broadcast the structured diff it produced. */
+function finishHarnessTurn(record) {
+    if (record.harnessTurnFinished)
+        return;
+    record.harnessTurnFinished = true;
+    void harnessEndTurn(record).finally(() => {
+        void replication.onTurnComplete(record.id);
+    });
+}
 async function harnessEndTurn(record) {
     const previous = record.workspaceState === "dirty" ? "dirty" : "clean";
     try {
@@ -1643,11 +1652,14 @@ function stampSessionEvent(payload) {
     return payload;
 }
 // Collapse the burst of assistant `message_update`s (one per agent stdout line,
-// each carrying the FULL text so far) into ~1 fan-out per tick. See
-// session-event-coalescer.ts for the rationale (kills the O(n^2) re-serialize).
+// each carrying the FULL text so far) to a human-smooth 4 fps. A 16 ms window
+// still allowed up to 62 cumulative snapshots/second, making a long answer
+// quadratic and surprisingly expensive over a phone's relay connection. The
+// latest snapshot supersedes every skipped one, and non-update events flush it
+// immediately, so 250 ms changes neither final content nor event ordering.
 // The coalescer's emit stamps the surviving (latest) update, so only ~one seq is
-// spent per tick — the ring holds turn-scale events, not every stdout line.
-const SESSION_UPDATE_COALESCE_MS = 16;
+// spent per window — the ring holds turn-scale events, not every stdout line.
+const SESSION_UPDATE_COALESCE_MS = 250;
 const sessionEvents = new SessionEventCoalescer({
     coalesceMs: SESSION_UPDATE_COALESCE_MS,
     emit: (payload) => broadcastCoalesced(stampSessionEvent(payload)),
@@ -2842,7 +2854,7 @@ const RELAY_COMMANDS = {
             // this the relay client (PWA) is stranded on "Working…" forever with
             // only a session.error toast. Clear working so a terminal state reaches it.
             clearSessionWorking(record);
-            broadcast({ type: "session.error", sessionId: record.id, error: actionableAgentError(record.runtimeId, error) });
+            broadcast({ type: "session.error", sessionId: record.id, error: sessionAgentError(record, error) });
         });
     },
     async "session.new"(msg) {
@@ -4580,11 +4592,58 @@ async function reconcileInterruptedSessions() {
         }
     }
 }
+/** Run the legacy direct GitHub queue through the same failure policy as the
+ * hosted queue. There is no control-plane run/evidence endpoint on this path,
+ * so the policy is applied locally and terminal failures retain the poller's
+ * existing logging behavior. */
+async function runDirectGitHubIssueWithPolicy(cfg, issue) {
+    let ruleset;
+    try {
+        // Repository policy has precedence, matching the hosted queue. An invalid
+        // project policy must not disable the direct poller; fall back to the
+        // node-global policy and leave the validation error visible in the log.
+        ruleset = loadProjectPolicy(cfg.repoDir)?.ruleset;
+    }
+    catch (error) {
+        console.warn(`[policy] ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const policy = createRunPolicy({
+        context: "queue",
+        ruleset: ruleset ?? activeRulesetFor(rulesetsDir, "queue"),
+    });
+    let attempt = 1;
+    let rerouteCount = 0;
+    let routing = {};
+    for (;;) {
+        try {
+            await runIssueTask(cfg, issue, { ...routing });
+            return;
+        }
+        catch (error) {
+            const decision = policy.decide({ routing, error, attempt, rerouteCount });
+            if (decision.action !== "retry" && decision.action !== "reroute")
+                throw error;
+            attempt += 1;
+            if (decision.action === "reroute") {
+                routing = {
+                    ...(routing.runtimeId !== undefined ? { runtimeId: routing.runtimeId } : {}),
+                    ...(routing.model !== undefined ? { model: routing.model } : {}),
+                    ...(decision.routing.runtimeId !== undefined ? { runtimeId: decision.routing.runtimeId } : {}),
+                    ...(decision.routing.model !== undefined ? { model: decision.routing.model } : {}),
+                };
+                rerouteCount = decision.rerouteCount;
+            }
+            console.warn(`[github-tasks] issue #${issue.number} ${decision.action} (${decision.condition}): ${decision.summary}`);
+            if (decision.delayMs > 0)
+                await new Promise((resolve) => setTimeout(resolve, decision.delayMs));
+        }
+    }
+}
 async function startGitHubTasksIfConfigured() {
     const cfg = await resolveGitHubTaskConfig();
     if (!cfg)
         return;
-    githubPoller = new GitHubTaskPoller(cfg, (issue) => runIssueTask(cfg, issue), nodeGithubMaxConcurrent);
+    githubPoller = new GitHubTaskPoller(cfg, (issue) => runDirectGitHubIssueWithPolicy(cfg, issue), nodeGithubMaxConcurrent);
     githubPoller.start();
 }
 let controlPlanePoller;
@@ -5959,6 +6018,7 @@ async function sessionListRows() {
             agent: meta?.runtimeId ?? s.agent,
             agentName: meta?.agentName ?? s.agentName,
             source: rec?.source ?? meta?.source,
+            bivyCreated: Boolean(meta),
             forkedFrom: rec?.forkedFrom ?? meta?.forkedFrom,
             branch: rec?.worktree?.branch ?? meta?.branch,
             sandbox: rec?.sandbox ?? normalizeSandboxTier(meta?.sandbox),
@@ -7175,6 +7235,11 @@ function actionableAgentError(runtimeId, error) {
     }
     return raw;
 }
+function sessionAgentError(record, error) {
+    const raw = humanizeAgentError(error instanceof Error ? error.message : String(error));
+    return classifyModelAuthError(raw, record.runtimeId, record.session.getCurrentModel()?.provider)
+        ?? actionableAgentError(record.runtimeId, error);
+}
 /**
  * A turn that ended in a *terminal* model/provider failure the runtime would
  * otherwise swallow. `agent_end` carries the turn's messages and whether the
@@ -7231,7 +7296,7 @@ function attachSessionListeners(record) {
             policy: sessionRunPolicy,
             onNotice: (n) => broadcast({ type: "session.notice", sessionId: record.id, level: n.level, message: n.message }),
             onModelChanged: () => broadcast({ type: "model.updated", sessionId: record.id, model: publicModel(record.session.getCurrentModel(), record.session.getCurrentModel()) }),
-            onFailed: (message) => broadcast({ type: "session.error", sessionId: record.id, error: message }),
+            onFailed: (message) => broadcast({ type: "session.error", sessionId: record.id, error: sessionAgentError(record, message) }),
         });
     }
     record.unsubscribe = record.session.subscribe((event) => {
@@ -7328,9 +7393,14 @@ function attachSessionListeners(record) {
             transcripts.resolveInlineImages(record);
         }
         // Durably persist the throttled sidecars at the turn boundary so a crash
-        // loses at most the in-flight turn's UI detail, not the whole turn.
-        if (event.type === "turn_end")
+        // loses at most the in-flight turn's UI detail, not the whole turn. A
+        // runtime may keep its agent process alive and never emit agent_end (Pi),
+        // so turn_end is also authoritative for the interactive working state.
+        if (event.type === "turn_end") {
             eventLog.flush(record.id);
+            clearSessionWorking(record);
+            finishHarnessTurn(record);
+        }
         // AskUserQuestion is intercepted and answered by the daemon's guardian /
         // QuestionManager (see guardianInterceptor), which broadcasts
         // session.question(.resolved) from its own listeners — runtimes no longer
@@ -7365,14 +7435,9 @@ function attachSessionListeners(record) {
             transcripts.clearLiveIntermediate(record.id);
             clearSessionWorking(record);
             void refreshSessionUsage(record);
-            // Snapshot the worktree and broadcast the structured diff this turn made —
-            // universal edit review + rewind target, for every runtime.
-            // Warm-replicate this turn to the standby AFTER the checkpoint is committed
-            // (so the shipped frame carries this turn's transcript AND its checkpoint).
-            // Gated on session sync — inert by default.
-            void harnessEndTurn(record).finally(() => {
-                void replication.onTurnComplete(record.id);
-            });
+            // Snapshot/diff at whichever completion boundary arrived first. Pi keeps
+            // its process alive after turn_end; other runtimes also emit agent_end.
+            finishHarnessTurn(record);
             // A turn that ended in a terminal model/provider error (e.g. an expired
             // credential or a 4xx from the API) otherwise vanished: working cleared,
             // no reply, no signal. Surface it as a session-scoped error so the client
@@ -7434,7 +7499,7 @@ function attachSessionListeners(record) {
                 scheduleAdvertise();
                 broadcast({ type: "session.failed", sessionId: record.id, failedAt: record.lastFailureAt });
                 if (messageError)
-                    broadcast({ type: "session.error", sessionId: record.id, error: actionableAgentError(record.runtimeId, messageError) });
+                    broadcast({ type: "session.error", sessionId: record.id, error: sessionAgentError(record, messageError) });
                 // If the terminal error is an auth failure (expired key/token → 4xx),
                 // also raise the sign-in sheet for the failing provider.
                 maybeSignalAuthRequired(record, turnError);
@@ -8058,7 +8123,7 @@ async function createSession(workspace = defaultWorkspace, sessionFile, opts = {
     void refreshSessionUsage(record);
     if (makeActive)
         active = record;
-    broadcast({ type: "session.created", sessionId, name: record.session.getName(), workspace: sessionWorkspace, sessionFile: record.sessionFile, source: record.source, branch: worktree?.branch, prUrl: record.prUrl, runtimeId: rt.id, agentName: rt.displayName, modelFallbackMessage, bivySession: bivySessionEnvelope(record), capabilities: capabilitiesWithCommands(rt.id, record.session) });
+    broadcast({ type: "session.created", sessionId, name: record.session.getName(), workspace: sessionWorkspace, sessionFile: record.sessionFile, source: record.source, bivyCreated: true, branch: worktree?.branch, prUrl: record.prUrl, runtimeId: rt.id, agentName: rt.displayName, modelFallbackMessage, bivySession: bivySessionEnvelope(record), capabilities: capabilitiesWithCommands(rt.id, record.session) });
     void maybeNotifyBivyUpdate();
     scheduleAdvertise();
     return record;
@@ -8075,6 +8140,12 @@ async function createSession(workspace = defaultWorkspace, sessionFile, opts = {
  * of the same session onto one promise fixes both.
  */
 const resumingSessions = new Map();
+// Keep an id index as well as the resolved runtime ref. A prompt can arrive
+// while session.open is still resolving and may not carry the session's path;
+// without this index it cannot discover the in-flight open from metadata and
+// is incorrectly reported as "Session not found". Both commands must join the
+// same resume operation by the identity the client actually supplied.
+const resumingSessionsById = new Map();
 /**
  * Resolve the session a client command targets, resuming it from durable
  * metadata when it isn't currently held in memory. A session survives being
@@ -8097,6 +8168,9 @@ async function resolveOrResumeSession(sessionId, sessionPath) {
     const open = openSessions.get(id);
     if (open)
         return open;
+    const byId = resumingSessionsById.get(id);
+    if (byId)
+        return byId;
     const pathRef = typeof sessionPath === "string" && sessionPath.trim() ? sessionPath.trim() : undefined;
     const meta = metadata.getSession(id) ?? (pathRef ? metadata.getSession(pathRef) : undefined);
     // A run that only kept its terminal log has nothing to resume — it opens as a
@@ -8152,15 +8226,23 @@ async function resolveOrResumeSession(sessionId, sessionPath) {
         }
     }
     const inflight = resumingSessions.get(key);
-    if (inflight)
+    if (inflight) {
+        resumingSessionsById.set(id, inflight);
         return inflight;
+    }
     const resume = createSession(defaultWorkspace, ref, { runtimeId, makeActive: false });
     resumingSessions.set(key, resume);
+    resumingSessionsById.set(id, resume);
     try {
         return await resume;
     }
     finally {
         resumingSessions.delete(key);
+        // Only delete our promise. A future implementation may replace an entry
+        // after a failed resume, and must not have its newer attempt removed by an
+        // older finally block.
+        if (resumingSessionsById.get(id) === resume)
+            resumingSessionsById.delete(id);
     }
 }
 // Enumerating a runtime's models needs a live session (the model registry lives
@@ -9836,6 +9918,7 @@ app.get("/api/sessions", async (_req, res, next) => {
                 agent: meta?.runtimeId ?? s.agent,
                 agentName: meta?.agentName ?? s.agentName,
                 source: rec?.source ?? meta?.source,
+                bivyCreated: Boolean(meta),
                 forkedFrom: rec?.forkedFrom ?? meta?.forkedFrom,
                 branch: rec?.worktree?.branch ?? meta?.branch,
                 prUrl: rec?.prUrl ?? meta?.prUrl,
@@ -9857,7 +9940,18 @@ app.get("/api/sessions", async (_req, res, next) => {
 });
 app.post("/api/sessions/open", async (req, res, next) => {
     try {
-        const session = await createSession(defaultWorkspace, String(req.body?.path ?? ""), { runtimeId: agentFrom(req.body ?? {}) });
+        // Direct transports use this endpoint for both opening a saved session and
+        // the legacy path-only open flow.  The old path-only implementation ignored
+        // sessionId, so a direct client sending into a closed chat opened a brand-new
+        // session instead of reopening the selected conversation.
+        const requestedId = typeof req.body?.sessionId === "string" && req.body.sessionId.trim()
+            ? req.body.sessionId.trim()
+            : undefined;
+        const session = requestedId
+            ? await resolveOrResumeSession(requestedId, req.body?.path)
+            : await createSession(defaultWorkspace, String(req.body?.path ?? ""), { runtimeId: agentFrom(req.body ?? {}) });
+        if (!session)
+            return res.status(404).json({ error: "Session not found" });
         res.json({
             id: session.id,
             workspace: session.workspace,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bivy/bivy",
-  "version": "0.15.0-staging.9",
+  "version": "0.16.0-staging.1",
   "type": "module",
   "license": "AGPL-3.0-only",
   "description": "Run coding agents on machines you own. Open-source, self-hostable agent workspace.",
@@ -50,9 +50,9 @@
     "zod": "^4.0.0"
   },
   "optionalDependencies": {
-    "@anthropic-ai/claude-agent-sdk": "0.3.246",
-    "@earendil-works/pi-ai": "0.84.3",
-    "@earendil-works/pi-coding-agent": "0.84.3",
+    "@anthropic-ai/claude-agent-sdk": "0.3.251",
+    "@earendil-works/pi-ai": "0.84.4",
+    "@earendil-works/pi-coding-agent": "0.84.4",
     "node-pty": "^1.1.0"
   },
   "overrides": {