@bivy/bivy 0.16.1-staging.4 → 0.16.1-staging.6

package/bin/bivy.mjs

@@ -34,7 +34,7 @@ import { randomBytes, createCipheriv, createDecipheriv, randomUUID, createHash,
 import { fileURLToPath, pathToFileURL } from "node:url";
 import vm from "node:vm";
 import { selectStaleSessions, sessionActivityMs } from "./prune-sessions.mjs";
-import { resolveSessionsLimit, truncateSavedSessions } from "./sessions-list.mjs";
+import { nativeResumeRef, resolveSessionsLimit, truncateSavedSessions } from "./sessions-list.mjs";
 import { renderManagedBlock, upsertManagedBlock, removeManagedBlock, rcFileForShell } from "./shim-path.mjs";
 import { removeInstallAndState } from "./uninstall-paths.mjs";
 import { findAvailablePort, reconcilePort } from "./port-picker.mjs";
@@ -1178,6 +1178,7 @@ const AGENT_RESUME_ARGS = {
   codex: (id) => ["resume", id],
   grok: (id) => ["--resume", id],
   gemini: (id) => ["--resume", id],
+  qwen: (id) => ["--resume", id],
   // `opencode -s, --session  session id to continue` (TUI), per `opencode --help`.
   opencode: (id) => ["--session", id],
 };
@@ -2428,7 +2429,11 @@ async function resumeSessionItem(item, config, token) {
     console.log(c.yellow(`"${item.name}" (${item.agentName || item.agent}) has no native terminal resume; open it in the web app with 'bivy open'.`));
     return;
   }
-  const resumeArgs = agentResumeArgs(agentId, item.id || item.ref);
+  // Resume with the provider's durable ref, not Bivy's canonical id. They
+  // differ for imported/forked sessions (notably Codex), and passing the Bivy id
+  // makes the native CLI report "No saved session found".
+  const resumeRef = nativeResumeRef(item);
+  const resumeArgs = agentResumeArgs(agentId, resumeRef);
   const runArgs = [agentId, ...resumeArgs];
   if (item.workspace) runArgs.push("--workspace", item.workspace); // native resume finds the session by its original cwd
   console.log(c.dim(`Resuming ${c.cyan(item.name)} with ${agentId} ${resumeArgs.join(" ")}…`));

package/bin/sessions-list.mjs

@@ -25,3 +25,14 @@ export function resolveSessionsLimit(rawArg) {
 export function truncateSavedSessions(sessions, limit) {
   return sessions.slice(0, limit);
 }
+
+/**
+ * Pick the provider-native token for a terminal resume. `id` is Bivy's
+ * canonical conversation id; `ref` is the runtime's durable resume ref exposed
+ * as `SessionSummary.path` (a Codex rollout id, a Claude session id, etc.).
+ * They are often equal, but forks/imports deliberately give a conversation a
+ * new Bivy id while retaining a different provider ref.
+ */
+export function nativeResumeRef(item) {
+  return item?.ref || item?.id;
+}

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.251";
+export const CLAUDE_TESTED_VERSION = "0.3.252";
 const CLAUDE_CAPABILITIES = withExactCapabilitySurface({
     toolInterception: true,
     modelSelection: true,

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

@@ -497,14 +497,22 @@ function findClaudeTranscript(sessionId) {
             for (const project of fs.readdirSync(projectsRoot, { withFileTypes: true })) {
                 if (!project.isDirectory())
                     continue;
-                const projectRoot = fs.realpathSync(path.resolve(projectsRoot, project.name));
-                if (!projectRoot.startsWith(`${projectsRoot}${path.sep}`))
-                    continue;
-                const candidate = fs.realpathSync(path.resolve(projectRoot, fileName));
-                if (!candidate.startsWith(`${projectRoot}${path.sep}`))
+                try {
+                    const projectRoot = fs.realpathSync(path.resolve(projectsRoot, project.name));
+                    if (!projectRoot.startsWith(`${projectsRoot}${path.sep}`))
+                        continue;
+                    // Most project directories do not contain this session. Resolve each
+                    // candidate independently: a missing file in the first project must
+                    // not abort the whole store scan and hide a transcript in a later one.
+                    const candidate = fs.realpathSync(path.resolve(projectRoot, fileName));
+                    if (!candidate.startsWith(`${projectRoot}${path.sep}`))
+                        continue;
+                    if (path.basename(candidate) === fileName)
+                        return candidate;
+                }
+                catch {
                     continue;
-                if (path.basename(candidate) === fileName)
-                    return candidate;
+                }
             }
         }
         catch {

package/dist/agents/pi/integration.js

@@ -12,6 +12,25 @@ export function piAgentDir() {
 export function piCommand() {
     return process.env.BIVY_PI_COMMAND?.trim() || "pi";
 }
+/** List sessions written by the operator's native `pi` TUI. Governed Pi chats
+ * use Bivy's own sessions directory, while `bivy run pi` intentionally keeps
+ * Pi's native auth/config untouched and therefore writes under
+ * PI_CODING_AGENT_DIR (normally ~/.pi/agent). Takeover discovery must inspect
+ * that native store rather than only the governed one. */
+export async function listNativePiSessions() {
+    const { SessionManager } = await import("@earendil-works/pi-coding-agent");
+    const sessions = await SessionManager.listAll(path.join(piAgentDir(), "sessions"));
+    return sessions.map((session) => ({
+        id: session.id,
+        path: session.path,
+        cwd: session.cwd,
+        name: session.name,
+        created: session.created,
+        modified: session.modified,
+        messageCount: session.messageCount,
+        firstMessage: session.firstMessage,
+    }));
+}
 const PI_COMMAND_CACHE = new Map();
 export function piCommandAvailable() {
     const command = piCommand();

package/dist/agents/profiles.js

@@ -153,6 +153,7 @@ export const AGENT_PROFILES = {
     },
     gemini: {
         displayName: "Gemini CLI",
+        behaviors: { nativeSessions: "gemini" },
         command: "gemini",
         packageName: "@google/gemini-cli",
         supportTier: "supported",
@@ -185,7 +186,7 @@ export const AGENT_PROFILES = {
         // most recent or index number (e.g. --resume 5)`, per `gemini --help`; a
         // session UUID also works). `{sandbox}` re-derives --approval-mode from the
         // tier so a resumed turn stays as contained as a fresh one.
-        resume: { template: ["-o", "json", "{sandbox}", "-r", "{id}", "-p"] },
+        resume: { template: ["-o", "json", "{sandbox}", "-r", "{id}", "-p"], historyLoader: "gemini" },
         // Gemini CLI speaks ACP (`--experimental-acp`), so it can be driven through the
         // governed ProtocolRuntime instead of the one-shot pipe — per-tool approvals +
         // streaming + resume. Opt in with BIVY_GEMINI_ACP=1 (or global BIVY_PREFER_ACP=1);
@@ -196,6 +197,7 @@ export const AGENT_PROFILES = {
     },
     qwen: {
         displayName: "Qwen Code",
+        behaviors: { nativeSessions: "qwen" },
         command: "qwen",
         packageName: "@qwen-code/qwen-code",
         supportTier: "supported",
@@ -225,7 +227,7 @@ export const AGENT_PROFILES = {
         },
         // Gemini-CLI fork: same `--resume <id>` headless resume form (Qwen Code docs,
         // "Headless Mode"). `{sandbox}` re-derives --approval-mode from the tier.
-        resume: { template: ["--output-format", "json", "{sandbox}", "--resume", "{id}", "-p"] },
+        resume: { template: ["--output-format", "json", "{sandbox}", "--resume", "{id}", "-p"], historyLoader: "qwen" },
         // Qwen Code inherits Gemini CLI's ACP server (packages/cli/src/acp-integration),
         // so it can be driven through the governed ProtocolRuntime instead of the pipe —
         // per-tool approvals + streaming + resume. Newer builds graduated the flag to

package/dist/certification/generated.js

@@ -3,7 +3,7 @@
 export const CERTIFICATION_MATRIX = {
     schemaVersion: 1,
     agents: [
-        { id: "claude-code-sdk", status: "active", executionMode: "protocol", pinnedVersion: "0.3.251", capabilities: ["toolInterception", "modelSelection", "resume"] },
+        { id: "claude-code-sdk", status: "active", executionMode: "protocol", pinnedVersion: "0.3.252", 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/runtime/cli-parsers.js

@@ -90,6 +90,12 @@ class TurnAccumulator {
     textFlushed = "";
     out = [];
     details = new Map();
+    // Not every CLI includes a stable id on both halves of a tool exchange.
+    // Keep a small FIFO of open calls so the universal parser can still pair an
+    // anonymous result with its call instead of creating a second, forever-running
+    // card in the transcript.
+    openToolIds = [];
+    anonymousToolId = 0;
     flushPendingText() {
         const pending = this.text.slice(this.textFlushed.length);
         this.textFlushed = this.text;
@@ -131,25 +137,35 @@ class TurnAccumulator {
         events.push({ type: "message_update", message: { role: "assistant", content: this.text } });
     }
     addToolUse(id, name, input, events) {
-        traceToolPayload({ phase: "call", context: this.toolContext, name, callId: id, payload: input });
+        const callId = id || `cli-tool-${++this.anonymousToolId}`;
+        this.openToolIds.push(callId);
+        traceToolPayload({ phase: "call", context: this.toolContext, name, callId, payload: input });
         // Attach a normalized ToolCallDetail (display-only) so the PWA renders this
         // call the same way it renders every other agent's equivalent call. Absent
         // when unrecognized — the block stays opaque and renders as before.
         const detail = mapToolCall(name, input, this.toolContext);
-        if (detail && id)
-            this.details.set(id, detail);
+        if (detail)
+            this.details.set(callId, detail);
         this.flushPendingText();
-        this.content.push({ type: "tool_use", id, name, input: input ?? {}, ...(detail ? { detail } : {}) });
-        events.push({ type: "tool_call", toolName: name, input, toolCallId: id, ...(detail ? { detail } : {}) });
+        this.content.push({ type: "tool_use", id: callId, name, input: input ?? {}, ...(detail ? { detail } : {}) });
+        events.push({ type: "tool_call", toolName: name, input, toolCallId: callId, ...(detail ? { detail } : {}) });
     }
     addToolResult(toolUseId, name, content, events, isError = false) {
-        traceToolPayload({ phase: "result", context: this.toolContext, name, callId: toolUseId, payload: content });
-        const prior = this.details.get(toolUseId);
+        // Prefer the explicit id. Otherwise close the oldest open call, which is
+        // the only generally safe correlation available from an id-less stream.
+        const callId = toolUseId || this.openToolIds.shift() || `cli-tool-result-${++this.anonymousToolId}`;
+        if (toolUseId) {
+            const index = this.openToolIds.indexOf(toolUseId);
+            if (index >= 0)
+                this.openToolIds.splice(index, 1);
+        }
+        traceToolPayload({ phase: "result", context: this.toolContext, name, callId, payload: content });
+        const prior = this.details.get(callId);
         const detail = prior ? { ...prior, result: mapToolResult(content, isError) } : undefined;
         if (detail)
-            this.details.set(toolUseId, detail);
-        this.toolResults.push({ type: "tool_result", tool_use_id: toolUseId, content: content ?? "", ...(detail ? { detail } : {}) });
-        events.push({ type: "tool_result", toolName: name, result: { toolCallId: toolUseId, content }, ...(detail ? { detail } : {}) });
+            this.details.set(callId, detail);
+        this.toolResults.push({ type: "tool_result", tool_use_id: callId, content: content ?? "", ...(detail ? { detail } : {}) });
+        events.push({ type: "tool_result", toolName: name, result: { toolCallId: callId, content }, ...(detail ? { detail } : {}) });
     }
     /** Finalize the turn: emit message_end/turn_end/agent_end and record history. */
     finish(events) {

package/dist/runtime/gemini-sessions.js

@@ -0,0 +1,209 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Petter André Sjulstad
+// Gemini CLI / Qwen Code on-disk session readers. Both agents persist JSON or
+// JSONL conversations, but currently use different directory layouts. Keep the
+// parser tolerant: upstream has migrated Gemini from whole-file JSON to
+// append-only JSONL, while Qwen stores one JSONL transcript per session.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { hasLiveProcessForCwd } from "./native-process-scan.js";
+function homeFor(agent) {
+    if (agent === "qwen") {
+        return process.env.QWEN_RUNTIME_DIR?.trim() || process.env.QWEN_HOME?.trim() || path.join(os.homedir(), ".qwen");
+    }
+    return process.env.GEMINI_CLI_HOME?.trim() || path.join(os.homedir(), ".gemini");
+}
+function textOf(value) {
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value))
+        return value.map(textOf).filter(Boolean).join("\n");
+    if (!value || typeof value !== "object")
+        return "";
+    const rec = value;
+    if (typeof rec.text === "string")
+        return rec.text;
+    if (rec.parts)
+        return textOf(rec.parts);
+    return "";
+}
+function epoch(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value !== "string")
+        return undefined;
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function projectRootNear(file) {
+    let dir = path.dirname(file);
+    for (let i = 0; i < 4; i++) {
+        try {
+            const root = fs.readFileSync(path.join(dir, ".project_root"), "utf8").trim();
+            if (root)
+                return root;
+        }
+        catch { /* continue upward */ }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return undefined;
+}
+function parseRecords(file) {
+    let raw;
+    let stat;
+    try {
+        raw = fs.readFileSync(file, "utf8");
+        stat = fs.statSync(file);
+    }
+    catch {
+        return undefined;
+    }
+    let records;
+    try {
+        const whole = JSON.parse(raw);
+        records = [whole, ...(Array.isArray(whole.messages) ? whole.messages : [])];
+    }
+    catch {
+        records = raw.split(/\r?\n/).filter((line) => line.trim()).flatMap((line) => {
+            try {
+                return [JSON.parse(line)];
+            }
+            catch {
+                return [];
+            }
+        });
+    }
+    let id;
+    let cwd = projectRootNear(file);
+    let createdAt;
+    let updatedAt;
+    const messages = new Map();
+    let sequence = 0;
+    const addMessage = (value) => {
+        if (!value || typeof value !== "object")
+            return;
+        const rec = value;
+        const type = rec.type ?? rec.role;
+        if (type !== "user" && type !== "gemini" && type !== "assistant" && type !== "model")
+            return;
+        const content = rec.content ?? rec.message;
+        const text = textOf(content).trim();
+        if (!text)
+            return;
+        const role = type === "user" ? "user" : "assistant";
+        const key = typeof rec.id === "string" ? rec.id : `message-${sequence++}`;
+        messages.set(key, { role, content: text, timestamp: epoch(rec.timestamp ?? rec.createdAt) });
+    };
+    for (const value of records) {
+        if (!value || typeof value !== "object")
+            continue;
+        const rec = value;
+        if (typeof rec.sessionId === "string")
+            id = rec.sessionId;
+        if (typeof rec.cwd === "string")
+            cwd = rec.cwd;
+        createdAt ??= epoch(rec.startTime ?? rec.createdAt ?? rec.timestamp);
+        updatedAt = epoch(rec.lastUpdated ?? rec.updatedAt ?? rec.timestamp) ?? updatedAt;
+        if (rec.$set && typeof rec.$set === "object") {
+            const set = rec.$set;
+            if (typeof set.sessionId === "string")
+                id = set.sessionId;
+            if (typeof set.cwd === "string")
+                cwd = set.cwd;
+            createdAt ??= epoch(set.startTime ?? set.createdAt);
+            updatedAt = epoch(set.lastUpdated ?? set.updatedAt) ?? updatedAt;
+            if (Array.isArray(set.messages))
+                for (const message of set.messages)
+                    addMessage(message);
+        }
+        if (typeof rec.$rewindTo === "string") {
+            let remove = false;
+            for (const key of [...messages.keys()]) {
+                if (key === rec.$rewindTo)
+                    remove = true;
+                if (remove)
+                    messages.delete(key);
+            }
+            continue;
+        }
+        addMessage(rec);
+    }
+    // Qwen names transcripts by the full session id. Gemini's filename contains
+    // only a short id, so require its metadata instead of inventing an unusable ref.
+    if (!id && /^[0-9a-f-]{16,}\.jsonl$/i.test(path.basename(file)))
+        id = path.basename(file, ".jsonl");
+    if (!id)
+        return undefined;
+    const out = [...messages.values()];
+    const first = out.find((message) => message.role === "user");
+    return {
+        id,
+        file,
+        cwd,
+        createdAt: createdAt ?? (stat.birthtimeMs || stat.mtimeMs),
+        updatedAt: updatedAt ?? stat.mtimeMs,
+        firstMessage: typeof first?.content === "string" ? first.content.slice(0, 120) : undefined,
+        messages: out,
+    };
+}
+function sessionFiles(agent) {
+    const home = homeFor(agent);
+    const roots = agent === "qwen" ? [path.join(home, "projects")] : [path.join(home, "tmp")];
+    const out = [];
+    const walk = (dir, depth) => {
+        if (depth < 0)
+            return;
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory())
+                walk(full, depth - 1);
+            else if (entry.isFile() && /\.jsonl?$/.test(entry.name) && !entry.name.endsWith(".ledger.jsonl")) {
+                const parent = path.basename(path.dirname(full));
+                if (parent === "chats" || path.basename(path.dirname(path.dirname(full))) === "chats")
+                    out.push(full);
+            }
+        }
+    };
+    for (const root of roots)
+        walk(root, 4);
+    return out;
+}
+export function listGeminiFamilySessions(agent) {
+    return sessionFiles(agent)
+        .map(parseRecords)
+        .filter((session) => Boolean(session))
+        .sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0));
+}
+export function loadGeminiFamilyTranscript(agent, sessionId) {
+    return listGeminiFamilySessions(agent).find((session) => session.id === sessionId)?.messages ?? [];
+}
+export function discoverGeminiFamilySessionForCwd(agent, cwd, since) {
+    const target = path.resolve(cwd);
+    const earliest = since - 10_000;
+    return listGeminiFamilySessions(agent)
+        .filter((session) => session.cwd && path.resolve(session.cwd) === target && (session.createdAt ?? 0) >= earliest)
+        .sort((a, b) => Math.abs((a.createdAt ?? 0) - since) - Math.abs((b.createdAt ?? 0) - since))[0];
+}
+export function discoverNativeGeminiFamilySessions(agent) {
+    return listGeminiFamilySessions(agent).map((session) => ({
+        runtimeId: agent,
+        ref: session.id,
+        file: session.file,
+        cwd: session.cwd,
+        updatedAt: session.updatedAt ?? session.createdAt,
+        title: session.firstMessage,
+        active: Boolean(session.cwd) && hasLiveProcessForCwd(session.cwd, agent === "gemini" ? ["gemini"] : ["qwen", "qwen-code"]),
+        resumable: true,
+    }));
+}

package/dist/runtime/index.js

@@ -13,6 +13,7 @@ import { invalidatePiCommandProbe, piAgentDir, piCommandAvailable, piIntegration
 import { deleteCodexSession, loadCodexTranscript } from "./codex-sessions.js";
 import { deleteOpenCodeSession, exportOpenCodeSession, importOpenCodeSession, loadOpenCodeTranscript, writeOpenCodeHistory } from "./opencode-sessions.js";
 import { discoverNativeGrokSessions, listGrokSessions, loadGrokTranscript } from "./grok-sessions.js";
+import { discoverNativeGeminiFamilySessions, listGeminiFamilySessions, loadGeminiFamilyTranscript } from "./gemini-sessions.js";
 import { createCredentialStore } from "./credentials.js";
 import { AgentRegistry } from "../agents/registry.js";
 import { applyCertification } from "../certification/index.js";
@@ -1196,7 +1197,11 @@ function makeCliRuntime(id, options, spec) {
         : resumeTemplate
             ? {
                 resumable: true,
-                loadHistory: spec.resume?.historyLoader === "grok" ? loadGrokTranscript : undefined,
+                loadHistory: spec.resume?.historyLoader === "grok"
+                    ? loadGrokTranscript
+                    : spec.resume?.historyLoader === "gemini" || spec.resume?.historyLoader === "qwen"
+                        ? (sessionId) => loadGeminiFamilyTranscript(spec.resume.historyLoader, sessionId)
+                        : undefined,
                 // `{sandbox}` expands to that agent's native containment flags for
                 // the tier (e.g. Gemini/Qwen's `--approval-mode <mode>`) — a whole
                 // token, not a string substitution, since it can be multiple argv
@@ -1213,24 +1218,36 @@ function makeCliRuntime(id, options, spec) {
                     : [a.replace(/\{id\}/g, sessionId).replace(/\{tier\}/g, tier)]),
             }
             : {};
-    // Grok-specific: on-disk session enumeration + interactive TUI hand-off so
-    // `bivy run grok` sessions persist after the PTY exits and can be taken
-    // over as chat or reopened in the native TUI.
-    const nativeSessionOpts = behaviors?.nativeSessions === "grok"
+    // Profile-selected native session enumeration + interactive TUI hand-off.
+    // Store readers keep terminal-originated sessions resumable and let the
+    // generic ProcessRuntime preload their transcript during chat takeover.
+    const nativeSessionBehavior = behaviors?.nativeSessions;
+    const nativeSessionOpts = nativeSessionBehavior
         ? {
             sessionDiscovery: true,
-            listDiskSessions: () => listGrokSessions().map((s) => ({
-                id: s.id,
-                path: s.dir,
-                cwd: s.cwd,
-                name: s.name || s.firstMessage,
-                created: s.createdAt ? new Date(s.createdAt).toISOString() : undefined,
-                modified: s.updatedAt ? new Date(s.updatedAt).toISOString() : undefined,
-                firstMessage: s.firstMessage,
-            })),
-            interactiveTui: ({ sessionRef, env }) => sessionRef ? { command: "grok", args: ["--resume", sessionRef], env } : null,
-            // discoverNativeSessions is on AgentRuntime; ProcessRuntime doesn't
-            // expose it as an option — wire via a thin subclass below when needed.
+            listDiskSessions: () => {
+                if (nativeSessionBehavior === "grok") {
+                    return listGrokSessions().map((s) => ({
+                        id: s.id,
+                        path: s.dir,
+                        cwd: s.cwd,
+                        name: s.name || s.firstMessage,
+                        created: s.createdAt ? new Date(s.createdAt).toISOString() : undefined,
+                        modified: s.updatedAt ? new Date(s.updatedAt).toISOString() : undefined,
+                        firstMessage: s.firstMessage,
+                    }));
+                }
+                return listGeminiFamilySessions(nativeSessionBehavior).map((s) => ({
+                    id: s.id,
+                    path: s.id,
+                    cwd: s.cwd,
+                    name: s.firstMessage,
+                    created: s.createdAt ? new Date(s.createdAt).toISOString() : undefined,
+                    modified: s.updatedAt ? new Date(s.updatedAt).toISOString() : undefined,
+                    firstMessage: s.firstMessage,
+                }));
+            },
+            interactiveTui: ({ sessionRef, env }) => sessionRef ? { command: spec.command, args: ["--resume", sessionRef], env } : null,
         }
         : {};
     const runtime = new ProcessRuntime({
@@ -1250,10 +1267,12 @@ function makeCliRuntime(id, options, spec) {
         ...resumeOpts,
         ...nativeSessionOpts,
     });
-    if (behaviors?.nativeSessions === "grok") {
+    if (nativeSessionBehavior) {
         // Issue #156 discovery surface — ProcessRuntime has no options hook for
-        // this; attach it so collectDiscoveredSessions picks Grok sessions up.
-        runtime.discoverNativeSessions = () => discoverNativeGrokSessions();
+        // this; attach the profile's native store reader to the generic runtime.
+        runtime.discoverNativeSessions = () => nativeSessionBehavior === "grok"
+            ? discoverNativeGrokSessions()
+            : discoverNativeGeminiFamilySessions(nativeSessionBehavior);
     }
     return runtime;
 }

package/dist/runtime/protocol.js

@@ -193,6 +193,25 @@ class ProtocolSession {
     // toolCallId -> the node's normalized classification, so a later tool.result
     // (or tool.update) can attach/refresh `detail` on the already-pushed block.
     toolDetailsByCallId = new Map();
+    openToolIds = [];
+    anonymousToolId = 0;
+    /** Protocol is intentionally agent-neutral: if an upstream omits ids, give
+     * the exchange a local identity so live and persisted views can still pair it. */
+    resolveToolId(raw, result = false) {
+        if (raw) {
+            if (result) {
+                const index = this.openToolIds.indexOf(raw);
+                if (index >= 0)
+                    this.openToolIds.splice(index, 1);
+            }
+            return raw;
+        }
+        if (result)
+            return this.openToolIds.shift() || `protocol-tool-result-${++this.anonymousToolId}`;
+        const id = `protocol-tool-${++this.anonymousToolId}`;
+        this.openToolIds.push(id);
+        return id;
+    }
     constructor(runtimeOptions, cwd, capabilitiesRef, toolInterceptor, 
     // When resuming, the agent's own session ref (e.g. a Codex thread id). Passed
     // back to the shim via the generic session.resume primitive so it reconnects
@@ -686,6 +705,7 @@ class ProtocolSession {
             this.turnTextFlushed = "";
             this.turnToolResults = [];
             this.toolDetailsByCallId.clear();
+            this.openToolIds = [];
             this.emit({ type: "agent_end" });
             return;
         }
@@ -696,12 +716,13 @@ class ProtocolSession {
             this.turnTextFlushed = "";
             this.turnToolResults = [];
             this.toolDetailsByCallId.clear();
+            this.openToolIds = [];
             this.emit({ type: "session.error", error: String(msg.error || "Protocol agent error") });
             this.emit({ type: "agent_end" });
             return;
         }
         if (type === "tool.call" || type === "tool.observe") {
-            const toolCallId = String(msg.toolCallId || msg.id || "");
+            const toolCallId = this.resolveToolId(String(msg.toolCallId || msg.id || ""));
             const toolName = String(msg.name || "tool");
             const detail = mapToolCall(toolName, msg.input, { provider: this.runtimeOptions.id || "acp", protocol: "protocol" });
             if (detail)
@@ -763,7 +784,7 @@ class ProtocolSession {
             return;
         }
         if (type === "tool.result") {
-            const toolCallId = String(msg.toolCallId || msg.tool_use_id || msg.id || "");
+            const toolCallId = this.resolveToolId(String(msg.toolCallId || msg.tool_use_id || msg.id || ""), true);
             const result = msg.result ?? msg.output ?? msg.content ?? msg.text ?? msg.summary ?? "";
             const isError = Boolean(msg.isError || msg.is_error);
             this.turnToolResults.push({

package/dist/server.js

@@ -48,6 +48,7 @@ import { isNativeOAuthProvider, loginModelOAuth } from "./runtime/oauth/model-oa
 import { decideOAuthLoginSweep } from "./runtime/oauth/oauth-login-sweep.js";
 import { listCodexSessions, loadCodexTranscript } from "./runtime/codex-sessions.js";
 import { dedupeSessionSummaries } from "./session-identity.js";
+import { listNativePiSessions } from "./agents/pi/integration.js";
 import { deriveSessionState } from "./session/session-state.js";
 import { resolveStreamingBehavior } from "./session/record.js";
 import { createSessionEngine } from "./session/engine.js";
@@ -8465,7 +8466,19 @@ const runTerms = createRunTerminals({
     listAllSessions,
     listProvidersUnified,
     pushModelAuthToControlPlane: () => pushModelAuthToControlPlane(),
-    listPiSessions: () => runtimeHost.listSessions(getRuntime("pi")),
+    listPiSessions: async () => {
+        // `bivy run pi` is an agent-owned native TUI and writes to Pi's own store;
+        // governed Pi chats write to Bivy's isolated store. Search both so a native
+        // terminal can always be correlated and taken over after its first turn.
+        const [governed, native] = await Promise.all([
+            runtimeHost.listSessions(getRuntime("pi")).catch(() => []),
+            listNativePiSessions().catch(() => []),
+        ]);
+        const byRef = new Map();
+        for (const session of [...governed, ...native])
+            byRef.set(session.path || session.id, session);
+        return [...byRef.values()];
+    },
     resolveAuthOwner: (agent) => {
         const integrationId = agent ? canonicalAgentId(agent) : undefined;
         return listRuntimes(agent).find((a) => a.id === integrationId)?.authOwner ?? "agent";
@@ -10094,7 +10107,11 @@ app.post("/api/session", async (req, res, next) => {
         res.json({ id: session.id, workspace: session.workspace, source: session.source, branch: session.worktree?.branch, prUrl: session.prUrl, sessionFile: session.sessionFile, name: session.session.getName(), runtimeId: session.runtimeId, agentName: getRuntime(session.runtimeId).displayName, model: publicModel(session.session.getCurrentModel(), session.session.getCurrentModel()), sessionState: sessionState(session) });
     }
     catch (error) {
-        res.status(400).json({ error: actionableAgentError(agentFrom(req.body ?? {}) ?? defaultRuntimeId, error) });
+        // Creating an empty session does not contact the model provider. Failures
+        // here come from workspace/repository/runtime setup (for example Git remote
+        // authentication), so classifying a generic "authentication failed" as a
+        // Claude/Codex login problem sends the user to the wrong sign-in flow.
+        res.status(400).json({ error: humanizeAgentError(error instanceof Error ? error.message : String(error)) });
     }
 });
 app.get("/api/github/issues", async (_req, res, next) => {

package/dist/session/run-terminal.js

@@ -18,6 +18,7 @@ import { provisionAgentRun } from "../runtime/credential-provisioning.js";
 import { ingestAgentCredentials } from "../runtime/credential-ingest.js";
 import { discoverCodexSessionForCwd } from "../runtime/codex-sessions.js";
 import { discoverGrokSessionForCwd } from "../runtime/grok-sessions.js";
+import { discoverGeminiFamilySessionForCwd } from "../runtime/gemini-sessions.js";
 import { discoverOpenCodeSessionForCwd } from "../runtime/opencode-sessions.js";
 import { discoverPiSessionForCwd } from "../runtime/pi-session-discovery.js";
 import { listMultiplexerSessions, attachCommand } from "../multiplexer.js";
@@ -30,6 +31,7 @@ const TAKEOVER_RUNTIME_BY_AGENT = {
     // Pinned at launch (`gemini --session-id <uuid>`); the gemini runtime's resume
     // template (`-r {id}`) reopens it as a governed chat.
     gemini: "gemini",
+    qwen: "qwen",
     // Discovered at exit from OpenCode's own store (discoverOpenCodeSessionForCwd);
     // the opencode runtime's resume template (`run -s {id}`) continues it.
     opencode: "opencode",
@@ -40,6 +42,7 @@ const RESUME_CLI_BY_AGENT = {
     codex: (id) => `codex resume ${id}`,
     grok: (id) => `grok --resume ${id}`,
     gemini: (id) => `gemini --resume ${id}`,
+    qwen: (id) => `qwen --resume ${id}`,
     opencode: (id) => `opencode --session ${id}`,
 };
 // When no resumable session id can be found, why — and what to do about it.
@@ -47,6 +50,8 @@ const TAKEOVER_EMPTY_HINT_BY_AGENT = {
     codex: "Codex writes its session only after the first message. Send one message in the terminal, then continue as chat.",
     pi: "Pi assigns its session once the conversation starts. Send one message in the terminal, then continue as chat.",
     grok: "Grok writes its session once the conversation starts. Send one message in the terminal, then continue as chat.",
+    gemini: "Gemini records its session after the conversation starts. Send one message in the terminal, then continue as chat.",
+    qwen: "Qwen records its session after the conversation starts. Send one message in the terminal, then continue as chat.",
     opencode: "OpenCode records its session as the TUI starts; if it isn't found yet, give it a moment and try again.",
 };
 /** Synthesize a default session name for a plain `bivy run` from agent + workspace. */
@@ -59,6 +64,8 @@ const ACTIVITY_PING_INTERVAL = 2000;
 const IDLE_NOTIFY_INTERVAL = Number(process.env.BIVY_RUN_IDLE_NOTIFY_MS) || 30_000;
 const BELL_QUIET_INPUT_MS = Number(process.env.BIVY_TERM_BELL_QUIET_MS) || 8_000;
 const BELL_NOTIFY_COOLDOWN_MS = Number(process.env.BIVY_TERM_BELL_COOLDOWN_MS) || 45_000;
+const TAKEOVER_DISCOVERY_ATTEMPTS = 10;
+const TAKEOVER_DISCOVERY_DELAY_MS = 200;
 export function createRunTerminals(deps) {
     const { terminals } = deps;
     // Native agents' on-disk session, located by cwd + terminal start time for
@@ -70,6 +77,8 @@ export function createRunTerminals(deps) {
             return match?.path || match?.id;
         },
         grok: (cwd, since) => discoverGrokSessionForCwd(cwd, since)?.id,
+        gemini: (cwd, since) => discoverGeminiFamilySessionForCwd("gemini", cwd, since)?.id,
+        qwen: (cwd, since) => discoverGeminiFamilySessionForCwd("qwen", cwd, since)?.id,
         opencode: (cwd, since) => discoverOpenCodeSessionForCwd(cwd, since)?.id,
     };
     const runTerminals = new Set();
@@ -329,6 +338,20 @@ export function createRunTerminals(deps) {
             return undefined;
         }
     }
+    async function discoverForTakeover(agent, workspace, createdAt) {
+        const discover = SESSION_DISCOVERY_BY_AGENT[agent];
+        if (!discover)
+            return undefined;
+        for (let attempt = 0; attempt < TAKEOVER_DISCOVERY_ATTEMPTS; attempt++) {
+            const ref = await discover(workspace, createdAt);
+            if (ref)
+                return ref;
+            if (attempt + 1 < TAKEOVER_DISCOVERY_ATTEMPTS) {
+                await new Promise((resolve) => setTimeout(resolve, TAKEOVER_DISCOVERY_DELAY_MS));
+            }
+        }
+        return undefined;
+    }
     async function takeoverRunTerminal(opts) {
         const runs = terminals.list((m) => m.kind === "run").filter((t) => runTerminals.has(t.id));
         const entry = opts.termId
@@ -342,20 +365,25 @@ export function createRunTerminals(deps) {
         const runtimeId = TAKEOVER_RUNTIME_BY_AGENT[agent];
         if (!runtimeId)
             return { ok: false, status: 409, error: `"Continue as chat" isn't supported for "${agent || "this agent"}" yet.` };
-        const discovered = entry.meta.sessionId ? undefined : await SESSION_DISCOVERY_BY_AGENT[agent]?.(entry.workspace, entry.createdAt);
+        // Several CLIs assign/persist their session id asynchronously after the
+        // first turn. Give their store a short bounded window to settle instead of
+        // making an immediate takeover spuriously fail.
+        const discovered = entry.meta.sessionId ? undefined : await discoverForTakeover(agent, entry.workspace, entry.createdAt);
         const pinned = entry.meta.sessionId ?? discovered;
         if (!pinned) {
             const hint = TAKEOVER_EMPTY_HINT_BY_AGENT[agent] ?? `Start it via the shim (or \`bivy run\`), or continue it in a terminal.`;
             return { ok: false, status: 409, error: `Couldn't find a ${agent || "session"} session to continue yet. ${hint}` };
         }
         const workspace = entry.workspace;
-        // 1. Stop the native TUI (the PTY this run-terminal owns is the kill target).
+        // Prepare and validate the governed resume BEFORE stopping the native TUI.
+        // Runtime openSession paths only read/bind durable state; they do not start a
+        // second agent process until the next prompt. If preparation fails, the
+        // terminal remains live and the user loses nothing.
+        const record = await deps.createSession(workspace, pinned, { runtimeId, makeActive: true, source: "takeover" });
         terminals.close(entry.id);
         runTerminals.delete(entry.id);
         runViewers.delete(entry.id);
         deps.broadcast({ type: "terminal.closed", termId: entry.id });
-        // 2. Reopen the session as a chat on its runtime.
-        const record = await deps.createSession(workspace, pinned, { runtimeId, makeActive: true, source: "takeover" });
         const resumeCommand = RESUME_CLI_BY_AGENT[agent]?.(pinned);
         return { ok: true, sessionId: record.id, runtimeId, resumeCommand };
     }

package/package.json

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