@bivy/bivy 0.6.0-staging.83 → 0.6.0-staging.85

package/dist/repo-workspace.js

@@ -164,6 +164,25 @@ export async function resolveBranchBaseRef(repoDir, branch) {
         throw new Error(`Branch "${branch}" was not found on the remote.`);
     }
 }
+/**
+ * Base ref for ADOPTING a source branch onto a fresh clone on another node (a
+ * cross-node fork). Prefers the pushed `origin/<branch>` so the source's
+ * committed work travels; falls back to the repo's default branch when the
+ * source branch was never pushed (best-effort — any uncommitted work still
+ * arrives via the fork's dirty patch). Fetches first so `origin/<branch>` is
+ * current. Contrast with `resolveBranchBaseRef`, which is user-facing and throws
+ * on a missing branch; a fork must degrade rather than fail.
+ */
+export async function resolveAdoptBaseRef(repoDir, branch) {
+    await fetchOrigin(repoDir);
+    try {
+        await exec("git", ["-C", repoDir, "rev-parse", "--verify", "--quiet", `origin/${branch}`], { cwd: repoDir });
+        return `origin/${branch}`;
+    }
+    catch {
+        return resolveDefaultBaseRef(repoDir);
+    }
+}
 /**
  * Whether an existing Bivy-owned checkout at `dest` can be reused as-is, i.e. it
  * has a `.git` entry AND `git rev-parse` accepts it as a real repository. A

package/dist/server.js

@@ -60,7 +60,7 @@ import { checkDiskAdmission } from "./harness/disk-admission.js";
 import { sandboxTier, setConfiguredSandboxTier, normalizeSandboxTier } from "./harness/sandbox.js";
 import { setConfiguredAutoAttachToolImages } from "./harness/tool-image-attachments.js";
 import { injectMcpProxyForSession, injectBivyToolsForSession } from "./harness/mcp-inject.js";
-import { parseRepo, inferGitHubRepoFromWorkspace, isSharedCloneRoot, resolveGitHubToken, cloneOrUpdateRepo, resolveDefaultBaseRef, resolveBranchBaseRef, fetchOrigin } from "./repo-workspace.js";
+import { parseRepo, inferGitHubRepoFromWorkspace, isSharedCloneRoot, resolveGitHubToken, cloneOrUpdateRepo, resolveDefaultBaseRef, resolveBranchBaseRef, resolveAdoptBaseRef, fetchOrigin } from "./repo-workspace.js";
 import { configureGitAuth, writeGitCredentialEndpoint } from "./git-auth.js";
 import { GitHubTaskPoller, resolveGitHubTaskConfig, buildTaskPrompt, buildResumePrompt, buildInteractiveResumePrompt, DEFAULT_ISSUE_INSTRUCTIONS, parseBivyDirectives, commitAll, pushBranch, mergeBaseIntoBranch, completeMerge, abortMerge, findOpenPullRequestForBranch, findPullRequestsForBranch, findMergedPullRequestForBranch, issueBranchName, getPullRequest, commentIssue, listOpenLabelledIssues, selectActionableIssues, getIssue, getIssueCommentBody, addLabel, removeLabel, announcePickup, } from "./github-tasks.js";
 import { buildLinearTaskPrompt, getLinearIssue, linearBranchName } from "./linear-tasks.js";
@@ -3084,6 +3084,7 @@ const RELAY_COMMANDS = {
     },
     async "models.list"(msg) {
         const requestedSessionId = typeof msg.sessionId === "string" && msg.sessionId ? msg.sessionId : undefined;
+        const wantedRuntimeId = typeof msg.runtimeId === "string" && msg.runtimeId ? msg.runtimeId : undefined;
         let record;
         try {
             record = requestedSessionId ? await resolveOrResumeSession(requestedSessionId, msg.path) : active;
@@ -3096,7 +3097,12 @@ const RELAY_COMMANDS = {
             relay?.sendEvent({ type: "session.error", sessionId: requestedSessionId, error: "Session not found" });
             return;
         }
-        record ??= await sessionForModelQuery();
+        // On a draft (no session id), a runtime hint from the composer takes
+        // precedence so an agent switch previews *that* agent's models even if a
+        // stale `active` on another runtime lingers on the node.
+        if (!requestedSessionId && wantedRuntimeId && record?.runtimeId !== wantedRuntimeId)
+            record = null;
+        record ??= await sessionForModelQuery(wantedRuntimeId);
         const session = record.session;
         const current = session.getCurrentModel();
         const models = await publicModelsList(session, current);
@@ -3108,6 +3114,17 @@ const RELAY_COMMANDS = {
         // (e.g. Claude) — the "Claude shows Codex models" bug.
         relay?.sendEvent({ type: "models.list", sessionId: record.id, runtimeId: record.runtimeId, current: current ? publicModel(current, current) : null, models, thinking });
     },
+    "models.prefetch"(msg) {
+        // The composer's agent picker opened: warm the scratch session for each
+        // offered agent in the background so the first switch to any of them answers
+        // instantly. Fire-and-forget — no reply; the follow-up models.list carries
+        // the result. Ignore anything but a bounded string[] of runtime ids.
+        const ids = Array.isArray(msg.runtimeIds)
+            ? msg.runtimeIds.filter((id) => typeof id === "string" && !!id).slice(0, 16)
+            : [];
+        if (ids.length)
+            prefetchModels(ids);
+    },
     async "model.select"(msg) {
         const requestedSessionId = typeof msg.sessionId === "string" && msg.sessionId ? msg.sessionId : undefined;
         let record;
@@ -3560,6 +3577,7 @@ const RELAY_COMMANDS = {
                 source: rec.source,
                 title: rec.session.getName(),
                 model: rec.session.getCurrentModel()?.name,
+                sandbox: rec.sandbox,
             };
             let dirtyPatch;
             if (rec.worktree) {
@@ -3568,6 +3586,14 @@ const RELAY_COMMANDS = {
                 }
                 catch { /* best effort — omit dirty state */ }
             }
