@fabricorg/cli 0.5.0 → 0.5.1

package/dist/fabric.js

@@ -6,7 +6,7 @@ import { Command as Command21 } from "commander";
 // package.json
 var package_default = {
   name: "@fabricorg/cli",
-  version: "0.5.0",
+  version: "0.5.1",
   description: "CLI for the Fabric AI platform",
   keywords: [
     "fabric",
@@ -235,10 +235,10 @@ var FabricHttpClient = class _FabricHttpClient {
    * Inject default `org` / `personal` query params if the path doesn't already
    * carry one. Resources that explicitly pass `?org=other` are untouched.
    */
-  buildUrl(path28) {
-    const url = `${this.baseUrl}/api/v1${path28}`;
-    const hasOrg = /[?&]org=/.test(path28);
-    const hasPersonal = /[?&]personal=/.test(path28);
+  buildUrl(path29) {
+    const url = `${this.baseUrl}/api/v1${path29}`;
+    const hasOrg = /[?&]org=/.test(path29);
+    const hasPersonal = /[?&]personal=/.test(path29);
     if (hasOrg || hasPersonal) {
       return url;
     }
@@ -251,11 +251,11 @@ var FabricHttpClient = class _FabricHttpClient {
     if (additions.length === 0) {
       return url;
     }
-    const sep = path28.includes("?") ? "&" : "?";
+    const sep = path29.includes("?") ? "&" : "?";
     return `${url}${sep}${additions.join("&")}`;
   }
-  async request(method, path28, options = {}) {
-    const url = this.buildUrl(path28);
+  async request(method, path29, options = {}) {
+    const url = this.buildUrl(path29);
     const isMutating = MUTATING_METHODS.has(method);
     const idempotencyKey = options.idempotencyKey ?? (isMutating ? randomId() : void 0);
     const maxAttempts = (options.retry ?? this.retry).maxRetries + 1;
@@ -265,7 +265,7 @@ var FabricHttpClient = class _FabricHttpClient {
         throw options.signal.reason;
       }
       const start = Date.now();
-      this.emit({ kind: "request", method, path: path28, attempt: attempt2 });
+      this.emit({ kind: "request", method, path: path29, attempt: attempt2 });
       try {
         const result = await this.executeOnce(
           method,
@@ -276,7 +276,7 @@ var FabricHttpClient = class _FabricHttpClient {
         this.emit({
           kind: "response",
           method,
-          path: path28,
+          path: path29,
           attempt: attempt2,
           status: 200,
           durationMs: Date.now() - start
@@ -289,7 +289,7 @@ var FabricHttpClient = class _FabricHttpClient {
         this.emit({
           kind: retriable ? "retry" : "error",
           method,
-          path: path28,
+          path: path29,
           attempt: attempt2,
           status,
           durationMs: Date.now() - start,
@@ -433,28 +433,28 @@ var FabricHttpClient = class _FabricHttpClient {
     } catch {
     }
   }
-  get(path28, options = {}) {
+  get(path29, options = {}) {
     return this.request(
       "GET",
-      path28,
+      path29,
       options.signal ? { signal: options.signal } : {}
     );
   }
-  post(path28, body, options = {}) {
-    return this.request("POST", path28, {
+  post(path29, body, options = {}) {
+    return this.request("POST", path29, {
       body,
       idempotencyKey: options.idempotencyKey,
       retry: options.retry
     });
   }
-  patch(path28, body, options = {}) {
-    return this.request("PATCH", path28, {
+  patch(path29, body, options = {}) {
+    return this.request("PATCH", path29, {
       body,
       idempotencyKey: options.idempotencyKey
     });
   }
-  put(path28, body, options = {}) {
-    return this.request("PUT", path28, {
+  put(path29, body, options = {}) {
+    return this.request("PUT", path29, {
       body,
       idempotencyKey: options.idempotencyKey,
       retry: options.retry
@@ -465,8 +465,8 @@ var FabricHttpClient = class _FabricHttpClient {
    * delete names the path and the version in its body). Without `body`,
    * nothing is sent, as before.
    */
-  delete(path28, body, options = {}) {
-    return this.request("DELETE", path28, {
+  delete(path29, body, options = {}) {
+    return this.request("DELETE", path29, {
       body,
       idempotencyKey: options.idempotencyKey
     });
@@ -1058,14 +1058,14 @@ function buildQuery3(opts) {
 
 // ../sdk/src/resources/integrations.ts
 var RESOURCE_BUILTINS = /* @__PURE__ */ new Set(["list", "constructor", "then"]);
-function makeDotPath(http, slug, path28) {
-  const fn = (args) => http.post(`/integrations/${slug}/${path28.join(".")}`, args ?? {});
+function makeDotPath(http, slug, path29) {
+  const fn = (args) => http.post(`/integrations/${slug}/${path29.join(".")}`, args ?? {});
   return new Proxy(fn, {
     get(target, prop) {
       if (prop in target || typeof prop !== "string") {
         return Reflect.get(target, prop);
       }
-      return makeDotPath(http, slug, [...path28, prop]);
+      return makeDotPath(http, slug, [...path29, prop]);
     }
   });
 }
@@ -1743,10 +1743,21 @@ import path from "path";
 import Conf from "conf";
 
 // src/lib/exclusive-lock.ts
-import { closeSync, openSync, statSync, unlinkSync, writeSync } from "fs";
+import { randomUUID } from "crypto";
+import {
+  closeSync,
+  openSync,
+  readFileSync,
+  statSync,
+  unlinkSync,
+  writeSync
+} from "fs";
 var ExclusiveLockBusyError = class extends Error {
-  constructor() {
-    super("another process holds this lock");
+  constructor(abandoned = false) {
+    super(
+      abandoned ? "an abandoned lock must be removed manually" : "another process holds this lock"
+    );
+    this.abandoned = abandoned;
     this.name = "ExclusiveLockBusyError";
   }
 };
@@ -1757,11 +1768,15 @@ function sleep2(ms) {
 function isExistsError(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
 }
+function isNotFoundError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
 function takeOnce(lockPath2, staleMs) {
   try {
     const descriptor = openSync(lockPath2, "wx", 384);
-    writeSync(descriptor, String(process.pid));
-    return descriptor;
+    const owner = `${process.pid}:${randomUUID()}`;
+    writeSync(descriptor, owner);
+    return { descriptor, owner };
   } catch (error) {
     if (!isExistsError(error)) {
       throw error;
@@ -1769,41 +1784,71 @@ function takeOnce(lockPath2, staleMs) {
   }
   try {
     if (Date.now() - statSync(lockPath2).mtimeMs > staleMs) {
-      unlinkSync(lockPath2);
+      if (ownerIsAlive(readFileSync(lockPath2, "utf8"))) {
+        return "busy";
+      }
+      return "abandoned";
+    }
+  } catch (error) {
+    if (isNotFoundError(error)) {
       return "retry";
     }
-  } catch {
-    return "retry";
+    throw error;
   }
   return "busy";
 }
-function release(descriptor, lockPath2) {
-  closeSync(descriptor);
+function ownerIsAlive(owner) {
+  const match = /^(\d+)(?::[0-9a-f-]+)?$/.exec(owner);
+  if (!match) {
+    return false;
+  }
+  const pid = Number(match[1]);
+  if (!Number.isSafeInteger(pid) || pid <= 0) {
+    return false;
+  }
   try {
-    unlinkSync(lockPath2);
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const code = error.code;
+    return code === "EPERM" || code !== "ESRCH" && code !== "ENOENT";
+  }
+}
+function release(held, lockPath2) {
+  closeSync(held.descriptor);
+  try {
+    if (readFileSync(lockPath2, "utf8") === held.owner) {
+      unlinkSync(lockPath2);
+    }
   } catch {
   }
 }
 async function withExclusiveLock(work, options) {
   const { lockPath: lockPath2, staleMs } = options;
   const deadline = Date.now() + options.waitMs;
-  let descriptor;
-  while (descriptor === void 0) {
+  let held;
+  while (held === void 0) {
     options.signal?.throwIfAborted();
     const taken = takeOnce(lockPath2, staleMs);
-    if (typeof taken === "number") {
-      descriptor = taken;
+    if (typeof taken === "object") {
+      held = taken;
+    } else if (taken === "abandoned") {
+      throw new ExclusiveLockBusyError(true);
     } else if (taken === "busy") {
       if (Date.now() >= deadline) {
         throw new ExclusiveLockBusyError();
       }
       await sleep2(options.pollMs ?? DEFAULT_POLL_MS);
+    } else if (Date.now() >= deadline) {
+      throw new ExclusiveLockBusyError();
+    } else {
+      await sleep2(options.pollMs ?? DEFAULT_POLL_MS);
     }
   }
   try {
     return await work();
   } finally {
-    release(descriptor, lockPath2);
+    release(held, lockPath2);
   }
 }
 function sleepSync(ms) {
@@ -1812,22 +1857,28 @@ function sleepSync(ms) {
 function withExclusiveLockSync(work, options) {
   const { lockPath: lockPath2, staleMs } = options;
   const deadline = Date.now() + options.waitMs;
-  let descriptor;
-  while (descriptor === void 0) {
+  let held;
+  while (held === void 0) {
     const taken = takeOnce(lockPath2, staleMs);
-    if (typeof taken === "number") {
-      descriptor = taken;
+    if (typeof taken === "object") {
+      held = taken;
+    } else if (taken === "abandoned") {
+      throw new ExclusiveLockBusyError(true);
     } else if (taken === "busy") {
       if (Date.now() >= deadline) {
         throw new ExclusiveLockBusyError();
       }
       sleepSync(options.pollMs ?? DEFAULT_POLL_MS);
+    } else if (Date.now() >= deadline) {
+      throw new ExclusiveLockBusyError();
+    } else {
+      sleepSync(options.pollMs ?? DEFAULT_POLL_MS);
     }
   }
   try {
     return work();
   } finally {
-    release(descriptor, lockPath2);
+    release(held, lockPath2);
   }
 }
 
@@ -1935,7 +1986,7 @@ function update(change) {
     );
   } catch (error) {
     throw error instanceof ExclusiveLockBusyError ? new Error(
-      "Another fabric process is updating the configuration and did not finish. Try again."
+      error.abandoned ? `A previous Fabric process left its configuration lock at ${JSON.stringify(lockPath2)}. Confirm it is no longer running, remove that lock, then try again.` : "Another fabric process is updating the configuration and did not finish. Try again."
     ) : error;
   }
 }
@@ -2257,8 +2308,8 @@ function sameOriginEndpoint(value, field2, issuer) {
 }
 function authorizationServerMetadataUrl(issuer) {
   const url = new URL(issuer);
-  const path28 = url.pathname.replace(/\/+$/, "");
-  return `${url.origin}/.well-known/oauth-authorization-server${path28}`;
+  const path29 = url.pathname.replace(/\/+$/, "");
+  return `${url.origin}/.well-known/oauth-authorization-server${path29}`;
 }
 async function discoverAuthorizationServer(baseUrl, options = {}) {
   const fetchImpl = options.fetch ?? ((input, init) => fetch(input, init));
@@ -2704,24 +2755,25 @@ var OAuthIssuerMismatchError = class extends Error {
   }
 };
 var OAuthRefreshBusyError = class extends Error {
-  constructor() {
+  constructor(lockPath2) {
     super(
-      "Another fabric process is renewing the sign-in and did not finish. Try again."
+      lockPath2 ? `A previous Fabric process left its sign-in lock at ${JSON.stringify(lockPath2)}. Confirm it is no longer running, remove that lock, then try again.` : "Another fabric process is renewing the sign-in and did not finish. Try again."
     );
     this.name = "OAuthRefreshBusyError";
   }
 };
 async function withRefreshLock(work, options = {}) {
+  const lockPath2 = options.lockPath ?? `${getConfigPath()}.refresh.lock`;
   try {
     return await withExclusiveLock(work, {
-      lockPath: options.lockPath ?? `${getConfigPath()}.refresh.lock`,
+      lockPath: lockPath2,
       staleMs: LOCK_STALE_MS,
       waitMs: options.waitMs ?? LOCK_WAIT_MS,
       pollMs: LOCK_POLL_MS,
       signal: options.signal
     });
   } catch (error) {
-    throw error instanceof ExclusiveLockBusyError ? new OAuthRefreshBusyError() : error;
+    throw error instanceof ExclusiveLockBusyError ? new OAuthRefreshBusyError(error.abandoned ? lockPath2 : void 0) : error;
   }
 }
 function defaults(deps) {
@@ -3530,8 +3582,9 @@ function decideCheckoutVerdict(input) {
 }
 
 // src/lib/user-agent.ts
+var INSTRUCTIONS_STREAMING_CAPABILITY = "instructions-stream-v1";
 function cliUserAgent(version = package_default.version, nodeVersion = process.versions.node, platform = process.platform) {
-  return `fabric-cli/${version} (node/${nodeVersion}; ${platform})`;
+  return `fabric-cli/${version} (node/${nodeVersion}; ${platform}; ${INSTRUCTIONS_STREAMING_CAPABILITY})`;
 }
 var MAX_NOTICE_CHARS = 300;
 var notice = null;
@@ -4815,7 +4868,7 @@ async function assertWritableTarget(root, relativePath) {
   }
   return check;
 }
-async function readFileSafely(root, relativePath, options = {}) {
+async function openFileSafely(root, relativePath) {
   const check = await assertWritableTarget(root, relativePath);
   if (!check.ok) {
     throw new Error(`Refusing to sync: ${describeRejection(check)}.`);
@@ -4851,15 +4904,31 @@ async function readFileSafely(root, relativePath, options = {}) {
         `Refusing to sync: ${relativePath} changed while it was being opened.`
       );
     }
+    return { handle, stats: opened };
+  } catch (error) {
+    await handle.close().catch(() => {
+    });
+    throw error;
+  }
+}
+async function readFileSafely(root, relativePath, options = {}) {
+  const opened = await openFileSafely(root, relativePath);
+  if (opened === null) {
+    return null;
+  }
+  try {
     if (options.maxBytes === void 0) {
-      return { bytes: await handle.readFile(), mode: opened.mode };
+      return {
+        bytes: await opened.handle.readFile(),
+        mode: opened.stats.mode
+      };
     }
     if (!Number.isSafeInteger(options.maxBytes) || options.maxBytes < 0) {
       throw new Error(
         "A safe file-read limit must be a non-negative integer."
       );
     }
-    if (opened.size > options.maxBytes) {
+    if (opened.stats.size > options.maxBytes) {
       throw new Error(
         `${relativePath} is too large to read safely (maximum ${options.maxBytes} bytes).`
       );
@@ -4867,7 +4936,7 @@ async function readFileSafely(root, relativePath, options = {}) {
     const buffer = Buffer.allocUnsafe(options.maxBytes + 1);
     let total = 0;
     while (total <= options.maxBytes) {
-      const { bytesRead } = await handle.read(
+      const { bytesRead } = await opened.handle.read(
         buffer,
         total,
         options.maxBytes + 1 - total,
@@ -4883,9 +4952,44 @@ async function readFileSafely(root, relativePath, options = {}) {
         `${relativePath} is too large to read safely (maximum ${options.maxBytes} bytes).`
       );
     }
-    return { bytes: buffer.subarray(0, total), mode: opened.mode };
+    return { bytes: buffer.subarray(0, total), mode: opened.stats.mode };
   } finally {
-    await handle.close();
+    await opened.handle.close();
+  }
+}
+var FINGERPRINT_BUFFER_BYTES = 64 * 1024;
+async function fingerprintFileSafely(root, relativePath) {
+  const opened = await openFileSafely(root, relativePath);
+  if (opened === null) {
+    return null;
+  }
+  try {
+    const hash = createHash2("sha256");
+    const buffer = Buffer.allocUnsafe(FINGERPRINT_BUFFER_BYTES);
+    let size = 0;
+    while (size <= opened.stats.size) {
+      const remaining = opened.stats.size + 1 - size;
+      const { bytesRead } = await opened.handle.read(
+        buffer,
+        0,
+        Math.min(buffer.length, remaining),
+        null
+      );
+      if (bytesRead === 0) {
+        break;
+      }
+      hash.update(buffer.subarray(0, bytesRead));
+      size += bytesRead;
+    }
+    const afterRead = await opened.handle.stat();
+    if (size !== opened.stats.size || afterRead.size !== opened.stats.size || afterRead.dev !== opened.stats.dev || afterRead.ino !== opened.stats.ino) {
+      throw new Error(
+        `Refusing to sync: ${relativePath} changed while it was being read.`
+      );
+    }
+    return { sha256: hash.digest("hex"), size, mode: opened.stats.mode };
+  } finally {
+    await opened.handle.close();
   }
 }
 async function resolveExistingRoot(destination) {
@@ -5070,23 +5174,23 @@ function normalizeContextSourcePath(input) {
   if (slashed.startsWith("/") || DRIVE_LETTER_PREFIX.test(slashed)) {
     return { ok: false, reason: "absolute" };
   }
-  let path28 = slashed.replace(/\/{2,}/g, "/");
-  while (path28.startsWith("./")) {
-    path28 = path28.slice(2);
+  let path29 = slashed.replace(/\/{2,}/g, "/");
+  while (path29.startsWith("./")) {
+    path29 = path29.slice(2);
   }
-  if (path28.length === 0) {
+  if (path29.length === 0) {
     return { ok: false, reason: "empty" };
   }
-  if (path28.endsWith("/")) {
+  if (path29.endsWith("/")) {
     return { ok: false, reason: "trailing-slash" };
   }
-  if (path28.split("/").some((segment) => segment === "." || segment === "..")) {
+  if (path29.split("/").some((segment) => segment === "." || segment === "..")) {
     return { ok: false, reason: "dot-segment" };
   }
-  if (path28.length > MAX_CONTEXT_SOURCE_PATH_LENGTH) {
+  if (path29.length > MAX_CONTEXT_SOURCE_PATH_LENGTH) {
     return { ok: false, reason: "too-long" };
   }
-  return { ok: true, sourcePath: path28 };
+  return { ok: true, sourcePath: path29 };
 }
 
 // src/lib/context-sync/lock.ts
@@ -5974,9 +6078,9 @@ async function pushContextPlan(input) {
     }
   };
   const pruneTargetsSoFar = () => {
-    const keptByMoves = results.map(moveKeptOldPath).filter((path28) => path28 !== null);
-    return [.../* @__PURE__ */ new Set([...input.plan.removed, ...keptByMoves])].filter((path28) => {
-      const locked = input.lock?.files[path28];
+    const keptByMoves = results.map(moveKeptOldPath).filter((path29) => path29 !== null);
+    return [.../* @__PURE__ */ new Set([...input.plan.removed, ...keptByMoves])].filter((path29) => {
+      const locked = input.lock?.files[path29];
       return locked !== void 0 && locked.state !== "duplicate";
     }).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
   };
@@ -6614,7 +6718,7 @@ function pruneSummary(results, targets) {
       (r) => r.status === "deleted" || r.status === "already-gone"
     ).map((r) => r.sourcePath)
   );
-  const notDeleted = targets.filter((path28) => !settled.has(path28)).length;
+  const notDeleted = targets.filter((path29) => !settled.has(path29)).length;
   let text3 = `--prune: ${count("deleted")} deleted, ${count("already-gone")} already gone, ${notDeleted} not deleted`;
   const first = results.find((r) => r.status === "delete-failed");
   if (first && first.status === "delete-failed") {
@@ -6997,8 +7101,8 @@ function buildFramesCommand() {
 }
 
 // src/commands/instructions/index.ts
-import { readdir as readdir4 } from "fs/promises";
-import path27 from "path";
+import { readdir as readdir3 } from "fs/promises";
+import path28 from "path";
 import { Command as Command12 } from "commander";
 
 // src/lib/environment.ts
@@ -7122,6 +7226,11 @@ function runGit(cwd, args, deadline, options = {}) {
       child = spawn2(
         "git",
         [
+          // Windows Git can report modified long-path files from its file
+          // system cache even when Git's diff is empty. This command-local
+          // setting keeps inspection truthful without changing the user's
+          // checkout configuration.
+          ...process.platform === "win32" ? ["-c", "core.fscache=false"] : [],
           "-c",
           "core.fsmonitor=false",
           ...options.write ? ["-c", "credential.interactive=never"] : [],
@@ -7541,6 +7650,77 @@ async function isClean(root, deadline) {
     deadline
   );
 }
+async function trackedPaths(root, relativePaths, deadline) {
+  if (relativePaths.length === 0) {
+    return { kind: "ok", value: [] };
+  }
+  if (relativePaths.some(
+    (relativePath) => relativePath === "" || relativePath.startsWith("-") || path7.isAbsolute(relativePath) || path7.win32.isAbsolute(relativePath) || relativePath.split(/[\\/]/).some((part) => part === "..")
+  )) {
+    return {
+      kind: "unavailable",
+      reason: "not paths git can be asked about"
+    };
+  }
+  const result = await simple(
+    root,
+    ["ls-files", "-z", "--", ...relativePaths],
+    deadline
+  );
+  if (result.kind !== "ok") {
+    return result;
+  }
+  if (result.value.code !== 0) {
+    return {
+      kind: "unavailable",
+      reason: `git exited with status ${result.value.code}`
+    };
+  }
+  return {
+    kind: "ok",
+    value: result.value.stdout.split("\0").filter((entry) => entry !== "")
+  };
+}
+async function checkoutAppearsIncomplete(root, deadline) {
+  const index = await simple(root, ["ls-files", "--stage", "-z"], deadline);
+  if (index.kind !== "ok") {
+    return index;
+  }
+  if (index.value.code !== 0) {
+    return {
+      kind: "unavailable",
+      reason: `git exited with status ${index.value.code}`
+    };
+  }
+  if (index.value.stdout !== "") {
+    return { kind: "ok", value: false };
+  }
+  const [headTree, staged, untracked] = await Promise.all([
+    simple(root, ["ls-tree", "-r", "-z", "--name-only", "HEAD"], deadline),
+    simple(root, ["diff", "--cached", "--quiet", "--exit-code"], deadline),
+    simple(
+      root,
+      ["ls-files", "--others", "--exclude-standard", "-z"],
+      deadline
+    )
+  ]);
+  if (headTree.kind !== "ok") {
+    return headTree;
+  }
+  if (staged.kind !== "ok") {
+    return staged;
+  }
+  if (untracked.kind !== "ok") {
+    return untracked;
+  }
+  if (headTree.value.code !== 0 || staged.value.code !== 0 && staged.value.code !== 1 || untracked.value.code !== 0) {
+    return { kind: "unavailable", reason: "git answered unexpectedly" };
+  }
+  return {
+    kind: "ok",
+    value: headTree.value.stdout !== "" && staged.value.code === 1 && untracked.value.stdout !== ""
+  };
+}
 async function porcelainIsEmpty(root, args, deadline) {
   const result = await simple(
     root,
@@ -7767,6 +7947,11 @@ function cloneFailureOf(stderr) {
   if (/Remote branch .* not found/i.test(stderr)) {
     return "missing-ref";
   }
+  if (/Filename too long|unable to create file|unable to checkout working tree/i.test(
+    stderr
+  )) {
+    return "checkout";
+  }
   if (/could not read (Username|Password)|terminal prompts disabled|Authentication failed|Permission denied|HTTP (401|403)|error: (401|403)|returned error: (401|403)|Repository not found|access denied/i.test(
     stderr
   )) {
@@ -7788,7 +7973,22 @@ async function cloneInto(dir, url, ref, deadline) {
   }
   const result = await runGit(
     dir,
-    ["clone", "--quiet", "--branch", ref, "--", url, "."],
+    [
+      ...process.platform === "win32" ? ["-c", "core.longpaths=true", "-c", "core.fscache=false"] : [],
+      "clone",
+      "--quiet",
+      ...process.platform === "win32" ? [
+        "--config",
+        "core.longpaths=true",
+        "--config",
+        "core.fscache=false"
+      ] : [],
+      "--branch",
+      ref,
+      "--",
+      url,
+      "."
+    ],
     deadline,
     { write: true }
   );
@@ -7879,16 +8079,19 @@ var LINES = {
   "clone-needs-project": () => "--clone <folder> needs --project <id>: there is no checkout yet to find the project from.",
   "clone-needs-repository": () => "--clone needs a project whose instructions come from a git repository; this project's are uploaded, so there is nothing to clone.",
   "clone-folder-in-use": () => "That folder already exists and is not empty, so nothing was cloned into it. Pick a folder that does not exist yet, or run init inside it when it already is the clone.",
+  "clone-checkout-needs-repair": () => "This folder appears to be an incomplete Git checkout. Fabric left it untouched. Inspect its staged and untracked files with git status, then repair or remove the checkout yourself before running init again.",
   "clone-failed": ({ repo, ref, host, url, reason, login }) => {
     switch (reason) {
       case "auth":
-        return `Could not clone ${repo}: git has no credentials for ${shown(host)}. Run: ${login}`;
+        return `Could not clone ${repo}: git has no credentials for ${shown(host)}. The Fabric MCP server was not registered. Run: ${login}`;
       case "network":
-        return `Could not clone ${repo}: ${shown(host)} did not answer. Check your network and try again.`;
+        return `Could not clone ${repo}: ${shown(host)} did not answer. The Fabric MCP server was not registered. Check your network and try again.`;
       case "missing-ref":
-        return `Could not clone ${repo}: it has no branch ${shown(ref)}.`;
+        return `Could not clone ${repo}: it has no branch ${shown(ref)}. The Fabric MCP server was not registered.`;
+      case "checkout":
+        return `Could not finish checking out ${repo}. Fabric did not change the partial checkout or register its MCP server. Inspect it with git status, then repair or remove it yourself before trying again.`;
       case "other":
-        return `Could not clone ${repo}. Run: git clone -- ${url} to see why.`;
+        return `Could not clone ${repo}. The Fabric MCP server was not registered. Run: git clone -- ${url} to see why.`;
       default:
         return reason;
     }
@@ -7964,6 +8167,7 @@ var LINES = {
     }
   },
   "ff-locked": () => `${HOOK_PREFIX}: another fabric process is updating this checkout; nothing was changed.`,
+  "ff-abandoned-lock": ({ lockPath: lockPath2 }) => `${HOOK_PREFIX}: a previous Fabric process left its lock at ${JSON.stringify(lockPath2)}; nothing was changed. Confirm it is no longer running, remove that lock, then run the hook again.`,
   "ff-fabric-lags": ({ reason, ref, sha7 }) => `${HOOK_PREFIX}: ${ref} is at ${sha7}; Fabric's copy is behind (${LAG_TEXT[reason]}).`,
   "class-foreign": ({ repo }) => `${HOOK_PREFIX}: no remote of this checkout fetches from ${repo}; nothing was checked.`,
   "class-ambiguous": ({ repo, remotes: remotes2 }) => `${HOOK_PREFIX}: remotes ${remotes2.join(", ")} all fetch from ${repo}; nothing was checked. Run: ${fabricCommand(`instructions init --remote ${remotes2[0] ?? "origin"}`)}`,
@@ -8017,6 +8221,7 @@ var EXIT_CODES = {
   "clone-needs-project": 2,
   "clone-needs-repository": 7,
   "clone-folder-in-use": 7,
+  "clone-checkout-needs-repair": 7,
   "clone-failed": ({ reason }) => reason === "auth" ? 3 : reason === "missing-ref" ? 7 : 1,
   "no-clone-url": 7,
   "lock-removed": 0,
@@ -8030,6 +8235,7 @@ var EXIT_CODES = {
   "ff-fetch-failed": 0,
   "ff-merge-failed": 0,
   "ff-locked": 0,
+  "ff-abandoned-lock": 0,
   "ff-fabric-lags": 0,
   "class-foreign": 7,
   "class-ambiguous": 7,
@@ -8899,6 +9105,9 @@ async function readRegistration(input) {
 }
 
 // src/lib/instructions/hook.ts
+import { createHash as createHash4 } from "crypto";
+import { mkdir as mkdir2 } from "fs/promises";
+import { tmpdir } from "os";
 import path11 from "path";
 
 // src/lib/instructions/identifiers.ts
@@ -8917,6 +9126,8 @@ var CLAUDE_SETTINGS_POSIX_PATH = ".claude/settings.local.json";
 var CODEX_HOOKS_POSIX_PATH = ".codex/hooks.json";
 var HOOK_TIMEOUT_SECONDS = 15;
 var MAX_HOOK_CONFIG_BYTES = 1024 * 1024;
+var HOOK_LOCK_STALE_MS = 3e4;
+var HOOK_LOCK_WAIT_MS = 5e3;
 var HOOK_SUBCOMMANDS = /* @__PURE__ */ new Set(["check", "sync", "lesson-prompt"]);
 var SESSION_START_SUBCOMMANDS = /* @__PURE__ */ new Set([
   "check",
@@ -8926,6 +9137,26 @@ var STOP_SUBCOMMANDS = /* @__PURE__ */ new Set(["lesson-prompt"]);
 function subcommandsForEvent(event) {
   return event === "Stop" ? STOP_SUBCOMMANDS : SESSION_START_SUBCOMMANDS;
 }
+async function withHookConfigLock(root, posixPath, work) {
+  const directory = path11.join(tmpdir(), "fabric-instructions-hook-locks");
+  await mkdir2(directory, { recursive: true });
+  const identity = createHash4("sha256").update(path11.resolve(root)).update("\0").update(posixPath).digest("hex");
+  const lockPath2 = path11.join(directory, `${identity}.lock`);
+  try {
+    return await withExclusiveLock(work, {
+      lockPath: lockPath2,
+      staleMs: HOOK_LOCK_STALE_MS,
+      waitMs: HOOK_LOCK_WAIT_MS
+    });
+  } catch (error) {
+    if (error instanceof ExclusiveLockBusyError && error.abandoned) {
+      throw new Error(
+        `A previous Fabric process left the hook configuration lock at ${JSON.stringify(lockPath2)}. Confirm it is no longer running, remove that lock, then run init again.`
+      );
+    }
+    throw error;
+  }
+}
 function assertCommandIdentifiers(projectId, org) {
   if (!isIdentifier(projectId) || org !== void 0 && !isIdentifier(org)) {
     throw new Error(
@@ -9043,85 +9274,89 @@ function pruneMatching(groups, projectId, subcommands) {
 }
 async function mergeCommandHook(input) {
   const hookTarget = hookTargetFor(input.tool ?? "claude-code");
-  const settingsPath = path11.join(input.root, hookTarget.relativePath);
-  const { settings, existingRaw } = await readHookConfig(
-    input.root,
-    hookTarget
-  );
-  const { hooks, groups } = readEventGroups(
-    settingsPath,
-    settings,
-    input.event
-  );
-  const replacement = {
-    type: "command",
-    command: input.command,
-    timeout: HOOK_TIMEOUT_SECONDS
-  };
-  const { pruned, removedCount } = pruneMatching(
-    groups,
-    input.projectId,
-    subcommandsForEvent(input.event)
-  );
-  pruned.push({ hooks: [replacement] });
-  const next = {
-    ...settings,
-    hooks: { ...hooks, [input.event]: pruned }
-  };
-  await writeFileSafely({
-    root: input.root,
-    relativePath: hookTarget.posixPath,
-    bytes: new TextEncoder().encode(
-      `${JSON.stringify(next, null, 2).replace(/\r\n/g, "\n")}
+  return withHookConfigLock(input.root, hookTarget.posixPath, async () => {
+    const settingsPath = path11.join(input.root, hookTarget.relativePath);
+    const { settings, existingRaw } = await readHookConfig(
+      input.root,
+      hookTarget
+    );
+    const { hooks, groups } = readEventGroups(
+      settingsPath,
+      settings,
+      input.event
+    );
+    const replacement = {
+      type: "command",
+      command: input.command,
+      timeout: HOOK_TIMEOUT_SECONDS
+    };
+    const { pruned, removedCount } = pruneMatching(
+      groups,
+      input.projectId,
+      subcommandsForEvent(input.event)
+    );
+    pruned.push({ hooks: [replacement] });
+    const next = {
+      ...settings,
+      hooks: { ...hooks, [input.event]: pruned }
+    };
+    await writeFileSafely({
+      root: input.root,
+      relativePath: hookTarget.posixPath,
+      bytes: new TextEncoder().encode(
+        `${JSON.stringify(next, null, 2).replace(/\r\n/g, "\n")}
 `
-    )
+      )
+    });
+    return {
+      settingsPath,
+      command: input.command,
+      createdFile: existingRaw === null,
+      replacedCount: removedCount
+    };
   });
-  return {
-    settingsPath,
-    command: input.command,
-    createdFile: existingRaw === null,
-    replacedCount: removedCount
-  };
 }
 async function mergeSessionStartHook(input) {
   return mergeCommandHook({ ...input, event: "SessionStart" });
 }
 async function removeCommandHook(input) {
   const hookTarget = hookTargetFor(input.tool ?? "claude-code");
-  const settingsPath = path11.join(input.root, hookTarget.relativePath);
-  const { settings, existingRaw } = await readHookConfig(
-    input.root,
-    hookTarget
-  );
-  if (existingRaw === null) {
-    return { settingsPath, changed: false };
-  }
-  const { hooks, groups } = readEventGroups(
-    settingsPath,
-    settings,
-    input.event
-  );
-  const { pruned, removedCount } = pruneMatching(
-    groups,
-    input.projectId,
-    /* @__PURE__ */ new Set([input.subcommand])
-  );
-  if (removedCount === 0) {
-    return { settingsPath, changed: false };
-  }
-  const next = {
-    ...settings,
-    hooks: { ...hooks, [input.event]: pruned }
-  };
-  await writeFileSafely({
-    root: input.root,
-    relativePath: hookTarget.posixPath,
-    bytes: new TextEncoder().encode(
-      `${JSON.stringify(next, null, 2).replace(/\r\n/g, "\n")}
+  return withHookConfigLock(input.root, hookTarget.posixPath, async () => {
+    const settingsPath = path11.join(input.root, hookTarget.relativePath);
+    const { settings, existingRaw } = await readHookConfig(
+      input.root,
+      hookTarget
+    );
+    if (existingRaw === null) {
+      return { settingsPath, changed: false };
+    }
+    const { hooks, groups } = readEventGroups(
+      settingsPath,
+      settings,
+      input.event
+    );
+    const { pruned, removedCount } = pruneMatching(
+      groups,
+      input.projectId,
+      /* @__PURE__ */ new Set([input.subcommand])
+    );
+    if (removedCount === 0) {
+      return { settingsPath, changed: false };
+    }
+    const next = {
+      ...settings,
+      hooks: { ...hooks, [input.event]: pruned }
+    };
+    await writeFileSafely({
+      root: input.root,
+      relativePath: hookTarget.posixPath,
+      bytes: new TextEncoder().encode(
+        `${JSON.stringify(next, null, 2).replace(/\r\n/g, "\n")}
 `
-    )
+      )
+    });
+    return { settingsPath, changed: true };
   });
-  return { settingsPath, changed: true };
 }
 async function findSessionStartHooks(input) {
   const hookTarget = hookTargetFor(input.tool);
@@ -9292,6 +9527,16 @@ var TOOL_COMMAND = {
   "claude-code": "claude",
   codex: "codex"
 };
+function mcpRegistrationComplete(results) {
+  return results.every(
+    (result) => result.outcome.kind === "registered" || result.outcome.kind === "replaced" || result.outcome.kind === "already"
+  );
+}
+function mcpAuthenticationPending(results) {
+  return results.some(
+    (result) => result.login === "printed" || result.login === "not-finished"
+  );
+}
 var SERVER_ID_SUFFIX_LENGTH = 6;
 function codexServerName(projectId) {
   const suffix = projectId.toLowerCase().replace(/[^a-z0-9]+/g, "").slice(-SERVER_ID_SUFFIX_LENGTH);
@@ -9795,9 +10040,6 @@ function createAgentRunner(input) {
 import { createHash as createHash5 } from "crypto";
 import { chmod } from "fs/promises";
 
-// src/lib/instructions/plan.ts
-import { createHash as createHash4 } from "crypto";
-
 // src/lib/instructions/lock.ts
 import { readFile as readFile3 } from "fs/promises";
 import path14 from "path";
@@ -9970,8 +10212,7 @@ function sourceProblem(value) {
 
 // src/lib/instructions/plan.ts
 async function hashLocalFile(root, relativePath) {
-  const read = await readFileSafely(root, relativePath);
-  return read === null ? null : createHash4("sha256").update(read.bytes).digest("hex");
+  return (await fingerprintFileSafely(root, relativePath))?.sha256 ?? null;
 }
 function lockPaths(lock) {
   return lock === null ? [] : Object.keys(lock.files);
@@ -10012,9 +10253,9 @@ async function findLedgerDrift(input) {
   assertSafeLockPaths(lockPaths(input.lock));
   const drifted = [];
   for (const [lockedPath, locked] of Object.entries(input.lock.files)) {
-    let read;
+    let fingerprint;
     try {
-      read = await readFileSafely(input.root, lockedPath);
+      fingerprint = await fingerprintFileSafely(input.root, lockedPath);
     } catch (error) {
       drifted.push({
         path: lockedPath,
@@ -10024,7 +10265,7 @@ async function findLedgerDrift(input) {
       });
       continue;
     }
-    if (read === null) {
+    if (fingerprint === null) {
       drifted.push({
         path: lockedPath,
         reason: "missing",
@@ -10033,7 +10274,7 @@ async function findLedgerDrift(input) {
       });
       continue;
     }
-    const actual = createHash4("sha256").update(read.bytes).digest("hex");
+    const actual = fingerprint.sha256;
     if (actual !== locked.sha256) {
       drifted.push({
         path: lockedPath,
@@ -10043,11 +10284,11 @@ async function findLedgerDrift(input) {
       });
       continue;
     }
-    if (process.platform !== "win32" && locked.mode !== null && (read.mode & 4095) !== (locked.mode & 4095)) {
+    if (process.platform !== "win32" && locked.mode !== null && (fingerprint.mode & 4095) !== (locked.mode & 4095)) {
       drifted.push({
         path: lockedPath,
         reason: "mode",
-        detail: `mode ${(read.mode & 4095).toString(8)}, published as ${(locked.mode & 4095).toString(8)}`,
+        detail: `mode ${(fingerprint.mode & 4095).toString(8)}, published as ${(locked.mode & 4095).toString(8)}`,
         kept: locked.kept === true
       });
     }
@@ -10207,7 +10448,7 @@ async function applyPlan(input) {
         `Refusing to sync: ${entry.path} asks for file mode ${(entry.mode ?? 0).toString(8)}, and only 644 and 755 are accepted. Nothing was written.`
       );
     }
-    const bytes = contents.get(entry.path);
+    const bytes = await contents.get(entry.path);
     if (!bytes) {
       throw new Error(
         `The downloaded bundle is missing ${entry.path}. Nothing was written.`
@@ -10233,7 +10474,10 @@ async function applyPlan(input) {
         continue;
       }
     }
-    const bytes = contents.get(entry.path);
+    const bytes = await contents.get(entry.path);
+    if (!bytes) {
+      throw new Error(`The downloaded bundle is missing ${entry.path}.`);
+    }
     await writeFileSafely({
       root,
       relativePath: entry.path,
@@ -10414,7 +10658,7 @@ function extractBundle(archive, wanted) {
 }
 
 // src/lib/instructions/clone-target.ts
-import { lstat as lstat5, readdir as readdir2 } from "fs/promises";
+import { lstat as lstat5 } from "fs/promises";
 import path15 from "path";
 async function resolveCloneFolder(base, folder) {
   const target = path15.resolve(base, folder);
@@ -10427,23 +10671,117 @@ async function resolveCloneFolder(base, folder) {
   if (stats === null) {
     return target;
   }
-  if (!stats.isDirectory() || (await readdir2(target)).length > 0) {
+  if (!stats.isDirectory()) {
     throw outcomeFailure("clone-folder-in-use", {});
   }
   return target;
 }
 
 // src/lib/instructions/doctor.ts
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash9 } from "crypto";
 import { stat as stat4 } from "fs/promises";
-import path16 from "path";
+import path17 from "path";
 
-// src/lib/instructions/manifest.ts
+// src/lib/instructions/file-downloads.ts
 import { createHash as createHash6 } from "crypto";
+var PER_FILE_MAX_WRITES = 100;
+var URL_REQUEST_CHUNK = 200;
+var DOWNLOAD_CONCURRENCY = 8;
+var PublishedChangedError = class extends Error {
+  constructor() {
+    super("The published version changed while this command ran.");
+    this.name = "PublishedChangedError";
+  }
+};
+async function fetchFilesByUrl(options) {
+  const contents = /* @__PURE__ */ new Map();
+  await downloadFilesByUrl(options, async (file, bytes) => {
+    contents.set(file.path, bytes);
+  });
+  return contents;
+}
+async function downloadFilesByUrl(options, consume) {
+  for (let i = 0; i < options.files.length; i += URL_REQUEST_CHUNK) {
+    const files = options.files.slice(i, i + URL_REQUEST_CHUNK);
+    const wanted = new Set(files.map((file) => file.path));
+    const urls = /* @__PURE__ */ new Map();
+    const paths = files.map((file) => file.path);
+    let response;
+    try {
+      response = await options.client.instructions.createFileDownloadUrls(
+        options.projectId,
+        { digest: options.digest, paths },
+        { org: options.org }
+      );
+    } catch (error) {
+      if (error instanceof FabricError && error.status === 409 && error.code === "PUBLISHED_CHANGED") {
+        throw new PublishedChangedError();
+      }
+      throw error;
+    }
+    if (response.digest !== options.digest) {
+      throw new PublishedChangedError();
+    }
+    for (const file of response.files) {
+      if (!wanted.has(file.path) || urls.has(file.path)) {
+        throw new Error(
+          "The server returned a file that was not asked for. Nothing was written."
+        );
+      }
+      urls.set(file.path, file.url);
+    }
+    if (urls.size !== wanted.size) {
+      throw new Error(
+        `The server returned ${urls.size} of ${wanted.size} requested files. Nothing was written.`
+      );
+    }
+    const queue = files.values();
+    const failures = [];
+    const worker = async () => {
+      while (failures.length === 0) {
+        const next = queue.next();
+        if (next.done) {
+          return;
+        }
+        const file = next.value;
+        try {
+          const bytes = await fetchBundle(urls.get(file.path) ?? "", {
+            timeoutMs: options.timeoutMs,
+            // The manifest's size, not the response's: the read is
+            // abandoned the moment it passes what the plan expects.
+            maxBytes: file.size,
+            signal: options.signal,
+            fetchImpl: options.fetchImpl
+          });
+          if (bytes.length !== file.size || createHash6("sha256").update(bytes).digest("hex") !== file.sha256) {
+            throw new Error(
+              `A downloaded file does not match the manifest (${file.path}). Nothing was written.`
+            );
+          }
+          await consume(file, bytes);
+        } catch (error) {
+          failures.push(error);
+        }
+      }
+    };
+    await Promise.all(
+      Array.from(
+        { length: Math.min(DOWNLOAD_CONCURRENCY, files.length) },
+        () => worker()
+      )
+    );
+    if (failures.length > 0) {
+      throw failures[0];
+    }
+  }
+}
+
+// src/lib/instructions/manifest.ts
+import { createHash as createHash7 } from "crypto";
 var SHA256_HEX3 = /^[0-9a-f]{64}$/;
 var MANIFEST_LIMITS = {
   maxFiles: 5e3,
-  maxTotalBytes: 52428800,
+  maxTotalBytes: 2147483647,
   maxFileBytes: 5242880,
   maxPathBytes: 1024,
   maxDepth: 64
@@ -10468,7 +10806,7 @@ function computeSnapshotDigest(entries) {
 ` : `${entry.path}\0${entry.sha256}\0${mode.toString(8)}
 `;
   }).join("");
-  return createHash6("sha256").update(Buffer.from(lines2, "utf8")).digest("hex");
+  return createHash7("sha256").update(Buffer.from(lines2, "utf8")).digest("hex");
 }
 function computeLegacySnapshotDigest(entries) {
   return computeSnapshotDigest(
@@ -10685,6 +11023,53 @@ function isTooLarge(error) {
   return error instanceof Error && error.message.includes("too large to read safely");
 }
 
+// src/lib/instructions/staged-files.ts
+import { createHash as createHash8 } from "crypto";
+import { mkdtemp, realpath as realpath3, rm } from "fs/promises";
+import { tmpdir as tmpdir2 } from "os";
+import path16 from "path";
+var IN_MEMORY_SNAPSHOT_BYTES = 50 * 1024 * 1024;
+async function stageFilesByUrl(options) {
+  const root = await realpath3(
+    await mkdtemp(path16.join(tmpdir2(), "fabric-instructions-"))
+  );
+  const files = /* @__PURE__ */ new Map();
+  const dispose = () => rm(root, { recursive: true, force: true });
+  try {
+    await downloadFilesByUrl(options, async (file, bytes) => {
+      const key = String(files.size);
+      files.set(file.path, { ...file, key });
+      await writeFileSafely({
+        root,
+        relativePath: key,
+        bytes,
+        mode: null
+      });
+    });
+  } catch (error) {
+    await dispose();
+    throw error;
+  }
+  return {
+    dispose,
+    async get(filePath) {
+      const file = files.get(filePath);
+      if (!file) {
+        return void 0;
+      }
+      const loaded = await readFileSafely(root, file.key, {
+        maxBytes: file.size
+      });
+      if (!loaded || loaded.bytes.length !== file.size || createHash8("sha256").update(loaded.bytes).digest("hex") !== file.sha256) {
+        throw new Error(
+          `A staged file does not match the manifest (${filePath}).`
+        );
+      }
+      return loaded.bytes;
+    }
+  };
+}
+
 // src/lib/instructions/doctor.ts
 var MAX_ITEMS = 50;
 var MAX_NAMES_IN_FIX = 20;
@@ -10812,7 +11197,7 @@ function buildFabricCommand(args, platform = process.platform) {
   return launcher === null ? void 0 : [...launcher, ...words].join(" ");
 }
 function sha256Hex(bytes) {
-  return createHash7("sha256").update(bytes).digest("hex");
+  return createHash9("sha256").update(bytes).digest("hex");
 }
 function listNames(names) {
   const shown2 = names.slice(0, MAX_NAMES_IN_FIX);
@@ -12002,26 +12387,55 @@ async function downloadDeclaration(input, commands, client, initial, initialEntr
   let manifest = initial.manifest;
   let entry = initialEntry;
   for (let attempt2 = 0; attempt2 < 2; attempt2++) {
-    let download2;
     try {
-      download2 = await input.createDownloadUrl(input.projectId, {
+      if (manifest.reduce((total, file) => total + file.size, 0) > IN_MEMORY_SNAPSHOT_BYTES) {
+        const instructions = client().instructions;
+        const sign = instructions.createFileDownloadUrls?.bind(instructions);
+        if (!sign) {
+          return {
+            kind: "unreadable",
+            status: "fail",
+            detail: "this CLI cannot read a declaration from a large snapshot",
+            fix: fixOf(
+              "run the latest CLI from the project's Connect dialog"
+            )
+          };
+        }
+        const files = await fetchFilesByUrl({
+          client: { instructions: { createFileDownloadUrls: sign } },
+          projectId: input.projectId,
+          org: input.org,
+          digest: snapshot.digest,
+          files: [entry],
+          timeoutMs: 3e4,
+          fetchImpl: input.fetchImpl
+        });
+        const bytes = files.get(entry.path);
+        if (!bytes) {
+          throw new Error("Published declaration missing");
+        }
+        return parseDeclarationBytes(bytes, "published");
+      }
+      const download2 = await input.createDownloadUrl(input.projectId, {
         org: input.org
       });
+      if (download2.snapshotId === snapshot.id && download2.digest === snapshot.digest) {
+        return fetchVerifiedDeclaration(
+          input,
+          download2.url,
+          manifest,
+          entry
+        );
+      }
     } catch (error) {
-      return {
-        kind: "unreadable",
-        status: "fail",
-        detail: `could not download the published declaration (${requestFailureClass(error)})`,
-        fix: fixOf(NETWORK_FIX)
-      };
-    }
-    if (download2.snapshotId === snapshot.id && download2.digest === snapshot.digest) {
-      return fetchVerifiedDeclaration(
-        input,
-        download2.url,
-        manifest,
-        entry
-      );
+      if (!(error instanceof PublishedChangedError)) {
+        return {
+          kind: "unreadable",
+          status: "fail",
+          detail: `could not download the published declaration (${requestFailureClass(error)})`,
+          fix: fixOf(NETWORK_FIX)
+        };
+      }
     }
     if (attempt2 > 0) {
       break;
@@ -12449,13 +12863,13 @@ async function commandResolves(input, lookup, command) {
   if (TOOL_NAME.test(command)) {
     return await isOnPath(command, lookup) ? "found" : "missing";
   }
-  const api = input.platform === "win32" ? path16.win32 : path16.posix;
+  const api = input.platform === "win32" ? path17.win32 : path17.posix;
   if (api.isAbsolute(command)) {
     return await isExecutableFile(command, input.platform) ? "found" : "missing";
   }
   if (command.includes("/") || command.includes("\\")) {
     return await isExecutableFile(
-      path16.resolve(input.root, command),
+      path17.resolve(input.root, command),
       input.platform
     ) ? "found" : "missing";
   }
@@ -12630,9 +13044,9 @@ function formatDoctorText(report, destination) {
 }
 
 // src/lib/instructions/drop-lock.ts
-import { createHash as createHash8 } from "crypto";
+import { createHash as createHash10 } from "crypto";
 import { rmdir } from "fs/promises";
-import path17 from "path";
+import path18 from "path";
 var LOCK_RELATIVE = `${LOCK_DIRECTORY}/${LOCK_FILENAME}`;
 var MAX_LOCK_BYTES2 = 16 * 1024 * 1024;
 async function dropOwnLock(root, projectId) {
@@ -12647,12 +13061,12 @@ async function dropOwnLock(root, projectId) {
     if (lock.projectId !== projectId) {
       return false;
     }
-    const sha256 = createHash8("sha256").update(read.bytes).digest("hex");
+    const sha256 = createHash10("sha256").update(read.bytes).digest("hex");
     const outcome = await deleteFileSafely(root, LOCK_RELATIVE, sha256);
     if (outcome !== "deleted") {
       return false;
     }
-    await rmdir(path17.join(root, LOCK_DIRECTORY)).catch(() => void 0);
+    await rmdir(path18.join(root, LOCK_DIRECTORY)).catch(() => void 0);
     return true;
   } catch {
     return false;
@@ -12744,8 +13158,8 @@ function replacePath(text3, target, replacement) {
 }
 
 // src/lib/instructions/fast-forward-run.ts
-import { mkdir as mkdir4, realpath as realpath3 } from "fs/promises";
-import path20 from "path";
+import { mkdir as mkdir5, realpath as realpath4 } from "fs/promises";
+import path21 from "path";
 
 // src/lib/instructions/fast-forward.ts
 function fastForwardEligibility(facts) {
@@ -12916,6 +13330,14 @@ function fastForwardLines(outcome, context) {
       stdout.push(outcomeLine("ff-locked", {}));
       otherLine();
       break;
+    case "abandoned-lock":
+      stdout.push(
+        outcomeLine("ff-abandoned-lock", {
+          lockPath: outcome.lockPath
+        })
+      );
+      otherLine();
+      break;
     case "deadline":
       stderr.push(
         skipped(outcomeLine("gave-up", { after: context.gaveUpAfter }))
@@ -12929,10 +13351,10 @@ function fastForwardLines(outcome, context) {
 }
 
 // src/lib/instructions/fast-forward-memory.ts
-import { mkdir as mkdir2, readFile as readFile4, rename as rename2, rm, writeFile } from "fs/promises";
-import path18 from "path";
+import { mkdir as mkdir3, readFile as readFile4, rename as rename2, rm as rm2, writeFile } from "fs/promises";
+import path19 from "path";
 function noticeFile(commonDir2) {
-  return path18.join(commonDir2, "fabric", "ff-notice.json");
+  return path19.join(commonDir2, "fabric", "ff-notice.json");
 }
 function isRecord4(value) {
   if (typeof value !== "object" || value === null) {
@@ -12951,7 +13373,7 @@ async function isNewNotice(file, key) {
 }
 async function rememberNotice(file, key) {
   try {
-    await mkdir2(path18.dirname(file), { recursive: true });
+    await mkdir3(path19.dirname(file), { recursive: true });
     const temporary = `${file}.${process.pid}.tmp`;
     const record = { v: 1, ...key };
     await writeFile(temporary, `${JSON.stringify(record)}
@@ -12963,7 +13385,7 @@ async function rememberNotice(file, key) {
   }
 }
 async function forgetNotice(file) {
-  await rm(file, { force: true }).catch(() => void 0);
+  await rm2(file, { force: true }).catch(() => void 0);
 }
 
 // src/lib/instructions/hook-timing.ts
@@ -12975,11 +13397,11 @@ var hookTiming = {
 };
 
 // src/lib/instructions/hook-trace.ts
-import { mkdir as mkdir3, readFile as readFile5, rename as rename3, writeFile as writeFile2 } from "fs/promises";
-import path19 from "path";
+import { mkdir as mkdir4, readFile as readFile5, rename as rename3, writeFile as writeFile2 } from "fs/promises";
+import path20 from "path";
 var TRACE_LIMIT = 50;
 function traceFile(configDir) {
-  return path19.join(configDir, "traces", "instructions-hook.jsonl");
+  return path20.join(configDir, "traces", "instructions-hook.jsonl");
 }
 async function appendTrace(file, entry) {
   try {
@@ -12992,7 +13414,7 @@ async function appendTrace(file, entry) {
       }
     }).slice(-(TRACE_LIMIT - 1));
     kept.push(JSON.stringify(entry));
-    await mkdir3(path19.dirname(file), { recursive: true, mode: 448 });
+    await mkdir4(path20.dirname(file), { recursive: true, mode: 448 });
     const temporary = `${file}.${process.pid}.tmp`;
     await writeFile2(temporary, `${kept.join("\n")}
 `, { mode: 384 });
@@ -13006,7 +13428,7 @@ var MERGE_RESERVE_MS = 1500;
 var FF_LOCK_STALE_MS = 3e4;
 var show2 = (value, max = 200) => sanitizeDisplayText(value, max);
 async function samePath(a, b) {
-  const resolve = async (value) => realpath3(value).catch(() => path20.resolve(value));
+  const resolve = async (value) => realpath4(value).catch(() => path21.resolve(value));
   const [left, right] = await Promise.all([resolve(a), resolve(b)]);
   return process.platform === "win32" ? left.toLowerCase() === right.toLowerCase() : left === right;
 }
@@ -13110,6 +13532,10 @@ async function underLock(run3, first) {
       return fetched;
   }
   const tip = fetched.tip;
+  const afterFetch = await factsStillMatch(run3, facts, deadline);
+  if (afterFetch !== null) {
+    return afterFetch;
+  }
   if (tip === head) {
     return { outcome: { kind: "already-current" }, head };
   }
@@ -13124,6 +13550,13 @@ async function underLock(run3, first) {
   if (deadline - Date.now() < MERGE_RESERVE_MS) {
     return { outcome: { kind: "deadline" }, head };
   }
+  const beforeMerge = await factsStillMatch(run3, facts, deadline);
+  if (beforeMerge !== null) {
+    return beforeMerge;
+  }
+  if (deadline - Date.now() < MERGE_RESERVE_MS) {
+    return { outcome: { kind: "deadline" }, head };
+  }
   const merged = await fastForwardTo(root, tip, deadline);
   switch (merged.kind) {
     case "merged":
@@ -13157,6 +13590,26 @@ async function underLock(run3, first) {
       return merged;
   }
 }
+async function factsStillMatch(run3, expected, deadline) {
+  const facts = await readFacts(run3, deadline);
+  if (facts === null) {
+    return unanswered(deadline, expected.state.head);
+  }
+  const gate = fastForwardEligibility(facts);
+  if (!gate.eligible) {
+    return {
+      outcome: { kind: "not-safe", reason: gate.reason },
+      head: facts.state.head
+    };
+  }
+  if (facts.state.branch !== expected.state.branch || facts.state.head !== expected.state.head) {
+    return {
+      outcome: { kind: "not-safe", reason: "git-busy" },
+      head: facts.state.head
+    };
+  }
+  return null;
+}
 async function decide(run3) {
   const { classification, deadline, report } = run3;
   const root = classification.toplevel;
@@ -13179,11 +13632,11 @@ async function decide(run3) {
   if (common.kind !== "ok") {
     return unanswered(deadline, head);
   }
-  const directory = path20.join(common.value, "fabric");
+  const directory = path21.join(common.value, "fabric");
   try {
-    await mkdir4(directory, { recursive: true });
+    await mkdir5(directory, { recursive: true });
     return await withExclusiveLock(() => underLock(run3, facts), {
-      lockPath: path20.join(directory, "ff.lock"),
+      lockPath: path21.join(directory, "ff.lock"),
       staleMs: FF_LOCK_STALE_MS,
       waitMs: 0
     });
@@ -13191,7 +13644,10 @@ async function decide(run3) {
     if (error instanceof ExclusiveLockBusyError) {
       const now = await headSha(root, deadline);
       return {
-        outcome: { kind: "locked" },
+        outcome: error.abandoned ? {
+          kind: "abandoned-lock",
+          lockPath: path21.join(directory, "ff.lock")
+        } : { kind: "locked" },
         head: now.kind === "ok" ? now.value : head
       };
     }
@@ -13309,99 +13765,11 @@ async function runFastForward(run3) {
   return { outcome, stdout, stderr };
 }
 
-// src/lib/instructions/file-downloads.ts
-import { createHash as createHash9 } from "crypto";
-var PER_FILE_MAX_WRITES = 100;
-var URL_REQUEST_CHUNK = 200;
-var DOWNLOAD_CONCURRENCY = 8;
-var PublishedChangedError = class extends Error {
-  constructor() {
-    super("The published version changed while this command ran.");
-    this.name = "PublishedChangedError";
-  }
-};
-async function fetchFilesByUrl(options) {
-  const wanted = new Map(options.files.map((file) => [file.path, file]));
-  const urls = /* @__PURE__ */ new Map();
-  for (let i = 0; i < options.files.length; i += URL_REQUEST_CHUNK) {
-    const paths = options.files.slice(i, i + URL_REQUEST_CHUNK).map((file) => file.path);
-    let response;
-    try {
-      response = await options.client.instructions.createFileDownloadUrls(
-        options.projectId,
-        { digest: options.digest, paths },
-        { org: options.org }
-      );
-    } catch (error) {
-      if (error instanceof FabricError && error.status === 409 && error.code === "PUBLISHED_CHANGED") {
-        throw new PublishedChangedError();
-      }
-      throw error;
-    }
-    if (response.digest !== options.digest) {
-      throw new PublishedChangedError();
-    }
-    for (const file of response.files) {
-      if (!wanted.has(file.path) || urls.has(file.path)) {
-        throw new Error(
-          "The server returned a file that was not asked for. Nothing was written."
-        );
-      }
-      urls.set(file.path, file.url);
-    }
-  }
-  if (urls.size !== wanted.size) {
-    throw new Error(
-      `The server returned ${urls.size} of ${wanted.size} requested files. Nothing was written.`
-    );
-  }
-  const contents = /* @__PURE__ */ new Map();
-  const queue = options.files.values();
-  const failures = [];
-  const worker = async () => {
-    while (failures.length === 0) {
-      const next = queue.next();
-      if (next.done) {
-        return;
-      }
-      const file = next.value;
-      try {
-        const bytes = await fetchBundle(urls.get(file.path) ?? "", {
-          timeoutMs: options.timeoutMs,
-          // The manifest's size, not the response's: the read is
-          // abandoned the moment it passes what the plan expects.
-          maxBytes: file.size,
-          signal: options.signal,
-          fetchImpl: options.fetchImpl
-        });
-        if (bytes.length !== file.size || createHash9("sha256").update(bytes).digest("hex") !== file.sha256) {
-          throw new Error(
-            `A downloaded file does not match the manifest (${file.path}). Nothing was written.`
-          );
-        }
-        contents.set(file.path, bytes);
-      } catch (error) {
-        failures.push(error);
-      }
-    }
-  };
-  await Promise.all(
-    Array.from(
-      { length: Math.min(DOWNLOAD_CONCURRENCY, options.files.length) },
-      () => worker()
-    )
-  );
-  if (failures.length > 0) {
-    throw failures[0];
-  }
-  return contents;
-}
-
 // src/lib/instructions/git-exclude.ts
-import { appendFile, lstat as lstat6, mkdir as mkdir5, readFile as readFile6 } from "fs/promises";
-import path21 from "path";
+import { appendFile, lstat as lstat6, mkdir as mkdir6, readFile as readFile6 } from "fs/promises";
+import path22 from "path";
 function relativeToTopLevel(toplevel, directory, file) {
-  return path21.relative(toplevel, path21.join(directory, file)).split(path21.sep).join("/");
+  return path22.relative(toplevel, path22.join(directory, file)).split(path22.sep).join("/");
 }
 function isLiteralEntry(entry) {
   return !/[\n\r*?[\]\\!]/.test(entry) && !entry.startsWith("#");
@@ -13435,7 +13803,7 @@ async function excludeLocalFiles(input) {
     if (file.kind !== "ok") {
       return { kind: "failed", entries: missing };
     }
-    await mkdir5(path21.dirname(file.value), { recursive: true });
+    await mkdir6(path22.dirname(file.value), { recursive: true });
     const existing = await lstat6(file.value).catch((error) => {
       if (error.code === "ENOENT") {
         return null;
@@ -13461,8 +13829,8 @@ async function excludeLocalFiles(input) {
 }
 
 // src/lib/instructions/hook-launcher.ts
-import { mkdir as mkdir6, readFile as readFile7, rename as rename4, rm as rm2, writeFile as writeFile3 } from "fs/promises";
-import path22 from "path";
+import { mkdir as mkdir7, readFile as readFile7, rename as rename4, rm as rm3, writeFile as writeFile3 } from "fs/promises";
+import path23 from "path";
 var NOT_ON_PATH_WARNING = "`fabric` is not on this machine's PATH, so this session hook will not run. Run the setup line from the project's Connect dialog instead: it keeps a copy of this deployment's CLI where the hook finds it.";
 var COPY_IN_USE_WARNING = "The CLI copy the session hook runs is in use and could not be replaced, so the earlier copy was kept. Run this again when no coding session is starting.";
 var UNQUOTABLE_PATH = "The CLI's config folder has characters in its path that cannot be written safely into a hook command. Set XDG_CONFIG_HOME (APPDATA on Windows) to a plain path and run this again.";
@@ -13470,7 +13838,7 @@ function deploymentFolder(origin) {
   return origin.replace(/^(https?):\/\//, "$1-").replace(/[^A-Za-z0-9.-]+/g, "-");
 }
 function bundleCopyPath(configDirectory, origin) {
-  return path22.join(
+  return path23.join(
     configDirectory,
     "cli",
     deploymentFolder(origin),
@@ -13478,18 +13846,18 @@ function bundleCopyPath(configDirectory, origin) {
   );
 }
 function samePath2(a, b) {
-  const [left, right] = [path22.resolve(a), path22.resolve(b)];
+  const [left, right] = [path23.resolve(a), path23.resolve(b)];
   return process.platform === "win32" ? left.toLowerCase() === right.toLowerCase() : left === right;
 }
 async function writeCopy(bytes, destination) {
-  await mkdir6(path22.dirname(destination), { recursive: true });
+  await mkdir7(path23.dirname(destination), { recursive: true });
   const temporary = `${destination}.${process.pid}.tmp`;
   await writeFile3(temporary, bytes, { mode: 420 });
   try {
     await rename4(temporary, destination);
     return true;
   } catch (error) {
-    await rm2(temporary, { force: true });
+    await rm3(temporary, { force: true });
     const existing = await readFile7(destination).catch(() => null);
     if (existing === null) {
       throw error;
@@ -13564,10 +13932,10 @@ async function installHooks(input) {
 }
 
 // src/lib/instructions/lesson-prompt.ts
-import { createHash as createHash10 } from "crypto";
+import { createHash as createHash11 } from "crypto";
 import { createReadStream } from "fs";
-import { mkdir as mkdir7, readdir as readdir3, stat as stat5, unlink as unlink2, writeFile as writeFile4 } from "fs/promises";
-import path23 from "path";
+import { mkdir as mkdir8, readdir as readdir2, stat as stat5, unlink as unlink2, writeFile as writeFile4 } from "fs/promises";
+import path24 from "path";
 import { createInterface } from "readline";
 function parseStopHookInput(text3) {
   let parsed;
@@ -13649,7 +14017,7 @@ function countEditingToolUsesInLine(line2) {
   return count;
 }
 function markerKey(sessionId, projectId) {
-  return createHash10("sha256").update(`${sessionId}:${projectId}`).digest("hex");
+  return createHash11("sha256").update(`${sessionId}:${projectId}`).digest("hex");
 }
 function lessonPromptReason(projectId) {
   return `Fabric lesson check for project ${projectId}: before you finish, ask the developer once, in one short question: was there a mistake in this session the team should not repeat? If they name one, draft it as a lesson (a title, what happened, why it was a mistake, what to do instead, and the instruction files it relates to) and show them the draft. Only after they confirm, call the MCP tool fabric_add_instruction_lesson with projectId "${projectId}", title, body and relatedPaths; it opens a proposal a person approves, so report it as a suggestion awaiting review. If they say no, or the tool is not available, say so in one line and stop. Never call the tool without an explicit yes.`;
@@ -13658,14 +14026,14 @@ var MARKER_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
 async function pruneOldMarkers(markerDir, now) {
   let entries;
   try {
-    entries = await readdir3(markerDir);
+    entries = await readdir2(markerDir);
   } catch {
     return;
   }
   const cutoff = now.getTime() - MARKER_MAX_AGE_MS;
   await Promise.all(
     entries.map(async (name) => {
-      const entryPath = path23.join(markerDir, name);
+      const entryPath = path24.join(markerDir, name);
       try {
         const stats = await stat5(entryPath);
         if (stats.mtimeMs < cutoff) {
@@ -13716,7 +14084,7 @@ async function runLessonPromptInner(input) {
     return { output: null, why: "stop-hook-active" };
   }
   try {
-    await mkdir7(input.markerDir, { recursive: true });
+    await mkdir8(input.markerDir, { recursive: true });
   } catch (error) {
     debugLog(`marker directory unavailable: ${describeError(error)}`);
     return { output: null, why: "marker-unavailable" };
@@ -13725,7 +14093,7 @@ async function runLessonPromptInner(input) {
     debugLog(`marker prune failed: ${describeError(error)}`);
   });
   const key = markerKey(parsedInput.sessionId, projectId);
-  const markerPath = path23.join(input.markerDir, key);
+  const markerPath = path24.join(input.markerDir, key);
   if (await markerExists(markerPath)) {
     return { output: null, why: "already-asked" };
   }
@@ -13994,8 +14362,9 @@ function splitMessage(message) {
 }
 
 // src/lib/instructions/push.ts
-import { createHash as createHash11 } from "crypto";
+import { createHash as createHash12 } from "crypto";
 var MAX_PUSH_CHANGES = 50;
+var MAX_INLINE_PUSH_BYTES = 2 * 1024 * 1024;
 function assertPushablePath(candidate, source) {
   const check = checkRelativePath(candidate);
   if (!check.ok) {
@@ -14025,7 +14394,7 @@ function encodeContent(bytes) {
   };
 }
 function sha256Of(bytes) {
-  return createHash11("sha256").update(bytes).digest("hex");
+  return createHash12("sha256").update(bytes).digest("hex");
 }
 function refuseStaleLedger(detail) {
   throw new Error(
@@ -14036,16 +14405,16 @@ function assertLockMatchesManifest(lock, manifest) {
   const published = new Map(
     manifest.map((entry) => [entry.path, entry.sha256])
   );
-  for (const [path28, entry] of Object.entries(lock.files)) {
-    const expected = published.get(path28);
+  for (const [path29, entry] of Object.entries(lock.files)) {
+    const expected = published.get(path29);
     if (expected === void 0) {
       refuseStaleLedger(
-        `it lists ${path28}, which version ${lock.snapshotVersion} does not contain`
+        `it lists ${path29}, which version ${lock.snapshotVersion} does not contain`
       );
     }
     if (expected !== entry.sha256) {
       refuseStaleLedger(
-        `its record of ${path28} is not the published file`
+        `its record of ${path29} is not the published file`
       );
     }
   }
@@ -14100,46 +14469,80 @@ async function computePushPlan(input) {
     );
   }
   const entries = [];
-  const changes = [];
   const unchanged = [];
   for (const lockedPath of lockedPaths.sort()) {
-    const read = await readFileSafely(root, lockedPath);
-    if (read === null) {
+    const fingerprint = await fingerprintFileSafely(root, lockedPath);
+    if (fingerprint === null) {
       entries.push({ path: lockedPath, action: "delete" });
-      changes.push({ op: "delete", path: lockedPath });
       continue;
     }
-    const actual = sha256Of(read.bytes);
-    if (actual === lock.files[lockedPath]?.sha256) {
+    if (fingerprint.sha256 === lock.files[lockedPath]?.sha256) {
       unchanged.push(lockedPath);
       continue;
     }
-    const encoded = encodeContent(read.bytes);
     entries.push({
       path: lockedPath,
       action: "put",
-      size: read.bytes.length,
-      sha256: actual
+      size: fingerprint.size,
+      sha256: fingerprint.sha256
     });
-    changes.push({ op: "put", path: lockedPath, ...encoded });
   }
   for (const newPath of added.sort()) {
-    const read = await readFileSafely(root, newPath);
-    if (read === null) {
+    const fingerprint = await fingerprintFileSafely(root, newPath);
+    if (fingerprint === null) {
       throw new Error(
         `Refusing to push: there is no file at ${newPath}.`
       );
     }
-    const encoded = encodeContent(read.bytes);
     entries.push({
       path: newPath,
       action: "put",
-      size: read.bytes.length,
-      sha256: sha256Of(read.bytes)
+      size: fingerprint.size,
+      sha256: fingerprint.sha256
+    });
+  }
+  return { entries, unchanged };
+}
+function pushContentBytes(entries) {
+  return entries.reduce(
+    (total, entry) => total + (entry.action === "put" ? entry.size : 0),
+    0
+  );
+}
+async function materializePushChanges(input) {
+  if (input.entries.length > MAX_PUSH_CHANGES) {
+    throw new Error(`Too many changes to push (${input.entries.length}).`);
+  }
+  if (pushContentBytes(input.entries) > MAX_INLINE_PUSH_BYTES) {
+    throw new Error("The selected changes are too large to send inline.");
+  }
+  const changes = [];
+  for (const entry of input.entries) {
+    if (entry.action === "delete") {
+      changes.push({ op: "delete", path: entry.path });
+      continue;
+    }
+    const read = await readFileSafely(input.root, entry.path, {
+      maxBytes: MAX_INLINE_PUSH_BYTES
+    });
+    if (read === null) {
+      throw new Error(
+        `Refusing to push: ${entry.path} disappeared after planning. Run \`${fabricCommand("instructions push")}\` again.`
+      );
+    }
+    const sha256 = sha256Of(read.bytes);
+    if (read.bytes.length !== entry.size || sha256 !== entry.sha256) {
+      throw new Error(
+        `Refusing to push: ${entry.path} changed after planning. Run \`${fabricCommand("instructions push")}\` again.`
+      );
+    }
+    changes.push({
+      op: "put",
+      path: entry.path,
+      ...encodeContent(read.bytes)
     });
-    changes.push({ op: "put", path: newPath, ...encoded });
   }
-  return { entries, changes, unchanged };
+  return changes;
 }
 var LIVE_PULL_REQUEST_STATES = /* @__PURE__ */ new Set([
   "QUEUED",
@@ -14183,9 +14586,6 @@ function setAsideProposed(plan, proposals, baseSnapshotId) {
   return {
     plan: {
       entries: plan.entries.filter((entry) => !setAside.has(entry.path)),
-      changes: plan.changes.filter(
-        (change) => !setAside.has(change.path)
-      ),
       unchanged: plan.unchanged
     },
     alreadyProposed
@@ -14193,7 +14593,7 @@ function setAsideProposed(plan, proposals, baseSnapshotId) {
 }
 
 // src/lib/instructions/resolve-project.ts
-import path24 from "path";
+import path25 from "path";
 var MAX_CANDIDATES = 8;
 var MAX_CANDIDATE_CHARS = 512;
 var MAX_LABEL_CHARS = 80;
@@ -14262,7 +14662,7 @@ async function resolveProjectFromCheckout(input) {
   for (const match of matches2) {
     if (await sameDirectory(
       destination,
-      path24.join(toplevel, match.rootPath)
+      path25.join(toplevel, match.rootPath)
     )) {
       here.push(match);
     }
@@ -14285,9 +14685,9 @@ async function resolveProjectFromCheckout(input) {
 }
 
 // src/lib/instructions/self-update.ts
-import { createHash as createHash12 } from "crypto";
-import { mkdir as mkdir8, readFile as readFile8, realpath as realpath4, writeFile as writeFile5 } from "fs/promises";
-import path25 from "path";
+import { createHash as createHash13 } from "crypto";
+import { mkdir as mkdir9, readFile as readFile8, realpath as realpath5, writeFile as writeFile5 } from "fs/promises";
+import path26 from "path";
 
 // src/lib/instructions/npm-tarball.ts
 import { gunzipSync } from "zlib";
@@ -14421,11 +14821,11 @@ function reasonToStayQuiet(input, now) {
   return null;
 }
 async function isKeptCopy(script, copy) {
-  const actual = await realpath4(copy).catch(() => null);
+  const actual = await realpath5(copy).catch(() => null);
   if (actual === null) {
     return false;
   }
-  const running = await realpath4(script).catch(() => path25.resolve(script));
+  const running = await realpath5(script).catch(() => path26.resolve(script));
   return samePath2(running, actual);
 }
 async function readState2(file) {
@@ -14438,7 +14838,7 @@ async function readState2(file) {
 }
 async function writeState(file, state) {
   try {
-    await mkdir8(path25.dirname(file), { recursive: true });
+    await mkdir9(path26.dirname(file), { recursive: true });
     await writeFile5(file, `${JSON.stringify(state)}
 `);
     return true;
@@ -14557,7 +14957,7 @@ async function attempt({
     signal,
     fetchImpl
   );
-  const digest = `sha512-${createHash12("sha512").update(tarball).digest("base64")}`;
+  const digest = `sha512-${createHash13("sha512").update(tarball).digest("base64")}`;
   if (digest !== served.integrity) {
     throw new SelfUpdateFailure(
       "the download does not match the integrity hash the deployment published"
@@ -14588,7 +14988,7 @@ async function refreshKeptCopy(input, deps = {}) {
   if (!await isKeptCopy(input.script, copy)) {
     return skipped2("not-a-kept-copy");
   }
-  const stateFile = path25.join(path25.dirname(copy), STATE_FILE);
+  const stateFile = path26.join(path26.dirname(copy), STATE_FILE);
   const previous = await readState2(stateFile);
   if (previous !== null && askedRecently(previous, now())) {
     return skipped2("checked-recently");
@@ -14646,7 +15046,7 @@ function selfUpdateLine(outcome) {
 
 // src/lib/instructions/tools.ts
 import { stat as stat6 } from "fs/promises";
-import path26 from "path";
+import path27 from "path";
 var TOOLS = [
   { tool: "claude-code", directory: ".claude", command: "claude" },
   { tool: "codex", directory: ".codex", command: "codex" }
@@ -14657,7 +15057,7 @@ async function isDirectory(target) {
 async function detectTools(input) {
   const present = [];
   for (const facts of TOOLS) {
-    const found = await isDirectory(path26.join(input.root, facts.directory)) || input.home !== null && await isDirectory(path26.join(input.home, facts.directory)) || await isOnPath(facts.command, input.lookup);
+    const found = await isDirectory(path27.join(input.root, facts.directory)) || input.home !== null && await isDirectory(path27.join(input.home, facts.directory)) || await isOnPath(facts.command, input.lookup);
     if (found) {
       present.push(facts.tool);
     }
@@ -14875,7 +15275,7 @@ async function refreshKeptCopyAfterHook(opts, deadlineAt) {
   const outcome = await refreshKeptCopy({
     origin,
     script: bundleScriptPath(),
-    configDirectory: path27.dirname(getConfigPath()),
+    configDirectory: path28.dirname(getConfigPath()),
     runningTarball: bundleTarballPath(),
     env: process.env,
     deadlineAt,
@@ -14935,7 +15335,7 @@ function gitDeadline() {
   return activeDeadlineAt === void 0 ? Date.now() + GIT_BUDGET_MS2 : activeDeadlineAt - hookTiming.gitMarginMs;
 }
 function destinationOf(opts) {
-  return path27.resolve(opts.dest ?? process.cwd());
+  return path28.resolve(opts.dest ?? process.cwd());
 }
 function instructionsClient(opts, timeoutMs, { neverRetry = false } = {}) {
   if (!getApiKey(deploymentOrigin(opts), opts.project)) {
@@ -15485,7 +15885,7 @@ async function syncOnce(opts) {
       projectId: opts.project,
       deadline: gitDeadline(),
       optedOut: opts.fastForward === false,
-      traceFile: traceFile(path27.dirname(getConfigPath()))
+      traceFile: traceFile(path28.dirname(getConfigPath()))
     }) : null;
     return {
       kind: "reported",
@@ -15557,42 +15957,67 @@ async function syncOnce(opts) {
     return { kind: "synced", outcome };
   }
   let contents = /* @__PURE__ */ new Map();
-  if (plan.writes.length > 0) {
-    let perFile = plan.writes.length <= PER_FILE_MAX_WRITES;
-    if (perFile) {
-      const byPath3 = new Map(
-        manifest.map((entry) => [entry.path, entry])
-      );
+  let staged = null;
+  let applied;
+  try {
+    for (let attempt2 = 0; plan.writes.length > 0 && attempt2 < 2; attempt2++) {
       try {
-        contents = await fetchFilesByUrl({
-          client,
-          projectId: opts.project,
-          org: orgSlugFor(opts),
-          digest: published.snapshot.digest,
-          files: plan.writes.map((entry) => ({
-            path: entry.path,
-            size: byPath3.get(entry.path)?.size ?? -1,
-            sha256: byPath3.get(entry.path)?.sha256 ?? ""
-          })),
-          timeoutMs: opts.hook ? hookDeadlineMs() : BUNDLE_TIMEOUT_MS,
-          signal: activeDeadline
-        });
+        const byPath3 = new Map(
+          manifest.map((entry) => [entry.path, entry])
+        );
+        const large = manifest.reduce((total, entry) => total + entry.size, 0) > IN_MEMORY_SNAPSHOT_BYTES;
+        if (large || attempt2 === 0 && plan.writes.length <= PER_FILE_MAX_WRITES) {
+          const options = {
+            client,
+            projectId: opts.project,
+            org: orgSlugFor(opts),
+            digest: published.snapshot.digest,
+            files: plan.writes.map((entry) => ({
+              path: entry.path,
+              size: byPath3.get(entry.path)?.size ?? -1,
+              sha256: entry.sha256 ?? ""
+            })),
+            timeoutMs: opts.hook ? hookDeadlineMs() : BUNDLE_TIMEOUT_MS,
+            signal: activeDeadline
+          };
+          if (large) {
+            staged = await stageFilesByUrl(options);
+            contents = staged;
+          } else contents = await fetchFilesByUrl(options);
+        } else {
+          const download2 = await downloadUrlClient(
+            opts
+          ).instructions.createDownloadUrl(opts.project, {
+            org: orgSlugFor(opts)
+          });
+          const archive = await fetchBundle(download2.url, {
+            timeoutMs: opts.hook ? hookDeadlineMs() : BUNDLE_TIMEOUT_MS,
+            maxBytes: maxArchiveBytes(manifest),
+            signal: activeDeadline
+          });
+          contents = extractBundle(
+            archive,
+            plan.writes.map((entry) => ({
+              path: entry.path,
+              size: byPath3.get(entry.path)?.size ?? -1
+            }))
+          );
+        }
+        break;
       } catch (error) {
-        if (!(error instanceof PublishedChangedError)) {
+        if (!(error instanceof PublishedChangedError) || attempt2 > 0)
           throw fixedFailure(error);
-        }
         published = await fetchPublished(
           client,
           opts,
           void 0,
           guard
         );
-        if (!published.published || !published.snapshot) {
+        if (!published.published || !published.snapshot)
           throw new CliFailure(
             "This project has no published coding instructions yet.",
             4
           );
-        }
         outcome.version = published.snapshot.version;
         outcome.digest = published.snapshot.digest;
         manifest = assertValidManifest({
@@ -15604,43 +16029,12 @@ async function syncOnce(opts) {
           { keepLocalEdits }
         );
         fillPlanPaths(outcome, plan);
-        perFile = false;
       }
     }
-    if (!perFile && plan.writes.length > 0) {
-      const org = orgSlugFor(opts);
-      let download2;
-      try {
-        download2 = await downloadUrlClient(
-          opts
-        ).instructions.createDownloadUrl(opts.project, { org });
-      } catch (error) {
-        throw fixedFailure(error);
-      }
-      const sizes = new Map(
-        manifest.map((entry) => [entry.path, entry.size])
-      );
-      const archive = await fetchBundle(download2.url, {
-        timeoutMs: opts.hook ? hookDeadlineMs() : BUNDLE_TIMEOUT_MS,
-        // Bounded by what this manifest says it holds, not by what the
-        // response claims. The manifest has already been checked against
-        // the published snapshot limits, so this is a number the client
-        // decided.
-        maxBytes: maxArchiveBytes(manifest),
-        // In hook mode the same clock that bounds the command bounds the
-        // download, rather than a second independent budget after it.
-        signal: activeDeadline
-      });
-      contents = extractBundle(
-        archive,
-        plan.writes.map((entry) => ({
-          path: entry.path,
-          size: sizes.get(entry.path) ?? -1
-        }))
-      );
-    }
+    applied = await applyPlan({ root, plan, contents, keepLocalEdits });
+  } finally {
+    await staged?.dispose();
   }
-  const applied = await applyPlan({ root, plan, contents, keepLocalEdits });
   outcome.removed = applied.deleted;
   if (applied.keptEdited.length > 0) {
     const late = new Set(applied.keptEdited);
@@ -15774,7 +16168,7 @@ async function runPush2(opts, format) {
     manifest: published.manifest ?? [],
     added: opts.add
   });
-  if (computed.changes.length === 0) {
+  if (computed.entries.length === 0) {
     throw new CliFailure(
       `Nothing to push: every file the last sync wrote still matches version ${lock.snapshotVersion}. Add a new file with --add <path> if you meant to suggest one.`,
       7
@@ -15805,9 +16199,15 @@ async function runPush2(opts, format) {
       );
     }
   }
-  if (plan.changes.length > MAX_PUSH_CHANGES) {
+  if (plan.entries.length > MAX_PUSH_CHANGES) {
     throw new CliFailure(
-      `Too many changes to push (${plan.changes.length} > ${MAX_PUSH_CHANGES}). A change set this large is a replacement rather than an edit \u2014 upload the folder from the project's Coding Instructions tab, which is also the only path that re-reads the project's exclusion rules.`,
+      `Too many changes to push (${plan.entries.length} > ${MAX_PUSH_CHANGES}). A change set this large is a replacement rather than an edit \u2014 upload the folder from the project's Coding Instructions tab, which is also the only path that re-reads the project's exclusion rules.`,
+      7
+    );
+  }
+  if (pushContentBytes(plan.entries) > MAX_INLINE_PUSH_BYTES) {
+    throw new CliFailure(
+      `The selected changes are too large to send inline (over ${MAX_INLINE_PUSH_BYTES} bytes of file content). Upload the folder from the project's Coding Instructions tab instead.`,
       7
     );
   }
@@ -15837,7 +16237,7 @@ async function runPush2(opts, format) {
     published: null,
     pullRequest: null
   };
-  if (plan.changes.length === 0 && opts.publish) {
+  if (plan.entries.length === 0 && opts.publish) {
     if (format === "json") {
       printOutput(outcome, { format: "json" });
     }
@@ -15852,17 +16252,26 @@ async function runPush2(opts, format) {
       sawBranchWithoutPullRequest = true;
     }
   };
-  if (!opts.dryRun && plan.changes.length > 0) {
+  if (!opts.dryRun && plan.entries.length > 0) {
+    let changes;
+    try {
+      changes = await materializePushChanges({
+        root,
+        entries: plan.entries
+      });
+    } catch (error) {
+      throw new CliFailure(describeError(error), 7);
+    }
     try {
       const submitted = opts.publish ? await client.instructions.publishChange(
         opts.project,
         lock.snapshotId,
-        plan.changes,
+        changes,
         { org: orgSlugFor(opts) }
       ) : await client.instructions.submitChange(
         opts.project,
         lock.snapshotId,
-        plan.changes,
+        changes,
         { org: orgSlugFor(opts), ...note ? { note } : {} }
       );
       outcome.snapshotId = submitted.snapshotId;
@@ -16214,7 +16623,7 @@ function reportAlreadyProposed(outcome) {
 var CLONE_TIMEOUT_MS = 5 * 6e4;
 async function isEmptyFolder(folder) {
   try {
-    return (await readdir4(folder)).length === 0;
+    return (await readdir3(folder)).length === 0;
   } catch (error) {
     return error.code === "ENOENT";
   }
@@ -16278,12 +16687,14 @@ async function runInit(opts, format) {
     destination = await resolveCloneFolder(destination, cloneFolder);
   }
   let existing = await resolveExistingRoot(destination);
+  let cloned = false;
+  const freshCloneDestination = cloneFolder !== void 0 && await isEmptyFolder(destination);
   await assertKeyOutside(existing);
   const client = instructionsClient(opts, SYNC_TIMEOUT_MS);
   const guard = new SourceGuard(
     destination,
     opts.remote,
-    cloneFolder !== void 0
+    freshCloneDestination
   );
   const published = await fetchPublished(client, opts, void 0, guard);
   const repository = published.repository ?? null;
@@ -16313,8 +16724,9 @@ async function runInit(opts, format) {
         destination,
         repository
       );
+      cloned = true;
       if (cloneFolder !== void 0 && checkout.class === "unmapped") {
-        destination = path27.join(checkout.toplevel, checkout.rootPath);
+        destination = path28.join(checkout.toplevel, checkout.rootPath);
         existing = await resolveExistingRoot(destination);
         checkout = await classifyCheckout({
           destination: existing,
@@ -16356,6 +16768,13 @@ async function runInit(opts, format) {
     }
   }
   const matching = checkout?.class === "matching" ? checkout : null;
+  const interrupted = matching === null ? null : await checkoutAppearsIncomplete(
+    matching.toplevel,
+    gitDeadline()
+  );
+  if (interrupted?.kind === "ok" && interrupted.value) {
+    throw outcomeFailure("clone-checkout-needs-repair", {});
+  }
   if (matching === null) {
     await readLockForProject2(existing, opts.project);
   }
@@ -16374,6 +16793,32 @@ async function runInit(opts, format) {
   if (opts.lessons && !tools.tools.includes("claude-code")) {
     throw outcomeFailure("lessons-need-claude", {});
   }
+  if (matching !== null) {
+    const prefix = path28.relative(matching.toplevel, root);
+    const relativeSetupPaths = [
+      ...tools.tools.map(
+        (tool) => path28.join(prefix, hookPathFor(tool)).replaceAll(path28.sep, "/")
+      ),
+      path28.join(prefix, LOCK_DIRECTORY, LOCK_FILENAME).replaceAll(path28.sep, "/")
+    ];
+    const tracked = await trackedPaths(
+      matching.toplevel,
+      relativeSetupPaths,
+      gitDeadline()
+    );
+    if (tracked.kind !== "ok") {
+      throw new CliFailure(
+        "Fabric could not verify whether its local setup files are tracked by Git, so it did not modify them. Check git status and run init again.",
+        7
+      );
+    }
+    if (tracked.value.length > 0) {
+      throw new CliFailure(
+        `Fabric left this checkout unchanged because Git tracks setup file${tracked.value.length === 1 ? "" : "s"}: ${tracked.value.join(", ")}. Keep ${tracked.value.length === 1 ? "it" : "them"} under the repository's normal setup process, or configure Fabric's hook and agent integration manually outside tracked paths.`,
+        7
+      );
+    }
+  }
   let outcome = null;
   if (checkout === null && published.published) {
     const synced = await syncOnce({ ...opts, hook: false, guard });
@@ -16389,7 +16834,7 @@ async function runInit(opts, format) {
   const applies = opts.reportOnly ? false : matching !== null ? true : Boolean(opts.apply);
   const launcher = await resolveHookLauncher({
     origin: deploymentOrigin(opts),
-    configDirectory: path27.dirname(getConfigPath()),
+    configDirectory: path28.dirname(getConfigPath()),
     lookup: { env: machine.env(), platform: machine.platform() },
     bundle: isServedBundle() ? { scriptPath: bundleScriptPath() } : null
   });
@@ -16427,7 +16872,8 @@ async function runInit(opts, format) {
     deadline: gitDeadline()
   });
   const lockRemoved = matching === null ? false : await dropOwnLock(root, opts.project);
-  const mcp = opts.mcp === false || !tools.detected && explicitTool === void 0 ? [] : await registerAgentMcp({
+  const mcpRequested = opts.mcp !== false && (tools.detected || explicitTool !== void 0);
+  const mcp = !mcpRequested ? [] : await registerAgentMcp({
     tools: tools.tools,
     projectId: opts.project,
     origin: deploymentOrigin(opts),
@@ -16443,6 +16889,8 @@ async function runInit(opts, format) {
     }),
     interactive: format !== "json" && canPrompt() && process.stdout.isTTY === true && !runningInCi()
   });
+  const mcpComplete = !mcpRequested || mcpRegistrationComplete(mcp);
+  const mcpAuthPending = mcpAuthenticationPending(mcp);
   const first = hooks[0];
   if (format === "json") {
     printOutput(
@@ -16461,6 +16909,9 @@ async function runInit(opts, format) {
           replacedHooks: hook.replacedCount
         })),
         lessonsHook: Boolean(opts.lessons),
+        mcpRequested,
+        mcpComplete,
+        mcpAuthenticationPending: mcpAuthPending,
         mcp: mcp.map((result) => ({
           tool: result.tool,
           name: result.name,
@@ -16477,6 +16928,12 @@ async function runInit(opts, format) {
       },
       { format: "json" }
     );
+    if (!mcpComplete) {
+      throw new CliFailure(
+        "Coding tool setup is incomplete: the Fabric MCP server was not registered for every selected tool. Complete the action shown above, then run init again.",
+        7
+      );
+    }
     return;
   }
   for (const hook of hooks) {
@@ -16512,12 +16969,17 @@ async function runInit(opts, format) {
   for (const mcpLine of agentMcpLines(mcp)) {
     line(mcpLine);
   }
-  if (cloneFolder !== void 0) {
+  if (mcpAuthPending) {
+    line(
+      "The Fabric MCP server is registered, but its coding-tool sign-in is still pending."
+    );
+  }
+  if (cloneFolder !== void 0 && cloned) {
     line(
       outcomeLine("cloned-into", {
         where: folderForCommand(
           opts.dest,
-          path27.relative(
+          path28.relative(
             await resolveExistingRoot(destinationOf(opts)),
             root
           )
@@ -16525,6 +16987,15 @@ async function runInit(opts, format) {
       })
     );
   }
+  if (!mcpComplete) {
+    line(
+      "The session hook was set up, but the Fabric MCP server was not registered for every selected tool."
+    );
+    throw new CliFailure(
+      "Coding tool setup is incomplete: the Fabric MCP server was not registered for every selected tool. Complete the action shown above, then run init again.",
+      7
+    );
+  }
   line(
     outcomeLine("set-up", {
       repo: matching !== null && repository !== null ? repositoryName(repository) : null,
@@ -16554,8 +17025,8 @@ async function runLessonPromptCommand(opts) {
     stdinText = await readAllStdin(process.stdin);
   } catch {
   }
-  const markerDir = path27.join(
-    path27.dirname(getConfigPath()),
+  const markerDir = path28.join(
+    path28.dirname(getConfigPath()),
     "lesson-prompts"
   );
   const result = await runLessonPrompt({