@bivy/bivy 0.6.0-staging.82 → 0.6.0-staging.84

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";
@@ -535,7 +535,9 @@ if (sessionRunPolicy) {
     console.log(`[policy] in-session model reroute enabled: ${process.env.BIVY_SESSION_MODEL_FALLBACK}`);
 }
 let lastUpdateCheckAt = 0;
-let updateNoticeSentFor = "";
+// The most recent "this node is behind" finding, so a client that connects after
+// the check already ran still gets the banner (replayed on connect below).
+let pendingBivyUpdate = null;
 function runtimeSummary(rt) {
     return runtimeHost.summary(rt);
 }
@@ -625,11 +627,11 @@ function readJsonFile(file) {
         return undefined;
     }
 }
-async function maybeNotifyBivyUpdate(record) {
-    // The daemon creates an initial session during startup before any UI is
-    // connected. Don't consume the once-per-version notice until someone can see it.
-    if (clients.size === 0 && !relay)
-        return;
+// Poll npm for a newer release (throttled to every 6h). On finding one, remember
+// it and push a dedicated `node.update` event so every connected app can show a
+// banner with a one-tap "Update this node" button (see runBivyUpdate). Safe to
+// call from anywhere — never throws, never interrupts a session.
+async function checkBivyUpdate() {
     const now = Date.now();
     if (now - lastUpdateCheckAt < 6 * 60 * 60 * 1000)
         return;
@@ -641,25 +643,48 @@ async function maybeNotifyBivyUpdate(record) {
         const res = await fetch(updateRegistryUrl, { signal: AbortSignal.timeout(5000) });
         if (!res.ok)
             return;
-        const latestVersion = (await res.json()).version;
-        if (!latestVersion || !isNewerVersion(latestVersion, current))
+        const latest = (await res.json()).version;
+        if (!latest || !isNewerVersion(latest, current))
             return;
-        if (updateNoticeSentFor === latestVersion)
-            return;
-        updateNoticeSentFor = latestVersion;
-        const label = ` ${latestVersion}`;
-        broadcast({
-            type: "session.notice",
-            sessionId: record.id,
-            level: "info",
-            message: `A newer Bivy version${label} is available. Run \`bivy update\` in your terminal to update.`,
-            action: "bivy update",
-        });
+        pendingBivyUpdate = { current, latest };
+        broadcast({ type: "node.update", current, latest });
     }
     catch {
         // Best-effort update checks should never interrupt a session.
     }
 }
+async function maybeNotifyBivyUpdate() {
+    // The daemon creates an initial session during startup before any UI is
+    // connected. Don't spend a check until someone can see the banner.
+    if (clients.size === 0 && !relay)
+        return;
+    await checkBivyUpdate();
+}
+// Run `bivy update` on this node, the same command a user would type. The CLI
+// re-spawns itself detached, waits for any in-flight turn, updates, and restarts
+// the service (logging to update.log), so we just fire-and-forget it here. The
+// bin ships next to this server bundle in both the git checkout (src/server.ts)
+// and the published package (dist/server.js), so repoRoot/bin/bivy.mjs resolves
+// in both. Returns a friendly error instead of throwing when it can't be found
+// (e.g. an unusual layout), so the banner can fall back to the manual command.
+function runBivyUpdate() {
+    const script = path.join(repoRoot, "bin", "bivy.mjs");
+    if (!fs.existsSync(script)) {
+        return { ok: false, error: "Could not locate the bivy CLI on this node — run `bivy update` in a terminal." };
+    }
+    try {
+        const child = spawn(process.execPath, [script, "update"], {
+            detached: true,
+            stdio: "ignore",
+            env: process.env,
+        });
+        child.unref();
+        return { ok: true };
+    }
+    catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    }
+}
 function runtimeInstallSpec(requested) {
     let id = String(requested ?? "").trim().toLowerCase();
     // Normalize a few historical aliases to their canonical runtime id.
@@ -2597,6 +2622,14 @@ const RELAY_COMMANDS = {
     ping(msg, ctx) {
         ctx.reply({ type: "pong", requestId: typeof msg.requestId === "string" ? msg.requestId : undefined });
     },
+    // Kick off `bivy update` on this node from the app's version-mismatch banner
+    // (see runBivyUpdate). The node restarts itself when the update lands, so the
+    // client just sees the socket reconnect on the new build; a failure to even
+    // start reports back so the banner can show the manual command.
+    "node.update"(_msg, ctx) {
+        const result = runBivyUpdate();
+        ctx.reply({ type: "node.update.result", ok: result.ok, error: result.error });
+    },
     // Fetch a stored attachment's bytes by content hash. The relay client (a phone
     // not on the LAN) can't reach the GET /api/attachment endpoint, so it fetches
     // over the encrypted tunnel instead; the relay framing chunks the base64 payload
@@ -3527,6 +3560,7 @@ const RELAY_COMMANDS = {
                 source: rec.source,
                 title: rec.session.getName(),
                 model: rec.session.getCurrentModel()?.name,
+                sandbox: rec.sandbox,
             };
             let dirtyPatch;
             if (rec.worktree) {
@@ -3535,6 +3569,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.
@@ -3615,6 +3657,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.
@@ -5826,6 +5869,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
@@ -5836,8 +5921,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.
@@ -5849,41 +5936,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;
@@ -5897,8 +6007,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;
@@ -5908,8 +6020,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
@@ -5928,6 +6040,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();
@@ -7640,7 +7756,7 @@ async function createSession(workspace = defaultWorkspace, sessionFile, opts = {
         if (makeActive)
             active = existing;
         broadcast({ type: "session.created", sessionId: existing.id, name: existing.session.getName(), workspace: existing.workspace, sessionFile: existing.sessionFile, source: existing.source, branch: existing.worktree?.branch, prUrl: existing.prUrl, runtimeId: existing.runtimeId, agentName: getRuntime(existing.runtimeId).displayName, bivySession: bivySessionEnvelope(existing), capabilities: capabilitiesWithCommands(existing.runtimeId, existing.session) });
-        void maybeNotifyBivyUpdate(existing);
+        void maybeNotifyBivyUpdate();
         return existing;
     }
     // Pick the agent for this session (fixed for its life). Resuming a tagged
@@ -7829,7 +7945,7 @@ async function createSession(workspace = defaultWorkspace, sessionFile, opts = {
     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) });
-    void maybeNotifyBivyUpdate(record);
+    void maybeNotifyBivyUpdate();
     scheduleAdvertise();
     return record;
 }
@@ -8544,6 +8660,16 @@ app.get("/api/node/info", (_req, res) => {
         sandbox: sandboxInfo(),
     });
 });