+            // Publish the source branch so a cross-node fork's COMMITTED work travels
+            // via origin (the destination adopts `origin/<branch>`; see
+            // resolveAdoptBaseRef). Uncommitted work rides the dirtyPatch above. Only
+            // for a genuine cross-node fork — a same-node cross-agent fork adopts the
+            // LOCAL branch and needs no push. Best-effort: a no-token/offline node just
+            // falls back to the default base downstream.
+            if (msg.crossNode === true)
+                await pushForkSourceBranch(rec);
             // Refresh the account model-auth vault so the destination node can pull
             // this session's model credentials during import (fork credential-move,
             // docs/session-fork-plan.md). Best-effort: local-only nodes just skip it.
@@ -3648,6 +3674,7 @@ const RELAY_COMMANDS = {
                 source: rec.source,
                 title: rec.session.getName(),
                 model: rec.session.getCurrentModel()?.name,
+                sandbox: rec.sandbox,
             };
             // Carry uncommitted work: capture from the SOURCE worktree; standUpFork
             // re-applies it into the fork's fresh worktree. Local git ops only.
@@ -5859,6 +5886,48 @@ async function applyRequestedModel(record, model) {
         broadcast({ type: "session.error", sessionId: record.id, error: error instanceof Error ? error.message : "Selected model is not available on this node." });
     }
 }
