@bivy/bivy 0.16.2 → 0.16.3-staging.2

package/dist/controllers/fork-commands.js

@@ -8,7 +8,7 @@
 // server injects its own session lookup, runtime access, event emit, and the fork
 // helpers as composition deps, so this stays free of daemon state and unit-testable.
 import { buildForkBundle } from "../session/fork.js";
-import { captureDirtyPatch } from "../session/fork-dirty.js";
+import { captureDirtyPatch, captureWorkspaceDirtyPatch } from "../session/fork-dirty.js";
 export function createForkCommands(deps) {
     return {
         async "session.fork.retire-source"(msg) {
@@ -45,13 +45,12 @@ export function createForkCommands(deps) {
             }
             try {
                 const forkRecord = deps.forkRecordFor(rec);
-                let dirtyPatch;
-                if (rec.worktree) {
-                    try {
-                        dirtyPatch = captureDirtyPatch(rec.worktree.path);
-                    }
-                    catch { /* best effort — omit dirty state */ }
-                }
+                // A git workspace must be captured successfully, including sessions that
+                // were started in an unmanaged checkout rather than a Bivy worktree.
+                // Treating a git/read failure as "clean" could retire the only WIP copy.
+                const dirtyPatch = rec.worktree
+                    ? captureDirtyPatch(rec.worktree.path)
+                    : captureWorkspaceDirtyPatch(rec.session.cwd || rec.workspace);
                 // 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
@@ -135,13 +134,11 @@ export function createForkCommands(deps) {
                 const forkRecord = deps.forkRecordFor(rec);
                 // Carry uncommitted work: capture from the SOURCE worktree; standUpFork
                 // re-applies it into the fork's fresh worktree. Local git ops only.
-                let dirtyPatch;
-                if (rec.worktree) {
-                    try {
-                        dirtyPatch = captureDirtyPatch(rec.worktree.path);
-                    }
-                    catch { /* best effort */ }
-                }
+                // Include unmanaged git workspaces too. standUpFork will cut an isolated
+                // worktree for them, so their uncommitted state must ride with it.
+                const dirtyPatch = rec.worktree
+                    ? captureDirtyPatch(rec.worktree.path)
+                    : captureWorkspaceDirtyPatch(rec.session.cwd || rec.workspace);
                 // Same runtime → the bundle carries the native payload → full fidelity.
                 const bundle = buildForkBundle({ runtime, sessionFile: rec.sessionFile, record: forkRecord, dirtyPatch, targetRuntimeId: rec.runtimeId, liveMessages: rec.session.getMessages(), state: deps.forkInFlightState(rec) });
                 // Cut a fresh fork branch (the source still holds its own); skip prereq

package/dist/session/fork-dirty.js

@@ -8,12 +8,21 @@ import path from "node:path";
  * checks it out); this carries the in-flight
  * edits on top so a fork never silently drops work-in-progress.
  *
- * The patch is size-capped. When the working tree is larger
- * than the cap (big or binary churn), we DON'T inline it — `capture` returns
- * `pushedInstead: true` and the caller commits & pushes the branch so the
- * destination reproduces from the pushed commit instead.
+ * The patch is size-capped. When the working tree is larger than the cap, the
+ * capture carries an explicit oversized marker. Fork stand-up rejects that
+ * bundle: pushing a branch cannot carry uncommitted files, and silently treating
+ * the marker as success would lose work-in-progress.
  */
 const DEFAULT_MAX_BYTES = 5 * 1024 * 1024; // 5 MiB of patch text
+/** Find the containing git checkout without throwing for ordinary non-git
+ * workspaces. A discovered checkout is captured fail-closed by the caller. */
+export function captureWorkspaceDirtyPatch(cwd, opts = {}) {
+    const probe = spawnSync("git", ["-C", cwd, "rev-parse", "--show-toplevel"], { encoding: "utf8", timeout: 10_000 });
+    if (probe.status !== 0)
+        return undefined;
+    const root = String(probe.stdout || "").trim();
+    return root ? captureDirtyPatch(root, opts) : undefined;
+}
 function git(repoDir, args) {
     try {
         return execFileSync("git", ["-C", repoDir, ...args], { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
@@ -43,15 +52,17 @@ export function captureDirtyPatch(repoDir, opts = {}) {
     // Each untracked file becomes a "new file" patch via --no-index against /dev/null.
     const untrackedPatches = untracked.map((rel) => git(repoDir, ["diff", "--no-index", "--binary", "--", "/dev/null", rel]));
     const patch = [tracked, ...untrackedPatches].filter(Boolean).join("");
-    if (Buffer.byteLength(patch, "utf8") > maxBytes) {
-        return { patch: "", untracked: [], pushedInstead: true };
+    const byteLength = Buffer.byteLength(patch, "utf8");
+    if (byteLength > maxBytes) {
+        return { patch: "", untracked, pushedInstead: true, byteLength, maxBytes };
     }
     return { patch, untracked };
 }
 /**
- * Re-apply a captured patch onto a fresh checkout at `repoDir`. A no-op when the
- * source pushed the branch instead (`pushedInstead`) or the working tree was
- * clean (empty patch). Uses `git apply` so both tracked hunks and untracked
+ * Re-apply a captured patch onto a fresh checkout at `repoDir`. An oversized
+ * marker produces a warning as a final defence; normal fork stand-up rejects it
+ * before reaching this function. A clean patch is a no-op. 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
@@ -64,7 +75,13 @@ export function captureDirtyPatch(repoDir, opts = {}) {
  * succeeds, minus the un-appliable working-tree edits.
  */
 export function applyDirtyPatch(repoDir, dirty) {
-    if (!dirty || dirty.pushedInstead || !dirty.patch.trim())
+    if (dirty?.pushedInstead) {
+        return {
+            applied: false,
+            warning: "The source working tree exceeded the fork transfer limit, so its uncommitted changes were not applied. The fork was stopped to prevent data loss.",
+        };
+    }
+    if (!dirty || !dirty.patch.trim())
         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);

package/dist/session/fork-standup.js

@@ -43,6 +43,20 @@ export function createForkStandUp(deps) {
     async function standUpFork(opts) {
         const { bundle, targetRuntimeId } = opts;
         const fallback = opts.fallback ?? { workspace: deps.defaultWorkspace, cwd: deps.defaultWorkspace };
+        // An oversized dirty marker means no WIP bytes are present in the bundle.
+        // Never continue and pretend the pushed branch preserved them: git push only
+        // transports commits. The source remains untouched, so the user can commit,
+        // reduce the change set, or raise the configured transfer limit and retry.
+        if (bundle.dirtyPatch?.pushedInstead) {
+            const size = bundle.dirtyPatch.byteLength;
+            const limit = bundle.dirtyPatch.maxBytes;
+            const detail = size && limit ? ` (${Math.ceil(size / 1024)} KiB; limit ${Math.ceil(limit / 1024)} KiB)` : "";
+            return {
+                ok: false,
+                error: `The source has too many uncommitted changes to transfer safely${detail}. Commit them or reduce the working-tree changes, then retry; the source was not modified.`,
+                missing: [],
+            };
+        }
         // 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);
@@ -131,6 +145,13 @@ export function createForkStandUp(deps) {
                 return deps.createWorktree({ repoDir, id: dirId, branch: srcBranch, base });
             });
             const applied = deps.applyDirtyPatch(wt.path, bundle.dirtyPatch);
+            if (bundle.dirtyPatch?.patch.trim() && applied.applied !== true) {
+                return {
+                    ok: false,
+                    error: applied.warning ?? "The source's uncommitted changes could not be applied safely. The source was not modified; retry after committing or reducing the changes.",
+                    missing: [],
+                };
+            }
             if (applied.warning)
                 dirtyWarning = applied.warning;
             workspace = repoDir;
@@ -148,6 +169,13 @@ export function createForkStandUp(deps) {
                 const forkBranch = `bivy/fork-${randomBytes(6).toString("hex")}`;
                 const wt = await deps.withRepoLock(forkRepoRoot, () => deps.createWorktree({ repoDir: forkRepoRoot, id: forkBranch, branch: forkBranch }));
                 const applied = deps.applyDirtyPatch(wt.path, bundle.dirtyPatch);
+                if (bundle.dirtyPatch?.patch.trim() && applied.applied !== true) {
+                    return {
+                        ok: false,
+                        error: applied.warning ?? "The source's uncommitted changes could not be applied safely. The source was not modified; retry after committing or reducing the changes.",
+                        missing: [],
+                    };
+                }
                 if (applied.warning)
                     dirtyWarning = applied.warning;
                 workspace = forkRepoRoot;

package/dist/session/fork.js

@@ -9,18 +9,19 @@ import { normalizeMessages, buildSeedPrompt, buildForkHistory, } from "./transcr
  */
 export function buildForkBundle(opts) {
     const { runtime, sessionFile, record } = opts;
-    // Prefer the build-free readMessages fast path (pi/Claude); fall back to the
-    // live session's transcript for runtimes without one (the generic CLI runtime),
-    // so a fork *from* any agent still carries its real history.
+    // The live session is authoritative: a persisted native reader can lag the
+    // current turn (or return an empty-but-valid snapshot during a flush race).
+    // Prefer liveMessages whenever the caller has them, and use readMessages only
+    // when no live transcript was supplied. This avoids silently truncating a fork
+    // made while the source is open, while still supporting offline/native refs.
     let messages = opts.liveMessages;
-    if (sessionFile && runtime.readMessages) {
+    if (messages === undefined && sessionFile && runtime.readMessages) {
         try {
-            messages = runtime.readMessages(sessionFile) ?? messages;
+            messages = runtime.readMessages(sessionFile);
         }
         catch {
-            // Runtime-native readers are best-effort. The live transcript is the
-            // universal source fallback and keeps one broken adapter from blocking a
-            // fork out to every other agent.
+            // Runtime-native readers are best-effort. An unavailable reader yields an
+            // empty portable transcript, which still degrades safely to a seed.
         }
     }
     const normalized = normalizeMessages(messages, {

package/package.json

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