+// One-tap "Update this node" from the app's version-mismatch banner, for
+// direct/LAN clients (the relay path uses the RELAY_COMMANDS "node.update"
+// handler). Both call the same runBivyUpdate.
+app.post("/api/node/update", (_req, res) => {
+    const result = runBivyUpdate();
+    if (result.ok)
+        res.json({ ok: true });
+    else
+        res.status(500).json({ ok: false, error: result.error });
+});
 // Build collectNodeStats() options, resolving the optional session so the panel
 // can attribute a session-scoped tier (its live agent process + workspace size).
 function nodeStatsOptsFor(sessionId) {
@@ -10444,6 +10570,14 @@ wss.on("connection", (socket, req) => {
     // sharing a PTY size it to their min (see TerminalManager.setClientSize).
     const clientTerminalId = `sock-${randomUUID()}`;
     socket.send(JSON.stringify({ type: "hello", activeSessionId: active?.id, activeSession: active ? { id: active.id, isStreaming: sessionBusy(active), lastActivity: active.lastActivity, workingStartedAt: active.workingStartedAt } : null }));
+    // Authoritative version status on every connect: `latest` set means this node
+    // is behind (banner shows); absent means up to date (banner + any "Updating…"
+    // state clear — this is how the banner disappears after an update lands and
+    // the socket reconnects on the new build). Then (re)run the throttled check so
+    // a freshly-opened app surfaces a newly-available update without waiting for a
+    // session turn.
+    socket.send(JSON.stringify({ type: "node.update", current: currentVersion() ?? "", latest: pendingBivyUpdate?.latest }));
+    void checkBivyUpdate();
     socket.on("message", (raw) => {
         let msg;
         try {

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.82",
+  "version": "0.6.0-staging.84",
   "type": "module",
   "license": "FSL-1.1-ALv2",
   "description": "Run coding agents on machines you own. Source-available, self-hostable agent workspace.",