+// Serialize clone + worktree work per repo directory. Two forks (or a fork and
+// a GitHub pickup) hitting the same shared clone concurrently race on
+// `git worktree add`/`remove` and the `.bivy/worktrees` dir — the loser used to
+// see "already exists"/"already checked out" or, worse, `createWorktree`'s
+// adopt-path `rmSync` clearing a sibling's tree. A lightweight per-key async
+// mutex removes the race without a filesystem lock.
+const repoWorktreeLocks = new Map();
+async function withRepoLock(key, fn) {
+    const prev = repoWorktreeLocks.get(key) ?? Promise.resolve();
+    // Chain the map's tail on the PREVIOUS holder settling (never rejecting), so a
+    // failing fork doesn't poison the next waiter's gate. Each caller still awaits
+    // its own `run` and gets its own result/exception. Bounded by repo count.
+    const gate = prev.then(() => { }, () => { });
+    const run = gate.then(fn);
+    repoWorktreeLocks.set(key, run.then(() => { }, () => { }));
+    return run;
+}
+/**
+ * Best-effort push of a fork SOURCE's branch to origin before the bundle leaves
+ * the node, so a cross-node fork's committed work travels via origin (the
+ * destination bases its adopted worktree on `origin/<branch>` — see
+ * `resolveAdoptBaseRef`). Guarded by a token + repo backing; a failure just
+ * means the destination falls back to the default base and the dirty patch.
+ */
+async function pushForkSourceBranch(rec) {
+    const parts = repoSessionParts(rec);
+    if (!parts)
+        return;
+    const { wt, parsed } = parts;
+    try {
+        const token = await resolveTokenForRepo(parsed.owner, parsed.repo);
+        if (!token)
+            return;
+        const cfg = { token, owner: parsed.owner, repo: parsed.repo, repoDir: wt.repoRoot, label: "bivy", claimLabel: "bivy:in-progress", pollMs: 60_000 };
+        await pushBranch(cfg, wt.path, wt.branch);
+        rec.branchPushed = true;
+    }
+    catch {
+        // offline / no rights / protected branch — committed work may not reach a
+        // cross-node destination, but the fork still proceeds from the best base.
+    }
+}
 /**
  * Stand a forked session up on THIS node from a `ForkBundle`: credential-move,
  * (optional) prerequisite detection, repo/worktree reconstruction, transcript
@@ -5869,8 +5938,10 @@ async function applyRequestedModel(record, model) {
  */
 async function standUpFork(opts) {
     const { bundle, targetRuntimeId } = opts;
-    const targetRuntime = getRuntime(targetRuntimeId);
     const fallback = opts.fallback ?? { workspace: defaultWorkspace, cwd: defaultWorkspace };
+    // Carry the source's sandbox tier so a sandboxed session forks into a
+    // sandboxed one, rather than defaulting to this node's tier (fork.ts).
+    const forkSandbox = normalizeSandboxTier(bundle.record.sandbox);
     // Credential-move: if the chosen model's provider isn't logged in on this node,
     // pull the account model-auth vault (a login done on another node carries over),
     // then re-check. Best-effort — a local-only node just skips it.
@@ -5882,41 +5953,64 @@ async function standUpFork(opts) {
         modelConfigured = await providerConfigured();
     }
     // Prerequisite detection. A missing AGENT is a hard blocker — stop before any
-    // clone/worktree work. Skipped for a same-node local fork.
+    // clone/worktree work. Skipped for a same-node local fork. Read the agent's
+    // availability + display name from the runtime REGISTRY (which never throws)
+    // rather than resolving the runtime up front: `getRuntime` throws for a
+    // known-but-not-installed agent, which — called eagerly — surfaced a raw
+    // "not available" string with an empty `missing[]` instead of this friendly
+    // install checklist. An unknown id (no registry entry) is treated as
+    // unavailable so it, too, degrades to the checklist rather than a getRuntime throw.
     const agentInfo = listRuntimes().find((r) => r.id === targetRuntimeId);
-    const agentAvailable = agentInfo ? agentInfo.status === "available" : true;
+    const agentAvailable = agentInfo ? agentInfo.status === "available" : false;
+    const agentDisplayName = agentInfo?.displayName ?? targetRuntimeId;
     const prereqInput = {
-        agent: { id: targetRuntimeId, displayName: targetRuntime.displayName, available: agentAvailable },
+        agent: { id: targetRuntimeId, displayName: agentDisplayName, available: agentAvailable },
         ...(modelProvider ? { model: { provider: modelProvider, configured: Boolean(modelConfigured) } } : {}),
     };
     if (opts.detectPrereqs) {
         const early = evaluateForkPrereqs(prereqInput);
         if (blockingForkPrereqs(early).length > 0) {
-            return { ok: false, error: `${targetRuntime.displayName} is not installed on the destination node.`, missing: missingForkPrereqs(early) };
+            return { ok: false, error: `${agentDisplayName} is not installed on the destination node.`, missing: missingForkPrereqs(early) };
         }
     }
+    // Safe now: the agent is available (or this is a same-node local fork whose
+    // agent is self-evidently present). The per-session sandbox tier bakes into
+    // the runtime's launch flags.
+    const targetRuntime = getRuntime(targetRuntimeId, forkSandbox);
     // Reconstruct repo + worktree when the source was repo-backed.
     let workspace = fallback.workspace;
     let cwd = fallback.cwd;
     let repoReachable;
     let worktree;
+    let dirtyWarning;
     const parsed = bundle.record.repoSlug ? parseRepo(bundle.record.repoSlug) : undefined;
     if (parsed) {
         const token = await resolveTokenForRepo(parsed.owner, parsed.repo);
         repoReachable = Boolean(token);
         const repoDir = await cloneOrUpdateRepo({ owner: parsed.owner, repo: parsed.repo, token, root: reposRoot });
         const srcBranch = bundle.record.branch;
-        let wt;
-        if (opts.worktree === "fresh") {
-            // Cut a new branch from the source branch (or the repo's default base).
-            const forkBranch = `${srcBranch ?? "fork"}-fork-${randomBytes(4).toString("hex")}`;
-            wt = await createWorktree({ repoDir, id: forkBranch, branch: forkBranch, base: srcBranch ?? await resolveDefaultBaseRef(repoDir) });
-        }
-        else {
-            // Adopt the source branch, or a fresh random worktree when it had none.
-            wt = await createWorktree({ repoDir, id: srcBranch ?? `fork-${randomBytes(6).toString("hex")}`, branch: srcBranch, base: srcBranch ? undefined : await resolveDefaultBaseRef(repoDir) });
-        }
-        applyDirtyPatch(wt.path, bundle.dirtyPatch);
+        // Serialize clone-adjacent worktree ops on this repo so concurrent forks /
+        // pickups don't race on `git worktree add` or clobber each other's trees.
+        const wt = await withRepoLock(repoDir, async () => {
+            if (opts.worktree === "fresh") {
+                // Same-node fork: cut a NEW branch from the source's LOCAL branch (which
+                // holds its latest, possibly-unpushed commits) or the repo default.
+                const forkBranch = `${srcBranch ?? "fork"}-fork-${randomBytes(4).toString("hex")}`;
+                return createWorktree({ repoDir, id: forkBranch, branch: forkBranch, base: srcBranch ?? await resolveDefaultBaseRef(repoDir) });
+            }
+            // Cross-node adopt: the source branch has no LOCAL ref here. Base the
+            // adopted branch on the pushed `origin/<branch>` so committed work travels
+            // (was: undefined → the destination's DEFAULT branch, silently dropping
+            // every commit). Give the worktree DIR a unique suffix so a same-branch
+            // adopt never reuses — or, via createWorktree's stale-dir cleanup, deletes
+            // — another live session's tree.
+            const dirId = `${srcBranch ?? "fork"}-${randomBytes(4).toString("hex")}`;
+            const base = srcBranch ? await resolveAdoptBaseRef(repoDir, srcBranch) : await resolveDefaultBaseRef(repoDir);
+            return createWorktree({ repoDir, id: dirId, branch: srcBranch, base });
+        });
+        const applied = applyDirtyPatch(wt.path, bundle.dirtyPatch);
+        if (applied.warning)
+            dirtyWarning = applied.warning;
         workspace = repoDir;
         cwd = wt.path;
         worktree = wt;
@@ -5930,8 +6024,10 @@ async function standUpFork(opts) {
         const forkRepoRoot = await gitRepoRoot(cwd);
         if (forkRepoRoot) {
             const forkBranch = `bivy/fork-${randomBytes(6).toString("hex")}`;
-            const wt = await createWorktree({ repoDir: forkRepoRoot, id: forkBranch, branch: forkBranch });
-            applyDirtyPatch(wt.path, bundle.dirtyPatch);
+            const wt = await withRepoLock(forkRepoRoot, () => createWorktree({ repoDir: forkRepoRoot, id: forkBranch, branch: forkBranch }));
+            const applied = applyDirtyPatch(wt.path, bundle.dirtyPatch);
+            if (applied.warning)
+                dirtyWarning = applied.warning;
             workspace = forkRepoRoot;
             cwd = wt.path;
             worktree = wt;
@@ -5941,8 +6037,8 @@ async function standUpFork(opts) {
     // transcript (full) or a fresh session the caller seeds with plan.seedPrompt.
     const plan = await materializeFork({ bundle, targetRuntime, ctx: { workspace, cwd }, seed: { transcriptUrl: opts.transcriptUrl } });
     const record = plan.kind === "resume"
-        ? await createSession(cwd, plan.sessionFile, { runtimeId: targetRuntimeId, source: bundle.record.source, makeActive: false })
-        : await createSession(cwd, undefined, { runtimeId: targetRuntimeId, source: bundle.record.source, makeActive: false });
+        ? await createSession(cwd, plan.sessionFile, { runtimeId: targetRuntimeId, source: bundle.record.source, sandbox: forkSandbox, makeActive: false })
+        : await createSession(cwd, undefined, { runtimeId: targetRuntimeId, source: bundle.record.source, sandbox: forkSandbox, makeActive: false });
     // Mark the new session as a fork of its source, so the run card can show
     // "Forked from …" and the lineage survives a reload (persisted below). Just
     // the parent's session id — an identifier, not content, so it's safe to
@@ -5961,6 +6057,10 @@ async function standUpFork(opts) {
     }
     if (bundle.record.title && !record.session.getName())
         record.session.setName(bundle.record.title);
+    // Surface a non-fatal note when the source's uncommitted changes didn't apply
+    // cleanly, so the fork isn't silently missing work-in-progress.
+    if (dirtyWarning)
+        broadcast({ type: "session.notice", sessionId: record.id, message: dirtyWarning });
     await applyRequestedModel(record, opts.model ?? nodeDefaultModel() ?? undefined);
     persistSessionMetadata(record);
     scheduleAdvertise();
@@ -7972,32 +8072,75 @@ async function resolveOrResumeSession(sessionId, sessionPath) {
 // races the runtime.select that switches the default agent, pin the pill to the
 // *previous* runtime (the reported agent-switching bug). Mirror how session.new/
 // session.open already refuse to touch `active` for remote clients: reuse a
-// single non-active scratch session on the current default runtime instead of
-// spawning a fresh runtime process on every picker read.
-let modelQueryScratch;
-let modelQueryScratchPending;
-async function sessionForModelQuery() {
-    if (active)
+// non-active scratch session per runtime instead of spawning a fresh runtime
+// process on every picker read.
+//
+// Keyed by runtime id, not a single slot: switching agents (Claude → Codex →
+// Claude) used to evict and re-spawn the one scratch on every switch — the
+// "switching agent takes a long time before models appear" bug. A map keeps one
+// warm scratch per runtime so a switch back to an agent already viewed this
+// session answers from the live session with no re-spawn, and `prefetchModels`
+// can warm several ahead of the first pick.
+const modelQueryScratch = new Map();
+const modelQueryScratchPending = new Map();
+async function sessionForModelQuery(runtimeId) {
+    const wanted = resolveRuntimeId(runtimeId);
+    // A live active session answers for itself — but only when it IS the runtime
+    // being queried, so a prefetch/draft read for a *different* agent doesn't get
+    // the active session's (wrong-runtime) model list.
+    if (active && active.runtimeId === wanted)
         return active;
-    const wanted = resolveRuntimeId();
-    if (modelQueryScratch &&
-        openSessions.has(modelQueryScratch.id) &&
-        modelQueryScratch.runtimeId === wanted &&
-        !sessionBusy(modelQueryScratch)) {
-        touchSession(modelQueryScratch);
-        return modelQueryScratch;
-    }
-    // De-dupe concurrent picker reads. Without this, a WS models.list and an HTTP
-    // GET /api/models fired together on page load both miss the reuse guard above
-    // (the scratch assignment only lands after createSession resolves ~0.3s later)
-    // and each stand up a session, leaving two empty rows a fraction of a second
-    // apart. Collapse concurrent builds onto one promise, mirroring resumingSessions.
-    if (modelQueryScratchPending)
-        return modelQueryScratchPending;
-    modelQueryScratchPending = createSession(defaultWorkspace, undefined, { makeActive: false, ephemeral: true })
-        .then((rec) => { modelQueryScratch = rec; return rec; })
-        .finally(() => { modelQueryScratchPending = undefined; });
-    return modelQueryScratchPending;
+    const cached = modelQueryScratch.get(wanted);
+    if (cached && openSessions.has(cached.id) && cached.runtimeId === wanted && !sessionBusy(cached)) {
+        touchSession(cached);
+        return cached;
+    }
+    // De-dupe concurrent picker reads per runtime. Without this, a WS models.list
+    // and an HTTP GET /api/models fired together on page load both miss the reuse
+    // guard above (the scratch assignment only lands after createSession resolves
+    // ~0.3s later) and each stand up a session, leaving two empty rows a fraction
+    // of a second apart. Collapse concurrent builds onto one promise per runtime,
+    // mirroring resumingSessions.
+    const inflight = modelQueryScratchPending.get(wanted);
+    if (inflight)
+        return inflight;
+    const build = createSession(defaultWorkspace, undefined, { makeActive: false, ephemeral: true, runtimeId: wanted })
+        .then((rec) => { modelQueryScratch.set(wanted, rec); return rec; })
+        .finally(() => { modelQueryScratchPending.delete(wanted); });
+    modelQueryScratchPending.set(wanted, build);
+    return build;
+}
+/**
+ * Warm the model-query scratch for one or more runtimes in the background so the
+ * first agent switch to any of them answers instantly instead of paying the
+ * runtime spin-up on the critical path. Fired when the agent picker opens (see
+ * the `models.prefetch` command). Best-effort and de-duped: a runtime already
+ * warm (or being warmed) is a no-op, and a spin-up failure is swallowed — the
+ * normal models.list path will surface any real error when the user picks it.
+ */
+function prefetchModels(runtimeIds) {
+    const wanted = [];
+    for (const id of runtimeIds) {
+        let resolved;
+        try {
+            resolved = resolveRuntimeId(id);
+        }
+        catch {
+            continue; // unknown/uninstalled agent — nothing to warm
+        }
+        if (wanted.includes(resolved))
+            continue;
+        const cached = modelQueryScratch.get(resolved);
+        if (cached && openSessions.has(cached.id) && !sessionBusy(cached))
+            continue;
+        if (modelQueryScratchPending.has(resolved))
+            continue;
+        wanted.push(resolved);
+    }
+    // Warm serially, not in a burst: spinning up every agent subprocess at once
+    // would spike a small node's memory/CPU right as the user is interacting. Each
+    // build is cached (and de-duped) so this cost is paid at most once per runtime.
+    void wanted.reduce((chain, id) => chain.then(() => sessionForModelQuery(id).then(() => undefined, () => undefined)), Promise.resolve());
 }
 async function createRepoSession(parsed, opts = {}) {
     const token = await resolveTokenForRepo(parsed.owner, parsed.repo);
@@ -8888,10 +9031,13 @@ app.get("/api/models", async (req, res, next) => {
     try {
         const requestedSessionId = typeof req.query.sessionId === "string" && req.query.sessionId ? req.query.sessionId : undefined;
         const requestedPath = typeof req.query.path === "string" ? req.query.path : undefined;
+        const wantedRuntimeId = typeof req.query.runtimeId === "string" && req.query.runtimeId ? req.query.runtimeId : undefined;
         let record = requestedSessionId ? await resolveOrResumeSession(requestedSessionId, requestedPath) : active;
         if (requestedSessionId && !record)
             return res.status(404).json({ error: "Session not found" });
-        record ??= await sessionForModelQuery();
+        if (!requestedSessionId && wantedRuntimeId && record?.runtimeId !== wantedRuntimeId)
+            record = undefined;
+        record ??= await sessionForModelQuery(wantedRuntimeId);
         const session = record.session;
         const current = session.getCurrentModel();
         const models = await publicModelsList(session, current);
@@ -8902,6 +9048,17 @@ app.get("/api/models", async (req, res, next) => {
         next(error);
     }
 });
+// Warm the per-runtime model-query scratch ahead of the first agent switch (see
+// prefetchModels). Fire-and-forget: returns immediately while the runtimes spin
+// up in the background, so the picker never blocks on it.
+app.post("/api/models/prefetch", (req, res) => {
+    const ids = Array.isArray(req.body?.runtimeIds)
+        ? req.body.runtimeIds.filter((id) => typeof id === "string" && !!id).slice(0, 16)
+        : [];
+    if (ids.length)
+        prefetchModels(ids);
+    res.json({ ok: true });
+});
 app.post("/api/models/select", async (req, res, next) => {
     try {
         const requestedSessionId = typeof req.body?.sessionId === "string" && req.body.sessionId ? req.body.sessionId : undefined;

package/dist/session/fork-dirty.js

@@ -1,4 +1,4 @@
-import { execFileSync } from "node:child_process";
+import { execFileSync, spawnSync } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -53,14 +53,52 @@ export function captureDirtyPatch(repoDir, opts = {}) {
  * source pushed the branch instead (`pushedInstead`) or the working tree was
  * clean (empty patch). Uses `git apply` so both tracked hunks and untracked
  * new-file hunks (produced via `--no-index`) land correctly.
+ *
+ * NEVER throws: a fork's uncommitted changes are best-effort, and the source's
+ * base commit frequently differs from what the destination cloned (a diverged
+ * default branch, an unpushed source branch), so a strict `git apply` fails on
+ * hunk-context mismatch and previously took the whole fork down with it. Instead
+ * we fall back to `git apply --3way` (which reconstructs the hunks from the blob
+ * SHAs the patch carries and merges what it can) and, when even that fails,
+ * surface a warning and leave the tree as the clone left it — the fork still
+ * succeeds, minus the un-appliable working-tree edits.
  */
 export function applyDirtyPatch(repoDir, dirty) {
     if (!dirty || dirty.pushedInstead || !dirty.patch.trim())
-        return;
+        return { applied: false };
     const tmp = path.join(os.tmpdir(), `bivy-fork-${Date.now()}-${Math.random().toString(36).slice(2)}.patch`);
     fs.writeFileSync(tmp, dirty.patch);
     try {
-        execFileSync("git", ["-C", repoDir, "apply", "--whitespace=nowarn", tmp], { stdio: "pipe" });
+        try {
+            execFileSync("git", ["-C", repoDir, "apply", "--whitespace=nowarn", tmp], { stdio: "pipe" });
+            return { applied: true };
+        }
+        catch {
+            // Clean apply failed — the destination's base drifted from the source's.
+            // Retry with a 3-way merge, which reconstructs the pre-image from the blob
+            // SHAs the patch carries (present because the destination cloned the same
+            // repo) and merges what it can. `git apply --3way` exits non-zero BOTH for
+            // an un-appliable patch (nothing lands) AND for a conflicting one (it lands
+            // the non-conflicting hunks and writes conflict markers) — so read the exit
+            // status/stderr with spawnSync rather than treating every non-zero as a
+            // total failure that drops all the WIP.
+            const res = spawnSync("git", ["-C", repoDir, "apply", "--3way", "--whitespace=nowarn", tmp], { encoding: "utf8" });
+            if (res.status === 0)
+                return { applied: true }; // merged cleanly onto the diverged base
+            const stderr = (res.stderr || "").toString();
+            if (/with conflicts/i.test(stderr)) {
+                return {
+                    applied: true,
+                    conflicted: true,
+                    warning: "Some uncommitted changes from the source didn't apply cleanly and were merged with conflict markers — review and resolve them in the fork.",
+                };
+            }
+            const detail = stderr.split("\n").find((l) => l.trim()) || "patch did not apply";
+            return {
+                applied: false,
+                warning: `Couldn't re-apply the source's uncommitted changes (${detail}); they were left behind. Re-make them in the fork if you still need them.`,
+            };
+        }
     }
     finally {
         try {

package/package.json

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