@fabricorg/cli 0.7.0 → 0.7.1

package/dist/fabric.js

@@ -6,7 +6,7 @@ import { Command as Command23 } from "commander";
 // package.json
 var package_default = {
   name: "@fabricorg/cli",
-  version: "0.7.0",
+  version: "0.7.1",
   description: "CLI for the Fabric AI platform",
   keywords: [
     "fabric",
@@ -135,6 +135,57 @@ var DEFAULT_RETRY = {
 };
 var RETRYABLE_STATUS = /* @__PURE__ */ new Set([408, 425, 429, 500, 502, 503, 504]);
 var MUTATING_METHODS = /* @__PURE__ */ new Set(["POST", "PATCH", "PUT", "DELETE"]);
+var RateLimitDelayError = class extends FabricError {
+  constructor(message, delayMs) {
+    super(message, 429);
+    this.delayMs = delayMs;
+  }
+};
+function retryAfterMs(value) {
+  if (value === null) {
+    return void 0;
+  }
+  if (/^\d+$/.test(value)) {
+    return Number(value) * 1e3;
+  }
+  const date = Date.parse(value);
+  return Number.isFinite(date) ? Math.max(0, date - Date.now()) : void 0;
+}
+async function boundedJson(res, maxBytes) {
+  const reader = res.body?.getReader();
+  if (!reader) {
+    throw new FabricError("Empty repository response", res.status);
+  }
+  const chunks = [];
+  let length = 0;
+  try {
+    for (; ; ) {
+      const next = await reader.read();
+      if (next.done) {
+        break;
+      }
+      length += next.value.byteLength;
+      if (length > maxBytes) {
+        await reader.cancel();
+        throw new FabricError(
+          "Repository response is too large",
+          res.status,
+          "RESPONSE_TOO_LARGE"
+        );
+      }
+      chunks.push(next.value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(length);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+}
 function env(name) {
   if (typeof process === "undefined" || !process.env) {
     return void 0;
@@ -235,10 +286,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(path38) {
-    const url = `${this.baseUrl}/api/v1${path38}`;
-    const hasOrg = /[?&]org=/.test(path38);
-    const hasPersonal = /[?&]personal=/.test(path38);
+  buildUrl(path42) {
+    const url = `${this.baseUrl}/api/v1${path42}`;
+    const hasOrg = /[?&]org=/.test(path42);
+    const hasPersonal = /[?&]personal=/.test(path42);
     if (hasOrg || hasPersonal) {
       return url;
     }
@@ -251,21 +302,22 @@ var FabricHttpClient = class _FabricHttpClient {
     if (additions.length === 0) {
       return url;
     }
-    const sep = path38.includes("?") ? "&" : "?";
+    const sep = path42.includes("?") ? "&" : "?";
     return `${url}${sep}${additions.join("&")}`;
   }
-  async request(method, path38, options = {}) {
-    const url = this.buildUrl(path38);
+  async request(method, path42, options = {}) {
+    const url = this.buildUrl(path42);
     const isMutating = MUTATING_METHODS.has(method);
     const idempotencyKey = options.idempotencyKey ?? (isMutating ? randomId() : void 0);
-    const maxAttempts = (options.retry ?? this.retry).maxRetries + 1;
+    const retries = (options.retry ?? this.retry).maxRetries;
+    const maxAttempts = (options.boundedRead ? Math.min(retries, 2) : retries) + 1;
     let lastError;
     for (let attempt2 = 1; attempt2 <= maxAttempts; attempt2++) {
       if (options.signal?.aborted) {
         throw options.signal.reason;
       }
       const start = Date.now();
-      this.emit({ kind: "request", method, path: path38, attempt: attempt2 });
+      this.emit({ kind: "request", method, path: path42, attempt: attempt2 });
       try {
         const result = await this.executeOnce(
           method,
@@ -276,7 +328,7 @@ var FabricHttpClient = class _FabricHttpClient {
         this.emit({
           kind: "response",
           method,
-          path: path38,
+          path: path42,
           attempt: attempt2,
           status: 200,
           durationMs: Date.now() - start
@@ -285,11 +337,11 @@ var FabricHttpClient = class _FabricHttpClient {
       } catch (err) {
         lastError = err;
         const status2 = err instanceof FabricError ? err.status : void 0;
-        const retriable = attempt2 < maxAttempts && this.shouldRetry(method, err);
+        const retriable = attempt2 < maxAttempts && this.shouldRetry(method, err) && !(err instanceof RateLimitDelayError && err.delayMs > 6e4);
         this.emit({
           kind: retriable ? "retry" : "error",
           method,
-          path: path38,
+          path: path42,
           attempt: attempt2,
           status: status2,
           durationMs: Date.now() - start,
@@ -301,7 +353,7 @@ var FabricHttpClient = class _FabricHttpClient {
         if (!retriable) {
           throw err;
         }
-        const delay2 = Math.min(
+        const delay2 = err instanceof RateLimitDelayError ? err.delayMs : Math.min(
           this.retry.initialDelayMs * this.retry.multiplier ** (attempt2 - 1),
           this.retry.maxDelayMs
         );
@@ -354,22 +406,51 @@ var FabricHttpClient = class _FabricHttpClient {
         "NETWORK_ERROR"
       );
     }
-    clearTimeout(timeoutHandle);
+    if (!options.boundedRead) {
+      clearTimeout(timeoutHandle);
+    }
     const upgradeNotice = res.headers?.get("X-Fabric-Cli-Upgrade");
     if (upgradeNotice) {
       this.notifyUpgrade(upgradeNotice);
     }
+    if (options.boundedRead && res.status === 429) {
+      try {
+        await res.body?.cancel();
+      } finally {
+        clearTimeout(timeoutHandle);
+      }
+      options.signal?.throwIfAborted();
+      throw new RateLimitDelayError(
+        "Too many requests. Wait a minute and try again.",
+        Math.max(
+          1e3,
+          retryAfterMs(res.headers.get("Retry-After")) ?? 6e4
+        )
+      );
+    }
     let json2;
     try {
-      json2 = await res.json();
-    } catch {
+      json2 = options.boundedRead ? await boundedJson(res, options.boundedRead.maxResponseBytes) : await res.json();
+    } catch (error) {
       if (options.signal?.aborted) {
         throw options.signal.reason;
       }
+      if (options.boundedRead && controller.signal.aborted) {
+        throw new FabricError(
+          `Request timed out after ${this.timeoutMs}ms`,
+          0,
+          "TIMEOUT"
+        );
+      }
+      if (options.boundedRead && error instanceof FabricError) {
+        throw error;
+      }
       throw new FabricError(
         `Unexpected response from server (status ${res.status})`,
         res.status
       );
+    } finally {
+      clearTimeout(timeoutHandle);
     }
     if (!res.ok) {
       const body = json2;
@@ -433,28 +514,28 @@ var FabricHttpClient = class _FabricHttpClient {
     } catch {
     }
   }
-  get(path38, options = {}) {
+  get(path42, options = {}) {
     return this.request(
       "GET",
-      path38,
+      path42,
       options.signal ? { signal: options.signal } : {}
     );
   }
-  post(path38, body, options = {}) {
-    return this.request("POST", path38, {
+  post(path42, body, options = {}) {
+    return this.request("POST", path42, {
       body,
       idempotencyKey: options.idempotencyKey,
       retry: options.retry
     });
   }
-  patch(path38, body, options = {}) {
-    return this.request("PATCH", path38, {
+  patch(path42, body, options = {}) {
+    return this.request("PATCH", path42, {
       body,
       idempotencyKey: options.idempotencyKey
     });
   }
-  put(path38, body, options = {}) {
-    return this.request("PUT", path38, {
+  put(path42, body, options = {}) {
+    return this.request("PUT", path42, {
       body,
       idempotencyKey: options.idempotencyKey,
       retry: options.retry
@@ -465,8 +546,8 @@ var FabricHttpClient = class _FabricHttpClient {
    * delete names the path and the version in its body). Without `body`,
    * nothing is sent, as before.
    */
-  delete(path38, body, options = {}) {
-    return this.request("DELETE", path38, {
+  delete(path42, body, options = {}) {
+    return this.request("DELETE", path42, {
       body,
       idempotencyKey: options.idempotencyKey
     });
@@ -830,6 +911,16 @@ function buildQuery2(opts) {
   return s ? `?${s}` : "";
 }
 
+// ../sdk/src/resources/instruction-repository-files.ts
+function readPinnedRepositoryFiles(http, url, input, signal) {
+  const deadline = AbortSignal.timeout(12e4);
+  return http.request("POST", url, {
+    body: input,
+    signal: signal ? AbortSignal.any([signal, deadline]) : deadline,
+    boundedRead: { maxResponseBytes: 4 * 1024 * 1024 }
+  });
+}
+
 // ../sdk/src/resources/instructions.ts
 var InstructionsResource = class {
   constructor(http) {
@@ -862,9 +953,19 @@ var InstructionsResource = class {
    * commit pin; repeat calls must carry that pin so a moving branch cannot
    * mix tree metadata with later file bytes.
    */
-  listRepositoryFiles(projectId, options = {}) {
+  listRepositoryFiles(projectId, options = {}, request2 = {}) {
     return this.http.get(
-      `/projects/${encodeURIComponent(projectId)}/instructions/repository/files${buildQuery3(options)}`
+      `/projects/${encodeURIComponent(projectId)}/instructions/repository/files${buildQuery3(options)}`,
+      request2
+    );
+  }
+  /** Read-only POST, with at most two retries and a two-minute total budget. */
+  readRepositoryFiles(projectId, input, options = {}) {
+    return readPinnedRepositoryFiles(
+      this.http,
+      `/projects/${encodeURIComponent(projectId)}/instructions/repository/files/read${buildQuery3({ org: options.org })}`,
+      input,
+      options.signal
     );
   }
   /** Read one text file from an already pinned direct repository commit. */
@@ -1091,14 +1192,14 @@ function buildQuery3(opts) {
 
 // ../sdk/src/resources/integrations.ts
 var RESOURCE_BUILTINS = /* @__PURE__ */ new Set(["list", "constructor", "then"]);
-function makeDotPath(http, slug, path38) {
-  const fn = (args) => http.post(`/integrations/${slug}/${path38.join(".")}`, args ?? {});
+function makeDotPath(http, slug, path42) {
+  const fn = (args) => http.post(`/integrations/${slug}/${path42.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, [...path38, prop]);
+      return makeDotPath(http, slug, [...path42, prop]);
     }
   });
 }
@@ -1784,6 +1885,102 @@ function buildQuery8(opts) {
   return s ? `?${s}` : "";
 }
 
+// ../sdk/src/plugin-mapping.ts
+var ALWAYS_ON_FILES = ["CLAUDE.md", "AGENTS.md"];
+function segmentsBelowRoot(instructionPath) {
+  const segments = instructionPath.split("/");
+  return segments[0]?.toLowerCase() === ".claude" ? segments.slice(1) : segments;
+}
+function isMarkdown(name) {
+  return name?.toLowerCase().endsWith(".md") ?? false;
+}
+function pluginPathFor(instructionPath) {
+  const rest = segmentsBelowRoot(instructionPath);
+  const folder = rest[0]?.toLowerCase();
+  if (rest.length < 2) {
+    return null;
+  }
+  const below = rest.slice(1);
+  switch (folder) {
+    case "skills":
+      return below.length >= 2 ? `skills/${below.join("/")}` : null;
+    case "agents":
+      return below.length === 1 && isMarkdown(below[0]) ? `agents/${below[0]}` : null;
+    case "commands":
+      return `commands/${below.join("/")}`;
+    default:
+      return null;
+  }
+}
+function projectRulePathFor(instructionPath) {
+  const rest = segmentsBelowRoot(instructionPath);
+  if (rest.length < 2 || rest[0]?.toLowerCase() !== "rules" || !isMarkdown(rest[rest.length - 1])) {
+    return null;
+  }
+  return rest.slice(1).join("/");
+}
+function reasonFor(instructionPath) {
+  const rest = segmentsBelowRoot(instructionPath);
+  if (rest.length >= 2) {
+    switch (rest[0]?.toLowerCase()) {
+      case "skills":
+        return "skill-needs-folder";
+      case "agents":
+        return "agent-must-be-markdown-file";
+      case "rules":
+        return "rule-must-be-markdown";
+      default:
+        break;
+    }
+  }
+  return "outside-plugin-folders";
+}
+var byPath = (a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0;
+function planPluginFiles(entries, tool) {
+  const order = tool === "codex" ? ["AGENTS.md", "CLAUDE.md"] : ALWAYS_ON_FILES;
+  const present = new Map(entries.map((entry) => [entry.path, entry]));
+  const alwaysOn = order.find((name) => {
+    const entry = present.get(name);
+    return entry !== void 0 && entry.size !== 0;
+  }) ?? null;
+  const plan = {
+    carried: [],
+    rules: [],
+    alwaysOn: alwaysOn === null ? null : { path: alwaysOn },
+    leftOut: []
+  };
+  for (const entry of entries) {
+    if (entry.path === alwaysOn) {
+      continue;
+    }
+    if (ALWAYS_ON_FILES.includes(entry.path)) {
+      plan.leftOut.push({
+        path: entry.path,
+        reason: "always-on-shadowed"
+      });
+      continue;
+    }
+    const place = pluginPathFor(entry.path);
+    const rule = projectRulePathFor(entry.path);
+    if (place === null && rule === null) {
+      plan.leftOut.push({
+        path: entry.path,
+        reason: reasonFor(entry.path)
+      });
+    } else if (entry.isText === false) {
+      plan.leftOut.push({ path: entry.path, reason: "not-text" });
+    } else if (rule !== null) {
+      plan.rules.push({ path: entry.path, as: rule });
+    } else if (place !== null) {
+      plan.carried.push({ path: entry.path, as: place });
+    }
+  }
+  plan.carried.sort(byPath);
+  plan.rules.sort(byPath);
+  plan.leftOut.sort(byPath);
+  return plan;
+}
+
 // ../sdk/src/index.ts
 var FabricClient = class _FabricClient {
   constructor(optionsOrHttp = {}) {
@@ -1848,9 +2045,11 @@ import Conf from "conf";
 import { randomUUID } from "crypto";
 import {
   closeSync,
+  constants,
+  fstatSync,
+  lstatSync,
   openSync,
-  readFileSync,
-  statSync,
+  readSync,
   unlinkSync,
   writeSync
 } from "fs";
@@ -1864,6 +2063,13 @@ var ExclusiveLockBusyError = class extends Error {
   }
 };
 var DEFAULT_POLL_MS = 100;
+var MAX_LOCK_BYTES = 256;
+var LockIdentityChangedError = class extends Error {
+  constructor() {
+    super("The lock changed while it was being read.");
+    this.name = "LockIdentityChangedError";
+  }
+};
 function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -1885,14 +2091,12 @@ function takeOnce(lockPath2, staleMs) {
     }
   }
   try {
-    if (Date.now() - statSync(lockPath2).mtimeMs > staleMs) {
-      if (ownerIsAlive(readFileSync(lockPath2, "utf8"))) {
-        return "busy";
-      }
-      return "abandoned";
+    const read = readLock(lockPath2);
+    if (Date.now() - read.stats.mtimeMs > staleMs) {
+      return ownerIsAlive(read.owner) ? "busy" : "abandoned";
     }
   } catch (error) {
-    if (isNotFoundError(error)) {
+    if (isNotFoundError(error) || error instanceof LockIdentityChangedError) {
       return "retry";
     }
     throw error;
@@ -1916,13 +2120,65 @@ function ownerIsAlive(owner) {
     return code === "EPERM" || code !== "ESRCH" && code !== "ENOENT";
   }
 }
+function readLock(lockPath2) {
+  const descriptor = openSync(
+    lockPath2,
+    constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK
+  );
+  try {
+    const stats = fstatSync(descriptor);
+    if (!stats.isFile()) {
+      throw new Error("The lock is not a regular file.");
+    }
+    if (stats.size > MAX_LOCK_BYTES) {
+      throw new Error("The lock is too large.");
+    }
+    const buffer = Buffer.allocUnsafe(MAX_LOCK_BYTES + 1);
+    let total = 0;
+    while (total <= MAX_LOCK_BYTES) {
+      const count = readSync(
+        descriptor,
+        buffer,
+        total,
+        MAX_LOCK_BYTES + 1 - total,
+        total
+      );
+      if (count === 0) {
+        break;
+      }
+      total += count;
+    }
+    if (total > MAX_LOCK_BYTES) {
+      throw new Error("The lock is too large.");
+    }
+    const current = lstatSync(lockPath2);
+    if (!current.isFile()) {
+      throw new Error("The lock is not a regular file.");
+    }
+    if (current.size > MAX_LOCK_BYTES) {
+      throw new Error("The lock is too large.");
+    }
+    if (current.dev !== stats.dev || current.ino !== stats.ino) {
+      throw new LockIdentityChangedError();
+    }
+    return { owner: buffer.toString("utf8", 0, total), stats };
+  } finally {
+    closeSync(descriptor);
+  }
+}
+function stillHeld(held, lockPath2) {
+  const expected = fstatSync(held.descriptor);
+  const read = readLock(lockPath2);
+  return read.owner === held.owner && read.stats.dev === expected.dev && read.stats.ino === expected.ino;
+}
 function release(held, lockPath2) {
-  closeSync(held.descriptor);
   try {
-    if (readFileSync(lockPath2, "utf8") === held.owner) {
+    if (stillHeld(held, lockPath2)) {
       unlinkSync(lockPath2);
     }
   } catch {
+  } finally {
+    closeSync(held.descriptor);
   }
 }
 async function withExclusiveLock(work, options) {
@@ -1948,6 +2204,10 @@ async function withExclusiveLock(work, options) {
     }
   }
   try {
+    options.signal?.throwIfAborted();
+    if (!stillHeld(held, lockPath2)) {
+      throw new Error("The lock changed before work could start.");
+    }
     return await work();
   } finally {
     release(held, lockPath2);
@@ -1978,6 +2238,9 @@ function withExclusiveLockSync(work, options) {
     }
   }
   try {
+    if (!stillHeld(held, lockPath2)) {
+      throw new Error("The lock changed before work could start.");
+    }
     return work();
   } finally {
     release(held, lockPath2);
@@ -2414,8 +2677,8 @@ function sameOriginEndpoint(value, field2, issuer) {
 }
 function authorizationServerMetadataUrl(issuer) {
   const url = new URL(issuer);
-  const path38 = url.pathname.replace(/\/+$/, "");
-  return `${url.origin}/.well-known/oauth-authorization-server${path38}`;
+  const path42 = url.pathname.replace(/\/+$/, "");
+  return `${url.origin}/.well-known/oauth-authorization-server${path42}`;
 }
 async function discoverAuthorizationServer(baseUrl, options = {}) {
   const fetchImpl = options.fetch ?? ((input, init) => fetch(input, init));
@@ -2482,11 +2745,26 @@ var CallbackError = class extends Error {
     this.name = "CallbackError";
   }
 };
+var DEFERRED_PAGE_TIMEOUT_MS = 60 * 1e3;
+var escapeHtml = (text3) => text3.replace(
+  /[&<>"']/g,
+  (char) => ({
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;"
+  })[char] ?? char
+);
 var FINAL_PAGE_HEADERS = {
   "Content-Type": "text/html; charset=utf-8",
   Connection: "close"
 };
-var PAGE = (title, body) => `<!doctype html><meta charset="utf-8"><title>${title}</title><body style="font-family:system-ui,sans-serif;max-width:32rem;margin:4rem auto;padding:0 1rem"><h1 style="font-weight:400">${title}</h1><p>${body}</p></body>`;
+var PAGE = (rawTitle, rawBody) => {
+  const title = escapeHtml(rawTitle);
+  const body = escapeHtml(rawBody);
+  return `<!doctype html><meta charset="utf-8"><title>${title}</title><body style="font-family:system-ui,sans-serif;max-width:32rem;margin:4rem auto;padding:0 1rem"><h1 style="font-weight:400">${title}</h1><p>${body}</p></body>`;
+};
 async function startLoopbackListener(options) {
   const callbackPath = options.callbackPath ?? CALLBACK_PATH;
   let settle = () => {
@@ -2502,6 +2780,32 @@ async function startLoopbackListener(options) {
   });
   result.catch(() => {
   });
+  let closed = false;
+  let held = null;
+  let heldTimer;
+  const release2 = () => {
+    held = null;
+    clearTimeout(heldTimer);
+    if (closed) {
+      server.closeAllConnections();
+    }
+  };
+  const finish = (page) => {
+    const response = held;
+    if (!response) {
+      return Promise.resolve();
+    }
+    held = null;
+    clearTimeout(heldTimer);
+    return new Promise((resolve) => {
+      response.once("close", resolve);
+      if (response.writableEnded || response.destroyed) {
+        resolve();
+        return;
+      }
+      response.writeHead(200, FINAL_PAGE_HEADERS).end(PAGE(page.title, page.body), () => resolve());
+    }).finally(release2);
+  };
   const server = createServer((request2, response) => {
     const url = new URL(request2.url ?? "/", "http://127.0.0.1");
     if (request2.method !== "GET" || url.pathname !== callbackPath) {
@@ -2543,6 +2847,22 @@ async function startLoopbackListener(options) {
       );
       return;
     }
+    if (options.deferPage) {
+      const { fallback, timeoutMs } = options.deferPage;
+      held = response;
+      response.once("close", () => {
+        if (held === response) {
+          release2();
+        }
+      });
+      heldTimer = setTimeout(
+        () => void finish(fallback),
+        timeoutMs ?? DEFERRED_PAGE_TIMEOUT_MS
+      );
+      heldTimer.unref();
+      settle({ code, params: url.searchParams });
+      return;
+    }
     response.writeHead(200, FINAL_PAGE_HEADERS).end(
       PAGE(
         options.successPage?.title ?? "Signed in",
@@ -2573,16 +2893,22 @@ async function startLoopbackListener(options) {
   const onAbort = () => settle({ error: new Error("Sign-in was cancelled.") });
   options.signal?.addEventListener("abort", onAbort, { once: true });
   const close = () => {
+    closed = true;
     clearTimeout(timer);
     options.signal?.removeEventListener("abort", onAbort);
-    server.closeAllConnections();
+    if (held) {
+      server.closeIdleConnections();
+    } else {
+      server.closeAllConnections();
+    }
     server.close();
   };
   result.then(close, close);
   return {
     redirectUri: `http://127.0.0.1:${port}${callbackPath}`,
     result,
-    close
+    close,
+    finish
   };
 }
 
@@ -2695,7 +3021,8 @@ var UNUSABLE_CLIENT_ERRORS = /* @__PURE__ */ new Set([
   "invalid_client",
   "client_disabled",
   "invalid_redirect",
-  "unauthorized_client"
+  "unauthorized_client",
+  "invalid_scope"
 ]);
 var OAuthLoginError = class extends Error {
   constructor(message) {
@@ -4795,10 +5122,10 @@ var AGENT_NAME = "Fabric";
 function registrationPath() {
   return join(dirname(getConfigPath()), "chatgpt-plan-host.json");
 }
-async function loadRegistrationStore(path38 = registrationPath()) {
+async function loadRegistrationStore(path42 = registrationPath()) {
   let stored;
   try {
-    stored = JSON.parse(await readFile(path38, "utf8"));
+    stored = JSON.parse(await readFile(path42, "utf8"));
   } catch {
     stored = {};
   }
@@ -4811,15 +5138,15 @@ async function loadRegistrationStore(path38 = registrationPath()) {
     accounts: stored.subject && stored.clientId ? { [stored.subject]: { clientId: stored.clientId } } : {}
   };
 }
-async function saveAccountRegistration(account, path38 = registrationPath()) {
-  const store = await loadRegistrationStore(path38);
+async function saveAccountRegistration(account, path42 = registrationPath()) {
+  const store = await loadRegistrationStore(path42);
   const { hostId, subject, ...registration } = account;
   const next = {
     hostId,
     accounts: { ...store.accounts, [subject]: registration }
   };
-  await mkdir(dirname(path38), { recursive: true, mode: 448 });
-  await writeFile(path38, JSON.stringify(next), { mode: 384 });
+  await mkdir(dirname(path42), { recursive: true, mode: 448 });
+  await writeFile(path42, JSON.stringify(next), { mode: 384 });
 }
 function selectRegistration(store, account) {
   if (account === void 0) {
@@ -4940,6 +5267,16 @@ function explainDenial(err) {
     `${err.message}${description} ChatGPT refused it for that workspace: run \`fabric connect chatgpt\` again without --account (the same as --new-registration) and choose your personal Plus or Pro workspace when ChatGPT asks which one to sign in to.`
   );
 }
+var CHECK_TERMINAL_PAGE = {
+  title: "Check your terminal",
+  body: "Fabric is taking longer than expected to answer. Your terminal shows whether the ChatGPT plan was connected. You can close this tab."
+};
+function notConnectedPage(reason) {
+  return {
+    title: "Not connected",
+    body: `${reason} Your terminal shows the same message. You can close this tab.`
+  };
+}
 async function attemptSignIn(registration, options) {
   const verifier = createCodeVerifier();
   const state = createState();
@@ -4947,7 +5284,10 @@ async function attemptSignIn(registration, options) {
   const listener = await startLoopbackListener({
     state,
     callbackPath: CHATGPT_CALLBACK_PATH,
-    preferredPort: options.preferredPort ?? CHATGPT_CALLBACK_PORT
+    preferredPort: options.preferredPort ?? CHATGPT_CALLBACK_PORT,
+    ...options.holdBrowserPage && {
+      deferPage: { fallback: CHECK_TERMINAL_PAGE }
+    }
   });
   try {
     options.open(
@@ -4961,27 +5301,38 @@ async function attemptSignIn(registration, options) {
       })
     );
     const { code, params } = await listener.result;
-    const clientId = issuedClientId(params, registration);
-    const tokens = await exchangeCode(
-      {
+    try {
+      const clientId = issuedClientId(params, registration);
+      const tokens = await exchangeCode(
+        {
+          clientId,
+          code,
+          codeVerifier: verifier,
+          redirectUri: listener.redirectUri
+        },
+        options.fetchImpl
+      );
+      const { sub, email } = checkIdToken(tokens.id_token ?? "", {
+        nonce,
+        subject: registration.subject
+      });
+      await options.save?.({
+        hostId: registration.hostId,
+        subject: sub,
         clientId,
-        code,
-        codeVerifier: verifier,
-        redirectUri: listener.redirectUri
-      },
-      options.fetchImpl
-    );
-    const { sub, email } = checkIdToken(tokens.id_token ?? "", {
-      nonce,
-      subject: registration.subject
-    });
-    await options.save?.({
-      hostId: registration.hostId,
-      subject: sub,
-      clientId,
-      ...email !== void 0 && { email }
-    });
-    return { tokens, clientId, subject: sub, email };
+        ...email !== void 0 && { email }
+      });
+      return {
+        tokens,
+        clientId,
+        subject: sub,
+        email,
+        finishBrowser: listener.finish
+      };
+    } catch (err) {
+      await listener.finish(notConnectedPage(err.message));
+      throw err;
+    }
   } finally {
     listener.close();
   }
@@ -5139,7 +5490,7 @@ async function approveInFabric(origin, sharedOrganizationSlug) {
 function describeOrganizations(result) {
   const enabled = result.organizations.filter((org) => org.enabled);
   if (enabled.length === 0) {
-    return "Choose where to use it in Fabric settings \u2192 Account \u2192 AI providers.";
+    return "Choose where to use it in Fabric: Settings \u2192 AI Providers \u2192 Personal.";
   }
   return `Your own AI work in ${enabled.map((org) => org.name).join(", ")} now uses your ChatGPT plan.`;
 }
@@ -5148,6 +5499,28 @@ function describeSharedAccount(result) {
   const { organization, created } = result.shared;
   return `${created ? "Connected" : "Reconnected"} the ChatGPT account${account} as a shared account of ${organization.name}. Choose which work it serves in ${organization.name}'s settings \u2192 AI providers.`;
 }
+function describeConnected(result) {
+  if ("shared" in result) {
+    return describeSharedAccount(result);
+  }
+  return `Connected your ChatGPT plan${result.email ? ` (${result.email})` : ""} to Fabric.`;
+}
+function connectedPage(result) {
+  const where = "shared" in result ? "" : ` ${describeOrganizations(result)}`;
+  return {
+    title: "Connected",
+    body: `${describeConnected(result)}${where} You can close this tab.`
+  };
+}
+function notConnectedMessage(reason) {
+  return `
+\u2717 Not connected: ${reason}
+`;
+}
+function failConnect(reason) {
+  process.stderr.write(notConnectedMessage(reason));
+  process.exit(1);
+}
 async function connect(opts) {
   const optionsError = connectOptionsError(opts);
   if (optionsError) {
@@ -5178,18 +5551,20 @@ async function connect(opts) {
   try {
     ticket = await approveInFabric(origin, sharedOrganizationSlug);
   } catch (err) {
-    printError(err.message, 1);
+    failConnect(err.message);
   }
   process.stdout.write("Approved in Fabric.\n");
+  let signIn;
   let result;
   try {
-    const signIn = await signInWithChatGpt({
+    signIn = await signInWithChatGpt({
       registration,
       open: (url) => open(url, "sign in with ChatGPT"),
       ...!sharedOrganizationSlug && { save: saveAccountRegistration },
       onRetry: () => process.stdout.write(
         "ChatGPT refused this machine's saved registration; signing in again with a new one.\n"
-      )
+      ),
+      holdBrowserPage: true
     });
     result = await uploadChatGptPlan({
       origin,
@@ -5200,17 +5575,16 @@ async function connect(opts) {
       })
     });
   } catch (err) {
-    printError(err.message, 1);
-  }
-  if ("shared" in result) {
-    printSuccess(describeSharedAccount(result));
-    return;
-  }
-  printSuccess(
-    `Connected your ChatGPT plan${result.email ? ` (${result.email})` : ""} to Fabric.`
-  );
-  process.stdout.write(`${describeOrganizations(result)}
+    const reason = err.message;
+    await signIn?.finishBrowser(notConnectedPage(reason));
+    failConnect(reason);
+  }
+  await signIn.finishBrowser(connectedPage(result));
+  printSuccess(describeConnected(result));
+  if (!("shared" in result)) {
+    process.stdout.write(`${describeOrganizations(result)}
 `);
+  }
 }
 function buildConnectCommand() {
   const connectCommand = new Command8("connect").description(
@@ -5314,7 +5688,7 @@ import path3 from "path";
 
 // src/lib/instructions/safe-write.ts
 import { createHash as createHash2, randomBytes as randomBytes3 } from "crypto";
-import { constants } from "fs";
+import { constants as constants2 } from "fs";
 import {
   lstat,
   mkdir as mkdir2,
@@ -5547,7 +5921,7 @@ async function openFileSafely(root, relativePath) {
   try {
     handle = await open2(
       check.path,
-      constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK
+      constants2.O_RDONLY | constants2.O_NOFOLLOW | constants2.O_NONBLOCK
     );
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -5593,40 +5967,57 @@ async function readFileSafely(root, relativePath, options = {}) {
         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.stats.size > options.maxBytes) {
-      throw new Error(
-        `${relativePath} is too large to read safely (maximum ${options.maxBytes} bytes).`
-      );
-    }
-    const buffer = Buffer.allocUnsafe(options.maxBytes + 1);
-    let total = 0;
-    while (total <= options.maxBytes) {
-      const { bytesRead } = await opened.handle.read(
-        buffer,
-        total,
-        options.maxBytes + 1 - total,
-        total
-      );
-      if (bytesRead === 0) {
-        break;
-      }
-      total += bytesRead;
-    }
-    if (total > options.maxBytes) {
-      throw new Error(
-        `${relativePath} is too large to read safely (maximum ${options.maxBytes} bytes).`
-      );
-    }
-    return { bytes: buffer.subarray(0, total), mode: opened.stats.mode };
+    return await readOpenedFileBounded(
+      opened.handle,
+      options.maxBytes,
+      relativePath
+    );
   } finally {
     await opened.handle.close();
   }
 }
+async function readOpenedFileBounded(handle, maxBytes, label) {
+  if (!Number.isSafeInteger(maxBytes) || maxBytes < 0) {
+    throw new Error(
+      "A safe file-read limit must be a non-negative integer."
+    );
+  }
+  const stats = await handle.stat();
+  if (!stats.isFile()) {
+    throw new Error(`${label} is not a regular file.`);
+  }
+  const tooLarge = () => new Error(
+    `${label} is too large to read safely (maximum ${maxBytes} bytes).`
+  );
+  if (stats.size > maxBytes) {
+    throw tooLarge();
+  }
+  const buffer = Buffer.allocUnsafe(maxBytes + 1);
+  let total = 0;
+  while (total <= maxBytes) {
+    const { bytesRead } = await handle.read(
+      buffer,
+      total,
+      maxBytes + 1 - total,
+      total
+    );
+    if (bytesRead === 0) {
+      break;
+    }
+    total += bytesRead;
+  }
+  if (total > maxBytes) {
+    throw tooLarge();
+  }
+  const after = await handle.stat();
+  if (after.size > maxBytes) {
+    throw tooLarge();
+  }
+  if (!after.isFile() || after.mode !== stats.mode) {
+    throw new Error(`${label} changed while it was being read.`);
+  }
+  return { bytes: buffer.subarray(0, total), mode: stats.mode };
+}
 var FINGERPRINT_BUFFER_BYTES = 64 * 1024;
 async function fingerprintFileSafely(root, relativePath) {
   const opened = await openFileSafely(root, relativePath);
@@ -5844,23 +6235,23 @@ function normalizeContextSourcePath(input) {
   if (slashed.startsWith("/") || DRIVE_LETTER_PREFIX.test(slashed)) {
     return { ok: false, reason: "absolute" };
   }
-  let path38 = slashed.replace(/\/{2,}/g, "/");
-  while (path38.startsWith("./")) {
-    path38 = path38.slice(2);
+  let path42 = slashed.replace(/\/{2,}/g, "/");
+  while (path42.startsWith("./")) {
+    path42 = path42.slice(2);
   }
-  if (path38.length === 0) {
+  if (path42.length === 0) {
     return { ok: false, reason: "empty" };
   }
-  if (path38.endsWith("/")) {
+  if (path42.endsWith("/")) {
     return { ok: false, reason: "trailing-slash" };
   }
-  if (path38.split("/").some((segment) => segment === "." || segment === "..")) {
+  if (path42.split("/").some((segment) => segment === "." || segment === "..")) {
     return { ok: false, reason: "dot-segment" };
   }
-  if (path38.length > MAX_CONTEXT_SOURCE_PATH_LENGTH) {
+  if (path42.length > MAX_CONTEXT_SOURCE_PATH_LENGTH) {
     return { ok: false, reason: "too-long" };
   }
-  return { ok: true, sourcePath: path38 };
+  return { ok: true, sourcePath: path42 };
 }
 
 // src/lib/context-sync/lock.ts
@@ -6058,7 +6449,7 @@ function buildContextIgnoreRules(input = {}) {
 // src/lib/context-sync/walk.ts
 import { lstat as lstat2, readdir } from "fs/promises";
 import path5 from "path";
-function byPath(a, b) {
+function byPath2(a, b) {
   return a < b ? -1 : a > b ? 1 : 0;
 }
 async function walkContextDirectory(root, rules) {
@@ -6111,16 +6502,16 @@ async function walkContextDirectory(root, rules) {
       }
     }
   }
-  walk.files.sort((a, b) => byPath(a.path, b.path));
-  walk.symlinks.sort(byPath);
-  walk.special.sort(byPath);
-  walk.unmatchable.sort(byPath);
-  walk.ignored.sort((a, b) => byPath(a.path, b.path));
+  walk.files.sort((a, b) => byPath2(a.path, b.path));
+  walk.symlinks.sort(byPath2);
+  walk.special.sort(byPath2);
+  walk.unmatchable.sort(byPath2);
+  walk.ignored.sort((a, b) => byPath2(a.path, b.path));
   return walk;
 }
 
 // src/lib/context-sync/plan.ts
-function byPath2(a, b) {
+function byPath3(a, b) {
   return a < b ? -1 : a > b ? 1 : 0;
 }
 async function readContextIgnore(root) {
@@ -6255,15 +6646,15 @@ async function computeContextPlan(input) {
       skipped3.push({ path: entry.diskPath, reason: verdict.reason });
       continue;
     }
-    const sha256 = hashContextContent(verdict.content);
+    const sha2562 = hashContextContent(verdict.content);
     const locked = lock?.files[entry.sourcePath];
     const plannedFile = {
       sourcePath: entry.sourcePath,
       diskPath: entry.diskPath,
-      sha256,
+      sha256: sha2562,
       bytes: read.bytes.byteLength
     };
-    if (locked?.sha256 === sha256) {
+    if (locked?.sha256 === sha2562) {
       unchangedLocal.push(entry.sourcePath);
     } else {
       push2.push(
@@ -6295,14 +6686,14 @@ async function computeContextPlan(input) {
       removed.push(sourcePath);
     }
   }
-  push2.sort((a, b) => byPath2(a.sourcePath, b.sourcePath));
-  removed.sort(byPath2);
+  push2.sort((a, b) => byPath3(a.sourcePath, b.sourcePath));
+  removed.sort(byPath3);
   const moves = pairMoves(lock, removed, push2);
   const moved = new Set(moves.map((move) => move.from));
   const arrived = new Set(moves.map((move) => move.to));
-  unchangedLocal.sort(byPath2);
-  forgotten.sort(byPath2);
-  skipped3.sort((a, b) => byPath2(a.path, b.path));
+  unchangedLocal.sort(byPath3);
+  forgotten.sort(byPath3);
+  skipped3.sort((a, b) => byPath3(a.path, b.path));
   return {
     push: push2.filter((entry) => !arrived.has(entry.sourcePath)),
     moves,
@@ -6664,7 +7055,7 @@ async function pushContextPlan(input) {
       }
     }
   };
-  const deleteEntry = async (sourcePath, sha256) => {
+  const deleteEntry = async (sourcePath, sha2562) => {
     const remove = (expectedContentHash) => input.client.contexts.deleteSyncedFile(
       input.projectId,
       { sourcePath, expectedContentHash },
@@ -6687,7 +7078,7 @@ async function pushContextPlan(input) {
       }
     };
     try {
-      return fromAnswer(await remove(sha256));
+      return fromAnswer(await remove(sha2562));
     } catch (error) {
       const managed = repositoryManagedOf(error);
       if (managed !== null) {
@@ -6748,9 +7139,9 @@ async function pushContextPlan(input) {
     }
   };
   const pruneTargetsSoFar = () => {
-    const keptByMoves = results.map(moveKeptOldPath).filter((path38) => path38 !== null);
-    return [.../* @__PURE__ */ new Set([...input.plan.removed, ...keptByMoves])].filter((path38) => {
-      const locked = input.lock?.files[path38];
+    const keptByMoves = results.map(moveKeptOldPath).filter((path42) => path42 !== null);
+    return [.../* @__PURE__ */ new Set([...input.plan.removed, ...keptByMoves])].filter((path42) => {
+      const locked = input.lock?.files[path42];
       return locked !== void 0 && locked.state !== "duplicate";
     }).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
   };
@@ -6821,12 +7212,12 @@ function nextContextLock(input) {
       changed = true;
     }
   };
-  const confirm2 = (sourcePath, sha256, contextId) => {
+  const confirm2 = (sourcePath, sha2562, contextId) => {
     const before = files[sourcePath];
-    if (before?.state === void 0 && before?.sha256 === sha256 && before.contextId === contextId) {
+    if (before?.state === void 0 && before?.sha256 === sha2562 && before.contextId === contextId) {
       return;
     }
-    files[sourcePath] = { sha256, contextId };
+    files[sourcePath] = { sha256: sha2562, contextId };
     changed = true;
   };
   for (const sourcePath of input.forgotten ?? []) {
@@ -7388,7 +7779,7 @@ function pruneSummary(results, targets) {
       (r) => r.status === "deleted" || r.status === "already-gone"
     ).map((r) => r.sourcePath)
   );
-  const notDeleted = targets.filter((path38) => !settled.has(path38)).length;
+  const notDeleted = targets.filter((path42) => !settled.has(path42)).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") {
@@ -7772,7 +8163,7 @@ function buildFramesCommand() {
 
 // src/commands/instructions/index.ts
 import { readdir as readdir4 } from "fs/promises";
-import path36 from "path";
+import path39 from "path";
 import { Command as Command13 } from "commander";
 
 // src/lib/environment.ts
@@ -7785,15 +8176,15 @@ function runningInCi(env2 = process.env) {
 }
 
 // src/lib/instructions/adoption.ts
-import path11 from "path";
+import path10 from "path";
 
 // src/lib/instructions/checkout.ts
-import { realpath as realpath2 } from "fs/promises";
-import path10 from "path";
+import { realpath as realpath3 } from "fs/promises";
+import path9 from "path";
 
 // src/lib/instructions/git.ts
-import { lstat as lstat5, stat } from "fs/promises";
-import path9 from "path";
+import { lstat as lstat4, stat } from "fs/promises";
+import path8 from "path";
 
 // src/lib/instructions/git-literals.ts
 var COMMIT_SHA = /^[0-9a-f]{40}$/;
@@ -8167,8 +8558,7 @@ async function changedTrackedPaths(root, deadline) {
 }
 
 // src/lib/instructions/git-write.ts
-import { lstat as lstat4, readFile as readFile3 } from "fs/promises";
-import path8 from "path";
+import { realpath as realpath2 } from "fs/promises";
 function fetchFailureOf(stderr) {
   if (/config-env/i.test(stderr) && /unknown option|usage:/i.test(stderr)) {
     return "old-git";
@@ -8380,24 +8770,22 @@ async function restorableBytes(root, file, entry, indexed, fileMode) {
   if (indexed === null || indexed === void 0 || entry.mode === "120000") {
     return null;
   }
-  const absolute = path8.join(root, file);
-  const info = await lstat4(absolute).catch(() => null);
-  if (info === null || !info.isFile() || info.size > MAX_COMPARED_BYTES) {
+  const read = await readFileSafely(root, file, {
+    maxBytes: MAX_COMPARED_BYTES
+  }).catch(() => null);
+  if (read === null) {
     return null;
   }
-  const executable = (info.mode & 73) !== 0;
+  const executable = (read.mode & 73) !== 0;
   if (fileMode && executable !== (entry.mode === "100755")) {
     return null;
   }
-  const local = await readFile3(absolute).catch(() => null);
-  if (local === null) {
-    return null;
-  }
+  const local = Buffer.from(read.bytes);
   const mine = local.toString("latin1");
   if (mine.includes("\0") || indexed.includes("\0")) {
     return null;
   }
-  return mine.replace(CRLF, "\n") === indexed.replace(CRLF, "\n") ? local : null;
+  return mine.replace(CRLF, "\n") === indexed.replace(CRLF, "\n") ? { bytes: local, mode: read.mode } : null;
 }
 async function realBlockers(root, files, deadline) {
   const scope = ["--literal-pathspecs", "-c", "core.quotepath=false"];
@@ -8520,9 +8908,11 @@ async function realBlockers(root, files, deadline) {
 }
 var RESTORE_AND_MERGE_FLOOR_MS = 1500;
 async function stillUntouched(root, restorable) {
-  for (const [file, bytes] of restorable) {
-    const now2 = await readFile3(path8.join(root, file)).catch(() => null);
-    if (now2 === null || !now2.equals(bytes)) {
+  for (const [file, previous] of restorable) {
+    const now2 = await readFileSafely(root, file, {
+      maxBytes: MAX_COMPARED_BYTES
+    }).catch(() => null);
+    if (now2 === null || now2.mode !== previous.mode || !Buffer.from(now2.bytes).equals(previous.bytes)) {
       return false;
     }
   }
@@ -8536,7 +8926,11 @@ async function fastForwardTo(root, sha, deadline) {
   if (first.kind !== "failed" || first.reason !== "local-changes" || first.files.length === 0) {
     return first;
   }
-  const judged = await realBlockers(root, first.files, deadline);
+  const restoreRoot = await realpath2(root).catch(() => null);
+  if (restoreRoot === null) {
+    return first;
+  }
+  const judged = await realBlockers(restoreRoot, first.files, deadline);
   if (judged === "ran-out-of-time") {
     return { kind: "timed-out" };
   }
@@ -8546,11 +8940,11 @@ async function fastForwardTo(root, sha, deadline) {
   if (judged.real.length > 0) {
     return { kind: "failed", reason: "local-changes", files: judged.real };
   }
-  if (deadline - Date.now() < RESTORE_AND_MERGE_FLOOR_MS || !await stillUntouched(root, judged.restorable)) {
+  if (deadline - Date.now() < RESTORE_AND_MERGE_FLOOR_MS || !await stillUntouched(restoreRoot, judged.restorable)) {
     return first;
   }
   const restored = await runGit(
-    root,
+    restoreRoot,
     ["--literal-pathspecs", "checkout", "--", ...first.files],
     deadline,
     { write: true, unattended: true }
@@ -8558,7 +8952,7 @@ async function fastForwardTo(root, sha, deadline) {
   if (restored.kind !== "exited" || restored.code !== 0) {
     return first;
   }
-  return mergeOnce(root, sha, deadline);
+  return mergeOnce(restoreRoot, sha, deadline);
 }
 
 // src/lib/instructions/git.ts
@@ -8575,13 +8969,13 @@ var OPERATION_MARKERS = [
   { marker: "sequencer", operation: "cherry-pick" }
 ];
 async function nearestExistingDirectory(dir) {
-  let current = path9.resolve(dir);
+  let current = path8.resolve(dir);
   for (; ; ) {
     const found = await stat(current).catch(() => null);
     if (found?.isDirectory()) {
       return current;
     }
-    const parent = path9.dirname(current);
+    const parent = path8.dirname(current);
     if (parent === current) {
       return null;
     }
@@ -8591,10 +8985,10 @@ async function nearestExistingDirectory(dir) {
 async function hasGitEntryAbove(dir) {
   let current = dir;
   for (; ; ) {
-    if (await lstat5(path9.join(current, ".git")).catch(() => null) !== null) {
+    if (await lstat4(path8.join(current, ".git")).catch(() => null) !== null) {
       return true;
     }
-    const parent = path9.dirname(current);
+    const parent = path8.dirname(current);
     if (parent === current) {
       return false;
     }
@@ -8640,7 +9034,7 @@ async function findWorkTree(dir, deadline) {
     kind: "ok",
     value: {
       toplevel,
-      gitDir: path9.resolve(cwd, gitDir),
+      gitDir: path8.resolve(cwd, gitDir),
       shallow: shallow === "true",
       superproject: superproject ? superproject : null
     }
@@ -8766,7 +9160,7 @@ async function trackedPaths(root, relativePaths, deadline) {
     return { kind: "ok", value: [] };
   }
   if (relativePaths.some(
-    (relativePath) => relativePath === "" || relativePath.startsWith("-") || path9.isAbsolute(relativePath) || path9.win32.isAbsolute(relativePath) || relativePath.split(/[\\/]/).some((part) => part === "..")
+    (relativePath) => relativePath === "" || relativePath.startsWith("-") || path8.isAbsolute(relativePath) || path8.win32.isAbsolute(relativePath) || relativePath.split(/[\\/]/).some((part) => part === "..")
   )) {
     return {
       kind: "unavailable",
@@ -8852,8 +9246,8 @@ async function operationInProgress(root, deadline) {
     return { kind: "unavailable", reason: "git answered unexpectedly" };
   }
   for (const [index, { operation }] of OPERATION_MARKERS.entries()) {
-    const marker = path9.resolve(root, paths[index]);
-    if (await lstat5(marker).catch(() => null) !== null) {
+    const marker = path8.resolve(root, paths[index]);
+    if (await lstat4(marker).catch(() => null) !== null) {
       return { kind: "ok", value: operation };
     }
   }
@@ -8943,7 +9337,7 @@ async function lockFilesPresent(root, deadline) {
     return { kind: "unavailable", reason: "git answered unexpectedly" };
   }
   for (const lock of paths) {
-    if (await lstat5(path9.resolve(root, lock)).catch(() => null) !== null) {
+    if (await lstat4(path8.resolve(root, lock)).catch(() => null) !== null) {
       return { kind: "ok", value: true };
     }
   }
@@ -8991,7 +9385,7 @@ async function commonDir(root, deadline) {
   if (result.value.code !== 0 || !dir) {
     return { kind: "unavailable", reason: "git answered unexpectedly" };
   }
-  return { kind: "ok", value: path9.resolve(root, dir) };
+  return { kind: "ok", value: path8.resolve(root, dir) };
 }
 async function excludeFilePath(root, deadline) {
   const result = await simple(
@@ -9006,7 +9400,7 @@ async function excludeFilePath(root, deadline) {
   if (result.value.code !== 0 || !answer) {
     return { kind: "unavailable", reason: "git answered unexpectedly" };
   }
-  return { kind: "ok", value: path9.resolve(root, answer) };
+  return { kind: "ok", value: path8.resolve(root, answer) };
 }
 async function isIgnored(root, relativePath, deadline) {
   if (relativePath.startsWith("-") || relativePath === "") {
@@ -9636,15 +10030,15 @@ function downloadsIn(classification, manual) {
   return manual && classification.class === "foreign";
 }
 function isSafeRootPath(rootPath) {
-  if (path10.posix.isAbsolute(rootPath) || path10.win32.isAbsolute(rootPath) || rootPath.startsWith("~")) {
+  if (path9.posix.isAbsolute(rootPath) || path9.win32.isAbsolute(rootPath) || rootPath.startsWith("~")) {
     return false;
   }
   return !rootPath.split(/[\\/]/).some((segment) => segment === "..");
 }
 async function sameDirectory(a, b) {
   const [left, right] = await Promise.all([
-    realpath2(a).catch(() => null),
-    realpath2(b).catch(() => null)
+    realpath3(a).catch(() => null),
+    realpath3(b).catch(() => null)
   ]);
   return left !== null && left === right;
 }
@@ -9730,7 +10124,7 @@ async function classify({
   if (matching.length > 1) {
     return { class: "ambiguous", remotes: matching };
   }
-  const mapped = path10.join(root, repository.rootPath);
+  const mapped = path9.join(root, repository.rootPath);
   if (!await sameDirectory(destination, mapped)) {
     return {
       class: "unmapped",
@@ -10033,7 +10427,7 @@ function providerLoginCommand(provider, gitCommand) {
   }
 }
 function folderForCommand(dest, relative) {
-  const inside = relative.split(path11.sep).join("/") || ".";
+  const inside = relative.split(path10.sep).join("/") || ".";
   const typed = dest?.replace(/\\/g, "/").replace(/\/+$/, "");
   return shellQuote(
     typed === void 0 || typed === "" ? inside : inside === "." ? typed : `${typed}/${inside}`
@@ -10075,9 +10469,9 @@ function adoptionFor(input) {
           repo,
           where: folderForCommand(
             input.rerun.dest,
-            path11.relative(
+            path10.relative(
               input.destination,
-              path11.join(
+              path10.join(
                 classification.toplevel,
                 classification.rootPath
               )
@@ -10109,17 +10503,27 @@ function adoptionFor(input) {
 }
 
 // src/lib/instructions/agent-mcp-config.ts
-import { readFile as readFile4, stat as stat2 } from "fs/promises";
-import path12 from "path";
+import { constants as constants3 } from "fs";
+import { open as open3 } from "fs/promises";
+import path11 from "path";
 var LEGACY_SERVER_NAME = "fabric";
 var MAX_CONFIG_BYTES = 16 * 1024 * 1024;
 async function readText(file) {
   try {
-    const info = await stat2(file);
-    if (!info.isFile() || info.size > MAX_CONFIG_BYTES) {
-      return { kind: "unusable" };
+    const handle = await open3(
+      file,
+      constants3.O_RDONLY | constants3.O_NONBLOCK
+    );
+    try {
+      const read = await readOpenedFileBounded(
+        handle,
+        MAX_CONFIG_BYTES,
+        file
+      );
+      return { kind: "text", text: read.bytes.toString("utf8") };
+    } finally {
+      await handle.close();
     }
-    return { kind: "text", text: await readFile4(file, "utf8") };
   } catch (error) {
     return error.code === "ENOENT" ? { kind: "absent" } : { kind: "unusable" };
   }
@@ -10149,7 +10553,7 @@ async function readClaudeServers(input) {
     return { state: "unlocated" };
   }
   const servers = [];
-  const config2 = await readText(path12.join(directory, ".claude.json"));
+  const config2 = await readText(path11.join(directory, ".claude.json"));
   if (config2.kind === "unusable") {
     return { state: "unreadable" };
   }
@@ -10177,7 +10581,7 @@ async function readClaudeServers(input) {
       servers.push({ scope: "user", ...found });
     }
   }
-  const shared = await readText(path12.join(input.cwd, ".mcp.json"));
+  const shared = await readText(path11.join(input.cwd, ".mcp.json"));
   if (shared.kind === "text") {
     try {
       for (const found of serversIn(
@@ -10196,11 +10600,11 @@ var CODEX_SERVER_SUBTABLE = /^\[mcp_servers\.(?:"[^"]+"|'[^']+'|[A-Za-z0-9_-]+)\
 var CODEX_OTHER_HEADER = /^\[{1,2}\s*mcp_servers\b/;
 var CODEX_OTHER_KEY = /^mcp_servers\b/;
 async function readCodexServers(input) {
-  const directory = input.env.CODEX_HOME ?? (input.home === null ? void 0 : path12.join(input.home, ".codex"));
+  const directory = input.env.CODEX_HOME ?? (input.home === null ? void 0 : path11.join(input.home, ".codex"));
   if (directory === void 0) {
     return { state: "unlocated" };
   }
-  const config2 = await readText(path12.join(directory, "config.toml"));
+  const config2 = await readText(path11.join(directory, "config.toml"));
   if (config2.kind === "absent") {
     return { state: "read", servers: [] };
   }
@@ -10351,7 +10755,7 @@ function registrationOf(servers, name) {
 import { createHash as createHash4 } from "crypto";
 import { mkdir as mkdir3 } from "fs/promises";
 import { tmpdir } from "os";
-import path13 from "path";
+import path12 from "path";
 
 // src/lib/instructions/identifiers.ts
 var IDENTIFIER = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
@@ -10360,11 +10764,11 @@ function isIdentifier(value) {
 }
 
 // src/lib/instructions/hook.ts
-var CLAUDE_SETTINGS_RELATIVE_PATH = path13.join(
+var CLAUDE_SETTINGS_RELATIVE_PATH = path12.join(
   ".claude",
   "settings.local.json"
 );
-var CODEX_HOOKS_RELATIVE_PATH = path13.join(".codex", "hooks.json");
+var CODEX_HOOKS_RELATIVE_PATH = path12.join(".codex", "hooks.json");
 var CLAUDE_SETTINGS_POSIX_PATH = ".claude/settings.local.json";
 var CODEX_HOOKS_POSIX_PATH = ".codex/hooks.json";
 var HOOK_TIMEOUT_SECONDS = 15;
@@ -10381,10 +10785,10 @@ function subcommandsForEvent(event) {
   return event === "Stop" ? STOP_SUBCOMMANDS : SESSION_START_SUBCOMMANDS;
 }
 async function withHookConfigLock(root, posixPath, work) {
-  const directory = path13.join(tmpdir(), "fabric-instructions-hook-locks");
+  const directory = path12.join(tmpdir(), "fabric-instructions-hook-locks");
   await mkdir3(directory, { recursive: true });
-  const identity = createHash4("sha256").update(path13.resolve(root)).update("\0").update(posixPath).digest("hex");
-  const lockPath2 = path13.join(directory, `${identity}.lock`);
+  const identity = createHash4("sha256").update(path12.resolve(root)).update("\0").update(posixPath).digest("hex");
+  const lockPath2 = path12.join(directory, `${identity}.lock`);
   try {
     return await withExclusiveLock(work, {
       lockPath: lockPath2,
@@ -10439,7 +10843,7 @@ async function assertKeyStaysOutside(destination, configPath) {
   }
 }
 async function readHookConfig(root, hookTarget) {
-  const settingsPath = path13.join(root, hookTarget.relativePath);
+  const settingsPath = path12.join(root, hookTarget.relativePath);
   let existingRaw;
   try {
     const existing = await readFileSafely(root, hookTarget.posixPath, {
@@ -10518,7 +10922,7 @@ function pruneMatching(groups, projectId, subcommands) {
 async function mergeCommandHook(input) {
   const hookTarget = hookTargetFor(input.tool ?? "claude-code");
   return withHookConfigLock(input.root, hookTarget.posixPath, async () => {
-    const settingsPath = path13.join(input.root, hookTarget.relativePath);
+    const settingsPath = path12.join(input.root, hookTarget.relativePath);
     const { settings, existingRaw } = await readHookConfig(
       input.root,
       hookTarget
@@ -10562,7 +10966,7 @@ async function mergeCommandHook(input) {
 async function updateHookConfig(input) {
   const hookTarget = hookTargetFor(input.tool);
   return withHookConfigLock(input.root, hookTarget.posixPath, async () => {
-    const settingsPath = path13.join(input.root, hookTarget.relativePath);
+    const settingsPath = path12.join(input.root, hookTarget.relativePath);
     const { settings, existingRaw } = await readHookConfig(
       input.root,
       hookTarget
@@ -10604,7 +11008,7 @@ async function mergeSessionStartHook(input) {
 async function removeCommandHook(input) {
   const hookTarget = hookTargetFor(input.tool ?? "claude-code");
   return withHookConfigLock(input.root, hookTarget.posixPath, async () => {
-    const settingsPath = path13.join(input.root, hookTarget.relativePath);
+    const settingsPath = path12.join(input.root, hookTarget.relativePath);
     const { settings, existingRaw } = await readHookConfig(
       input.root,
       hookTarget
@@ -11253,8 +11657,8 @@ function agentMcpSummaryLines(results) {
 import { spawn as spawn3 } from "child_process";
 
 // src/lib/instructions/path-lookup.ts
-import { stat as stat3 } from "fs/promises";
-import path14 from "path";
+import { stat as stat2 } from "fs/promises";
+import path13 from "path";
 var MAX_PATH_ENTRIES = 256;
 var MAX_PATHEXT_ENTRIES = 32;
 var DEFAULT_PATHEXT = ".COM;.EXE;.BAT;.CMD";
@@ -11268,7 +11672,7 @@ function readVariable(lookup, name) {
   return key === void 0 ? void 0 : lookup.env[key];
 }
 function pathApi(platform) {
-  return platform === "win32" ? path14.win32 : path14.posix;
+  return platform === "win32" ? path13.win32 : path13.posix;
 }
 function searchDirectories(lookup) {
   const api = pathApi(lookup.platform);
@@ -11290,7 +11694,7 @@ function windowsExtensions(lookup) {
   const raw = readVariable(lookup, "PATHEXT") ?? DEFAULT_PATHEXT;
   return raw.split(";").map((extension) => extension.trim()).filter((extension) => /^\.[A-Za-z0-9]+$/.test(extension)).slice(0, MAX_PATHEXT_ENTRIES);
 }
-async function isExecutableFile(candidate, platform, statCandidate = stat3) {
+async function isExecutableFile(candidate, platform, statCandidate = stat2) {
   try {
     const stats = await statCandidate(candidate);
     if (!stats.isFile()) {
@@ -11464,8 +11868,8 @@ import { createHash as createHash5 } from "crypto";
 import { chmod } from "fs/promises";
 
 // src/lib/instructions/lock.ts
-import { readFile as readFile5 } from "fs/promises";
-import path15 from "path";
+import { readFile as readFile3 } from "fs/promises";
+import path14 from "path";
 var LOCK_DIRECTORY = ".fabric";
 var LOCK_FILENAME = "instructions.lock";
 var LOCK_VERSION = 3;
@@ -11473,13 +11877,13 @@ var READABLE_LOCK_VERSIONS = [1, 2, LOCK_VERSION];
 var LOCK_RELATIVE_PATH = `${LOCK_DIRECTORY}/${LOCK_FILENAME}`;
 var SHA256_HEX2 = /^[0-9a-f]{64}$/;
 function lockPath(destination) {
-  return path15.join(destination, LOCK_DIRECTORY, LOCK_FILENAME);
+  return path14.join(destination, LOCK_DIRECTORY, LOCK_FILENAME);
 }
-async function readLock(destination) {
+async function readLock2(destination) {
   const file = lockPath(destination);
   let raw;
   try {
-    raw = await readFile5(file, "utf8");
+    raw = await readFile3(file, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") {
       return null;
@@ -12081,11 +12485,11 @@ function extractBundle(archive, wanted) {
 }
 
 // src/lib/instructions/clone-target.ts
-import { lstat as lstat6 } from "fs/promises";
-import path16 from "path";
+import { lstat as lstat5 } from "fs/promises";
+import path15 from "path";
 async function resolveCloneFolder(base, folder) {
-  const target = path16.resolve(base, folder);
-  const stats = await lstat6(target).catch((error) => {
+  const target = path15.resolve(base, folder);
+  const stats = await lstat5(target).catch((error) => {
     if (error.code === "ENOENT") {
       return null;
     }
@@ -12102,8 +12506,8 @@ async function resolveCloneFolder(base, folder) {
 
 // src/lib/instructions/doctor.ts
 import { createHash as createHash9 } from "crypto";
-import { stat as stat4 } from "fs/promises";
-import path18 from "path";
+import { stat as stat3 } from "fs/promises";
+import path17 from "path";
 
 // src/lib/instructions/file-downloads.ts
 import { createHash as createHash6 } from "crypto";
@@ -12448,13 +12852,13 @@ function isTooLarge(error) {
 
 // src/lib/instructions/staged-files.ts
 import { createHash as createHash8 } from "crypto";
-import { mkdtemp, realpath as realpath3, rm } from "fs/promises";
+import { mkdtemp, realpath as realpath4, rm } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import path17 from "path";
+import path16 from "path";
 var IN_MEMORY_SNAPSHOT_BYTES = 50 * 1024 * 1024;
 async function stageFilesByUrl(options) {
-  const root = await realpath3(
-    await mkdtemp(path17.join(tmpdir2(), "fabric-instructions-"))
+  const root = await realpath4(
+    await mkdtemp(path16.join(tmpdir2(), "fabric-instructions-"))
   );
   const files = /* @__PURE__ */ new Map();
   const dispose = () => rm(root, { recursive: true, force: true });
@@ -12496,7 +12900,7 @@ async function stageFilesByUrl(options) {
 // src/lib/instructions/doctor.ts
 var MAX_ITEMS = 50;
 var MAX_NAMES_IN_FIX = 20;
-var MAX_LOCK_BYTES = 16 * 1024 * 1024;
+var MAX_LOCK_BYTES2 = 16 * 1024 * 1024;
 var MAX_DOWNLOAD_BYTES = 52428800 + 1048576 + 5e3 * (512 + 2 * 1024);
 var PROBE_TIMEOUT_MS = 5e3;
 var PROBE_BUDGET_MS = 15e3;
@@ -12654,7 +13058,7 @@ function loginCommand2(input) {
   ) ?? fabricCommand("auth login");
 }
 async function isRegularFile(file) {
-  return (await stat4(file).catch(() => null))?.isFile() ?? false;
+  return (await stat3(file).catch(() => null))?.isFile() ?? false;
 }
 var Commands = class {
   constructor(input) {
@@ -13154,7 +13558,7 @@ function checkPublished(access) {
 }
 async function readLockBounded(root) {
   try {
-    const lock = await readLockSafely(root, { maxBytes: MAX_LOCK_BYTES });
+    const lock = await readLockSafely(root, { maxBytes: MAX_LOCK_BYTES2 });
     return lock === null ? { kind: "absent" } : { kind: "ok", lock };
   } catch (error) {
     if (error instanceof LockReadRefusedError) {
@@ -13186,7 +13590,7 @@ function unreadableLockCheck(input, commands, reason) {
     "lock",
     "machine",
     "fail",
-    reason === "too-large" ? `the lock is larger than ${MAX_LOCK_BYTES} bytes` : "the lock is unreadable",
+    reason === "too-large" ? `the lock is larger than ${MAX_LOCK_BYTES2} bytes` : "the lock is unreadable",
     {
       fix: fixOf(
         `the lock at ${where} is damaged: remove it, then run this sync to take a fresh copy`,
@@ -14383,13 +14787,13 @@ async function commandResolves(input, lookup, command) {
   if (TOOL_NAME.test(command)) {
     return await isOnPath(command, lookup) ? "found" : "missing";
   }
-  const api = input.platform === "win32" ? path18.win32 : path18.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(
-      path18.resolve(input.root, command),
+      path17.resolve(input.root, command),
       input.platform
     ) ? "found" : "missing";
   }
@@ -14566,13 +14970,13 @@ function formatDoctorText(report, destination) {
 // src/lib/instructions/drop-lock.ts
 import { createHash as createHash10 } from "crypto";
 import { rmdir } from "fs/promises";
-import path19 from "path";
+import path18 from "path";
 var LOCK_RELATIVE = `${LOCK_DIRECTORY}/${LOCK_FILENAME}`;
-var MAX_LOCK_BYTES2 = 16 * 1024 * 1024;
+var MAX_LOCK_BYTES3 = 16 * 1024 * 1024;
 async function dropOwnLock(root, projectId) {
   try {
     const read = await readFileSafely(root, LOCK_RELATIVE, {
-      maxBytes: MAX_LOCK_BYTES2
+      maxBytes: MAX_LOCK_BYTES3
     });
     if (read === null) {
       return false;
@@ -14581,12 +14985,12 @@ async function dropOwnLock(root, projectId) {
     if (lock.projectId !== projectId) {
       return false;
     }
-    const sha256 = createHash10("sha256").update(read.bytes).digest("hex");
-    const outcome = await deleteFileSafely(root, LOCK_RELATIVE, sha256);
+    const sha2562 = createHash10("sha256").update(read.bytes).digest("hex");
+    const outcome = await deleteFileSafely(root, LOCK_RELATIVE, sha2562);
     if (outcome !== "deleted") {
       return false;
     }
-    await rmdir(path19.join(root, LOCK_DIRECTORY)).catch(() => void 0);
+    await rmdir(path18.join(root, LOCK_DIRECTORY)).catch(() => void 0);
     return true;
   } catch {
     return false;
@@ -14678,8 +15082,8 @@ function replacePath(text3, target, replacement) {
 }
 
 // src/lib/instructions/fast-forward-run.ts
-import { mkdir as mkdir6, realpath as realpath4 } from "fs/promises";
-import path22 from "path";
+import { mkdir as mkdir6, realpath as realpath5 } from "fs/promises";
+import path21 from "path";
 
 // src/lib/instructions/fast-forward.ts
 function fastForwardEligibility(facts) {
@@ -14868,10 +15272,10 @@ function fastForwardLines(outcome, context) {
 }
 
 // src/lib/instructions/fast-forward-memory.ts
-import { mkdir as mkdir4, readFile as readFile6, rename as rename2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
-import path20 from "path";
+import { mkdir as mkdir4, readFile as readFile4, rename as rename2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import path19 from "path";
 function noticeFile(commonDir2) {
-  return path20.join(commonDir2, "fabric", "ff-notice.json");
+  return path19.join(commonDir2, "fabric", "ff-notice.json");
 }
 function isRecord4(value) {
   if (typeof value !== "object" || value === null) {
@@ -14882,7 +15286,7 @@ function isRecord4(value) {
 }
 async function isNewNotice(file, key) {
   try {
-    const parsed = JSON.parse(await readFile6(file, "utf8"));
+    const parsed = JSON.parse(await readFile4(file, "utf8"));
     return !(isRecord4(parsed) && parsed.projectId === key.projectId && parsed.publishedVersion === key.publishedVersion && parsed.directCommitSha === key.directCommitSha && parsed.reason === key.reason);
   } catch {
     return true;
@@ -14890,7 +15294,7 @@ async function isNewNotice(file, key) {
 }
 async function rememberNotice(file, key) {
   try {
-    await mkdir4(path20.dirname(file), { recursive: true });
+    await mkdir4(path19.dirname(file), { recursive: true });
     const temporary = `${file}.${process.pid}.tmp`;
     const record = { v: 1, ...key };
     await writeFile2(temporary, `${JSON.stringify(record)}
@@ -14919,15 +15323,15 @@ function sinceProcessStart(now2 = Date.now()) {
 }
 
 // src/lib/instructions/hook-trace.ts
-import { mkdir as mkdir5, readFile as readFile7, rename as rename3, writeFile as writeFile3 } from "fs/promises";
-import path21 from "path";
+import { mkdir as mkdir5, readFile as readFile5, rename as rename3, writeFile as writeFile3 } from "fs/promises";
+import path20 from "path";
 var TRACE_LIMIT = 50;
 function traceFile(configDir) {
-  return path21.join(configDir, "traces", "instructions-hook.jsonl");
+  return path20.join(configDir, "traces", "instructions-hook.jsonl");
 }
 async function appendTrace(file, entry) {
   try {
-    const previous = await readFile7(file, "utf8").catch(() => "");
+    const previous = await readFile5(file, "utf8").catch(() => "");
     const kept = previous.split("\n").filter((line4) => {
       try {
         return typeof JSON.parse(line4)?.outcome === "string";
@@ -14936,7 +15340,7 @@ async function appendTrace(file, entry) {
       }
     }).slice(-(TRACE_LIMIT - 1));
     kept.push(JSON.stringify(entry));
-    await mkdir5(path21.dirname(file), { recursive: true, mode: 448 });
+    await mkdir5(path20.dirname(file), { recursive: true, mode: 448 });
     const temporary = `${file}.${process.pid}.tmp`;
     await writeFile3(temporary, `${kept.join("\n")}
 `, { mode: 384 });
@@ -14964,7 +15368,7 @@ var Phases = class {
 };
 var show2 = (value, max = 200) => sanitizeDisplayText(value, max);
 async function samePath(a, b) {
-  const resolve = async (value) => realpath4(value).catch(() => path22.resolve(value));
+  const resolve = async (value) => realpath5(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;
 }
@@ -15216,11 +15620,11 @@ async function decide(run4) {
   if (common.kind !== "ok") {
     return unanswered(deadline, head, "read");
   }
-  const directory = path22.join(common.value, "fabric");
+  const directory = path21.join(common.value, "fabric");
   try {
     await mkdir6(directory, { recursive: true });
     return await withExclusiveLock(() => underLock(run4, facts), {
-      lockPath: path22.join(directory, "ff.lock"),
+      lockPath: path21.join(directory, "ff.lock"),
       staleMs: FF_LOCK_STALE_MS,
       waitMs: 0
     });
@@ -15230,7 +15634,7 @@ async function decide(run4) {
       return {
         outcome: error.abandoned ? {
           kind: "abandoned-lock",
-          lockPath: path22.join(directory, "ff.lock")
+          lockPath: path21.join(directory, "ff.lock")
         } : { kind: "locked" },
         head: now2.kind === "ok" ? now2.value : head
       };
@@ -15435,11 +15839,11 @@ function gatewayProbeFor(input) {
 }
 
 // src/lib/instructions/git-exclude.ts
-import { constants as constants2 } from "fs";
-import { lstat as lstat7, mkdir as mkdir7, open as open3 } from "fs/promises";
-import path23 from "path";
+import { constants as constants4 } from "fs";
+import { lstat as lstat6, mkdir as mkdir7, open as open4 } from "fs/promises";
+import path22 from "path";
 function relativeToTopLevel(toplevel, directory, file) {
-  return path23.relative(toplevel, path23.join(directory, file)).split(path23.sep).join("/");
+  return path22.relative(toplevel, path22.join(directory, file)).split(path22.sep).join("/");
 }
 function isLiteralEntry(entry) {
   return !/[\n\r*?[\]\\!]/.test(entry) && !entry.startsWith("#");
@@ -15473,16 +15877,16 @@ async function excludeLocalFiles(input) {
     if (file.kind !== "ok") {
       return { kind: "failed", entries: missing };
     }
-    await mkdir7(path23.dirname(file.value), { recursive: true });
-    const noFollow = constants2.O_NOFOLLOW;
-    const flags = constants2.O_RDWR | constants2.O_APPEND | (constants2.O_NONBLOCK ?? 0) | (noFollow ?? 0);
-    const handle = await open3(file.value, flags).catch((error) => {
+    await mkdir7(path22.dirname(file.value), { recursive: true });
+    const noFollow = constants4.O_NOFOLLOW;
+    const flags = constants4.O_RDWR | constants4.O_APPEND | (constants4.O_NONBLOCK ?? 0) | (noFollow ?? 0);
+    const handle = await open4(file.value, flags).catch((error) => {
       if (error.code !== "ENOENT") {
         throw error;
       }
-      return open3(
+      return open4(
         file.value,
-        flags | constants2.O_CREAT | constants2.O_EXCL
+        flags | constants4.O_CREAT | constants4.O_EXCL
       );
     });
     try {
@@ -15491,7 +15895,7 @@ async function excludeLocalFiles(input) {
         return { kind: "failed", entries: missing };
       }
       if (noFollow === void 0) {
-        const current = await lstat7(file.value, { bigint: true });
+        const current = await lstat6(file.value, { bigint: true });
         if (!current.isFile() || current.dev !== opened.dev || current.ino !== opened.ino) {
           return { kind: "failed", entries: missing };
         }
@@ -15515,8 +15919,8 @@ async function excludeLocalFiles(input) {
 }
 
 // src/lib/instructions/hook-launcher.ts
-import { mkdir as mkdir8, readFile as readFile8, rename as rename4, rm as rm3, writeFile as writeFile4 } from "fs/promises";
-import path24 from "path";
+import { mkdir as mkdir8, readFile as readFile6, rename as rename4, rm as rm3, writeFile as writeFile4 } 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.";
@@ -15524,7 +15928,7 @@ function deploymentFolder(origin) {
   return origin.replace(/^(https?):\/\//, "$1-").replace(/[^A-Za-z0-9.-]+/g, "-");
 }
 function bundleCopyPath(configDirectory, origin) {
-  return path24.join(
+  return path23.join(
     configDirectory,
     "cli",
     deploymentFolder(origin),
@@ -15532,11 +15936,11 @@ function bundleCopyPath(configDirectory, origin) {
   );
 }
 function samePath2(a, b) {
-  const [left, right] = [path24.resolve(a), path24.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 mkdir8(path24.dirname(destination), { recursive: true });
+  await mkdir8(path23.dirname(destination), { recursive: true });
   const temporary = `${destination}.${process.pid}.tmp`;
   await writeFile4(temporary, bytes, { mode: 420 });
   try {
@@ -15544,7 +15948,7 @@ async function writeCopy(bytes, destination) {
     return true;
   } catch (error) {
     await rm3(temporary, { force: true });
-    const existing = await readFile8(destination).catch(() => null);
+    const existing = await readFile6(destination).catch(() => null);
     if (existing === null) {
       throw error;
     }
@@ -15567,7 +15971,7 @@ async function resolveHookLauncher(input) {
     return { prefix: `node ${word}`, warning: null };
   }
   const current = await writeCopy(
-    await readFile8(input.bundle.scriptPath),
+    await readFile6(input.bundle.scriptPath),
     destination
   );
   return {
@@ -15620,8 +16024,8 @@ async function installHooks(input) {
 // src/lib/instructions/lesson-prompt.ts
 import { createHash as createHash11 } from "crypto";
 import { createReadStream } from "fs";
-import { mkdir as mkdir9, readdir as readdir2, stat as stat5, unlink as unlink2, writeFile as writeFile5 } from "fs/promises";
-import path25 from "path";
+import { mkdir as mkdir9, readdir as readdir2, stat as stat4, unlink as unlink2, writeFile as writeFile5 } from "fs/promises";
+import path24 from "path";
 import { createInterface } from "readline";
 function parseStopHookInput(text3) {
   let parsed;
@@ -15719,9 +16123,9 @@ async function pruneOldMarkers(markerDir, now2) {
   const cutoff = now2.getTime() - MARKER_MAX_AGE_MS;
   await Promise.all(
     entries.map(async (name) => {
-      const entryPath = path25.join(markerDir, name);
+      const entryPath = path24.join(markerDir, name);
       try {
-        const stats = await stat5(entryPath);
+        const stats = await stat4(entryPath);
         if (stats.mtimeMs < cutoff) {
           await unlink2(entryPath);
         }
@@ -15732,7 +16136,7 @@ async function pruneOldMarkers(markerDir, now2) {
 }
 async function markerExists(markerPath) {
   try {
-    await stat5(markerPath);
+    await stat4(markerPath);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -15779,7 +16183,7 @@ async function runLessonPromptInner(input) {
     debugLog(`marker prune failed: ${describeError(error)}`);
   });
   const key = markerKey(parsedInput.sessionId, projectId);
-  const markerPath = path25.join(input.markerDir, key);
+  const markerPath = path24.join(input.markerDir, key);
   if (await markerExists(markerPath)) {
     return { output: null, why: "already-asked" };
   }
@@ -15876,16 +16280,16 @@ function assertLockMatchesManifest(lock, manifest) {
   const published = new Map(
     manifest.map((entry) => [entry.path, entry.sha256])
   );
-  for (const [path38, entry] of Object.entries(lock.files)) {
-    const expected = published.get(path38);
+  for (const [path42, entry] of Object.entries(lock.files)) {
+    const expected = published.get(path42);
     if (expected === void 0) {
       refuseStaleLedger(
-        `it lists ${path38}, which version ${lock.snapshotVersion} does not contain`
+        `it lists ${path42}, which version ${lock.snapshotVersion} does not contain`
       );
     }
     if (expected !== entry.sha256) {
       refuseStaleLedger(
-        `its record of ${path38} is not the published file`
+        `its record of ${path42} is not the published file`
       );
     }
   }
@@ -16009,8 +16413,8 @@ async function materializePushChanges(input) {
         `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) {
+    const sha2562 = sha256Of(read.bytes);
+    if (read.bytes.length !== entry.size || sha2562 !== entry.sha256) {
       throw new Error(
         `Refusing to push: ${entry.path} changed after planning. Run \`${fabricCommand("instructions push")}\` again.`
       );
@@ -16700,7 +17104,7 @@ async function confirm(question, streams = { input: process.stdin, output: proce
 }
 
 // src/lib/instructions/resolve-project.ts
-import path26 from "path";
+import path25 from "path";
 var MAX_CANDIDATES = 8;
 var MAX_CANDIDATE_CHARS = 512;
 var MAX_LABEL_CHARS = 80;
@@ -16769,7 +17173,7 @@ async function resolveProjectFromCheckout(input) {
   for (const match of matches2) {
     if (await sameDirectory(
       destination,
-      path26.join(toplevel, match.rootPath)
+      path25.join(toplevel, match.rootPath)
     )) {
       here.push(match);
     }
@@ -16796,13 +17200,13 @@ import { spawn as spawn4 } from "child_process";
 import { createHash as createHash14 } from "crypto";
 import {
   mkdir as mkdir10,
-  readFile as readFile9,
-  realpath as realpath5,
+  readFile as readFile7,
+  realpath as realpath6,
   rm as rm4,
-  stat as stat6,
+  stat as stat5,
   writeFile as writeFile6
 } from "fs/promises";
-import path27 from "path";
+import path26 from "path";
 
 // src/lib/instructions/npm-tarball.ts
 import { gunzipSync } from "zlib";
@@ -16936,16 +17340,16 @@ function outOfTime(input, now2) {
   return input.deadlineAt - now2 < input.timing.budgetMs + input.timing.marginMs;
 }
 async function isKeptCopy(script, copy) {
-  const actual = await realpath5(copy).catch(() => null);
+  const actual = await realpath6(copy).catch(() => null);
   if (actual === null) {
     return false;
   }
-  const running = await realpath5(script).catch(() => path27.resolve(script));
+  const running = await realpath6(script).catch(() => path26.resolve(script));
   return samePath2(running, actual);
 }
 async function readState(file) {
   try {
-    const parsed = JSON.parse(await readFile9(file, "utf8"));
+    const parsed = JSON.parse(await readFile7(file, "utf8"));
     return typeof parsed.checkedAt === "number" && Number.isFinite(parsed.checkedAt) && typeof parsed.tarball === "string" ? { checkedAt: parsed.checkedAt, tarball: parsed.tarball } : null;
   } catch {
     return null;
@@ -16953,7 +17357,7 @@ async function readState(file) {
 }
 async function writeState(file, state) {
   try {
-    await mkdir10(path27.dirname(file), { recursive: true });
+    await mkdir10(path26.dirname(file), { recursive: true });
     await writeFile6(file, `${JSON.stringify(state)}
 `);
     return true;
@@ -16963,7 +17367,7 @@ async function writeState(file, state) {
 }
 async function claimSlot(file, now2, timing) {
   try {
-    await mkdir10(path27.dirname(file), { recursive: true });
+    await mkdir10(path26.dirname(file), { recursive: true });
     for (let attempt2 = 0; attempt2 < 2; attempt2 += 1) {
       try {
         await writeFile6(file, `${now2}
@@ -16973,7 +17377,7 @@ async function claimSlot(file, now2, timing) {
         if (error.code !== "EEXIST") {
           return false;
         }
-        const held = await stat6(file).catch(() => null);
+        const held = await stat5(file).catch(() => null);
         if (held !== null && now2 - held.mtimeMs < timing.budgetMs + timing.marginMs) {
           return false;
         }
@@ -17127,7 +17531,7 @@ async function refreshKeptCopy(input, deps = {}) {
   if (!await isKeptCopy(input.script, copy)) {
     return skipped2("not-a-kept-copy");
   }
-  const stateFile = path27.join(path27.dirname(copy), STATE_FILE);
+  const stateFile = path26.join(path26.dirname(copy), STATE_FILE);
   const previous = await readState(stateFile);
   if (previous !== null && askedRecently(previous, now2())) {
     return skipped2("checked-recently");
@@ -17230,19 +17634,19 @@ function selfUpdateLine(outcome) {
 }
 
 // src/lib/instructions/tools.ts
-import { stat as stat7 } from "fs/promises";
-import path28 from "path";
+import { stat as stat6 } from "fs/promises";
+import path27 from "path";
 var TOOLS = [
   { tool: "claude-code", directory: ".claude", command: "claude" },
   { tool: "codex", directory: ".codex", command: "codex" }
 ];
 async function isDirectory(target) {
-  return (await stat7(target).catch(() => null))?.isDirectory() ?? false;
+  return (await stat6(target).catch(() => null))?.isDirectory() ?? false;
 }
 async function detectTools(input) {
   const present = [];
   for (const facts of TOOLS) {
-    const found = await isDirectory(path28.join(input.root, facts.directory)) || input.home !== null && await isDirectory(path28.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);
     }
@@ -17251,7 +17655,7 @@ async function detectTools(input) {
 }
 
 // src/commands/instructions/init-plugin.ts
-import path35 from "path";
+import path38 from "path";
 
 // src/lib/memory/hooks.ts
 var HOOK_TIMEOUT_SECONDS2 = 15;
@@ -17277,6 +17681,9 @@ function kindOf(command) {
   if (args[0] === "instructions" && args[1] === "render") {
     return "plugin-render";
   }
+  if (args[0] === "instructions" && args[1] === "rules") {
+    return "rules-sync";
+  }
   return null;
 }
 function isOurs(hook, projectId, kinds) {
@@ -17332,6 +17739,18 @@ function desiredHooks(input) {
     ];
   }
   return [
+    {
+      event: "SessionStart",
+      kind: "rules-sync",
+      command: words(
+        input.launcher,
+        "instructions rules",
+        input.projectId,
+        binding,
+        ""
+      ),
+      timeout: RENDER_HOOK_TIMEOUT_SECONDS
+    },
     {
       event: "SessionStart",
       kind: "memory-pull",
@@ -17401,7 +17820,12 @@ function without(groups, projectId, kinds) {
 }
 async function installPluginHooks(input) {
   const wanted = desiredHooks(input);
-  const allKinds = ["memory-pull", "memory-push", "plugin-render"];
+  const allKinds = [
+    "memory-pull",
+    "memory-push",
+    "plugin-render",
+    "rules-sync"
+  ];
   return updateHookConfig({
     root: input.root,
     tool: input.tool,
@@ -17438,7 +17862,7 @@ async function installPluginHooks(input) {
 }
 
 // src/lib/memory/project-root.ts
-import path29 from "path";
+import path28 from "path";
 var MARKER_RELATIVE_PATH = ".fabric/project.json";
 var MARKER_VERSION = 1;
 var MAX_MARKER_BYTES = 64 * 1024;
@@ -17478,13 +17902,13 @@ async function writeProjectMarker(root, marker) {
   });
 }
 async function findProjectRoot(start) {
-  let current = path29.resolve(start);
+  let current = path28.resolve(start);
   for (; ; ) {
     const marker = await readMarker(current);
     if (marker !== null) {
       return { root: current, marker };
     }
-    const parent = path29.dirname(current);
+    const parent = path28.dirname(current);
     if (parent === current) {
       return null;
     }
@@ -17492,7 +17916,7 @@ async function findProjectRoot(start) {
   }
 }
 function comparable(folder) {
-  const resolved = path29.resolve(folder);
+  const resolved = path28.resolve(folder);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function samePath3(left, right) {
@@ -17503,7 +17927,7 @@ function gitToplevelIsTheProjects(marker, root, found) {
 }
 
 // src/lib/memory/runtime.ts
-import path30 from "path";
+import path29 from "path";
 var GIT_BUDGET_MS2 = 8e3;
 var MemoryNotSignedIn = class extends CliFailure {
   constructor(origin) {
@@ -17564,7 +17988,7 @@ function gitFor(root, marker) {
 async function createRuntime(options, signal) {
   const origin = originOf3(options.baseUrl);
   const start = await resolveExistingRoot(
-    path30.resolve(options.dest ?? process.cwd())
+    path29.resolve(options.dest ?? process.cwd())
   );
   const found = await findProjectRoot(start);
   if (found === null) {
@@ -17604,44 +18028,95 @@ async function createRuntime(options, signal) {
   };
 }
 
-// src/lib/plugin/gateway.ts
-var REMOVE_TIMEOUT_MS = 3e4;
-async function removeLocalClaudeGateway(input) {
-  const name = serverNameFor(input.projectId);
-  const inspected = await inspectServers({
-    tool: "claude-code",
-    origin: input.origin,
-    projectId: input.projectId,
-    cwd: input.cwd,
-    home: input.home,
-    env: input.env,
-    platform: input.platform
-  });
-  if (inspected.state !== "read") {
-    return { kind: "unchecked" };
-  }
-  const ours = inspected.servers.some(
-    (server) => server.scope === "local" && server.name === name && server.kind === "this-project"
-  );
-  if (!ours) {
-    return { kind: "none" };
+// src/lib/plugin/codex-install.ts
+import { stat as stat7 } from "fs/promises";
+import path32 from "path";
+
+// src/lib/plugin/instruction-access.ts
+var INSTRUCTION_ACCESS_SKILL = "fabric-instruction-access";
+var INSTRUCTION_CATALOG = `skills/${INSTRUCTION_ACCESS_SKILL}/catalog.json`;
+function instructionAccessBootstrap(pluginName, tool) {
+  const skill = tool === "claude-code" ? `/${pluginName}:${INSTRUCTION_ACCESS_SKILL}` : INSTRUCTION_ACCESS_SKILL;
+  return `Fabric instruction access for plugin ${pluginName}: Load the generated ${skill} skill from this plugin before following references or choosing rules for a task. Its catalog lists every source instruction path, including rules beyond automatic delivery limits and files outside plugin folders. Read applicable rules and referenced files from their mapped local copies or this plugin's Fabric MCP server. Resolve @ references and relative paths in the original instruction tree, not by guessing paths in the user's checkout.
+`;
+}
+function instructionCatalog(input) {
+  const paths = input.listed.map((entry) => entry.path);
+  if (paths.some((entry) => !checkRelativePath(entry).ok) || findCollision(paths) !== null) {
+    throw new Error(
+      "The instruction catalog contains unsafe or colliding paths."
+    );
   }
-  const removed = await input.run(
-    "claude",
-    ["mcp", "remove", name, "--scope", "local"],
-    { cwd: input.cwd, timeoutMs: REMOVE_TIMEOUT_MS }
-  );
-  return removed.kind === "exited" && removed.code === 0 ? { kind: "removed", name } : { kind: "failed", name };
+  const entries = [...input.listed].sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0).map((entry) => ({
+    path: entry.path,
+    size: entry.size,
+    isText: entry.isText,
+    kind: entry.kind,
+    blobId: entry.blobId,
+    sha256: entry.sha256,
+    mode: entry.mode,
+    localPath: input.localPaths.get(entry.path) ?? null
+  }));
+  return `${JSON.stringify(
+    {
+      version: 1,
+      projectId: input.projectId,
+      source: input.source,
+      entries
+    },
+    null,
+    2
+  )}
+`;
+}
+function instructionAccessSkill() {
+  return [
+    "---",
+    `name: ${INSTRUCTION_ACCESS_SKILL}`,
+    "description: Discover and read this project's original coding instructions, referenced files and rules on demand, including files outside the plugin and rules beyond automatic delivery limits. Use before selecting applicable guidance or following instruction references.",
+    "---",
+    "",
+    "# Fabric instruction access",
+    "",
+    "Search catalog.json beside this SKILL.md with your file search tool and read only matching entries, or use the MCP query below. It contains metadata for every listed instruction file, not file contents, and can be large. Do not load the whole catalog or tree into context. The catalog's projectId and source identify the instructions used to build this plugin; the plugin version is a render hash, not a repository pin.",
+    "",
+    "A non-null localPath is relative to this installed plugin's root (two directories above this skill folder). Read that file for the original bytes. A null localPath means the file is not stored in the plugin; automatic rule caps and unsupported layouts do not remove its catalog entry. Fabric reserves the fabric-instruction-access and fabric-living-memory skill folders; source files displaced by those names remain discoverable here and through MCP.",
+    "",
+    "## Select all applicable rules",
+    "",
+    "Automatic rule delivery can be incomplete. Find rule entries by kind and original rules/ or .claude/rules/ paths. Search the passive rule files under instructions/source/ and inspect the paths: frontmatter of each original rule to determine scope. Before affected work, read every unscoped rule and every rule whose paths match the files you will work on, including rules beyond automatic delivery limits. A filename or topic search alone cannot establish applicability. If applicable instructions cannot be read completely, report the blocked work instead of silently omitting them.",
+    "",
+    "## Read through this plugin's Fabric MCP server",
+    "",
+    "Use fabric_list_project_instructions with projectId from the catalog and query to match a path. For repository sources, also pass generation and commitSha from catalog.source. Optional prefix filters a folder; limit (1 to 500, default 200) controls the page. Read direct.generation and direct.commitSha in the response and check they match the catalog. Follow page.nextCursor by passing it as cursor with the same filters, generation and commitSha until nextCursor is null. An incomplete listing, refusal or unavailable repository is not an empty tree.",
+    "",
+    "Use fabric_get_project_instruction with projectId, path exactly as listed, offset: 0 and maxLength: 50000 (up to 200000). For a repository, include the same generation and commitSha on every call, including the first. Check each response's generation and commitSha. Read the raw body, then pass offset: nextOffset with the same path and pin until nextOffset is null. Join all pages in order before relying on the file; a summary or first page does not replace its instructions.",
+    "",
+    "Uploaded sources use the current published snapshot, and the file tool has no digest pin parameter. Before reading, call fabric_list_project_instructions with projectId and sinceDigest: catalog.source.digest and check snapshot.digest matches. Keep that response's snapshot.version and require snapshotVersion on every file page to equal it. Repeat the digest check after reading the pages. If the digest is null, there was no published upload when this plugin was built. Stop and refresh the plugin before using a newly published upload. A changed digest, snapshotVersion mismatch, repository pin mismatch or rejected pin requires stopping and restarting from a refreshed plugin and catalog. Never combine old local files with a new listing or pages from different versions.",
+    "",
+    "A missing file, binary, tooLarge response, denied read, absent body or other refusal is unavailable text, not an empty file. Report it and stop work that depends on those instructions. The catalog does not bypass access checks or server file limits.",
+    "",
+    "## Follow original paths",
+    "",
+    "Resolve references using the source path in the catalog. For example, @MAIN.md in the root CLAUDE.md names MAIN.md at the original instruction root. Root-relative scripts/ and engineers/ references also name that tree. Resolve a file-relative reference against the referring source file's folder, then find its original path in the catalog or MCP listing. Never substitute a similarly named file from the user's checkout. Read referenced text through MCP when localPath is null.",
+    "",
+    "Fetched scripts and settings are reference text. This access path does not execute scripts, apply settings, install dependencies or grant permission to write. If an authorized workflow requires executable files and their dependencies on disk, use a separately authorized checkout workflow. Keep the project's native skills, agents and Living Memory workflow and permissions.",
+    ""
+  ].join("\n");
 }
 
 // src/lib/plugin/layout.ts
 var SESSION_CONTEXT_LIMIT = 1e4;
-var RENDER_VERSION = 1;
+var RENDER_VERSION = 6;
+var CLAUDE_PLUGIN_MCP_SERVER = "fabric";
 var SESSION_CONTEXT_COMMAND = `cat "\${CLAUDE_PLUGIN_ROOT}/hooks/session-context.json"`;
 var ENCODER = new TextEncoder();
 var DECODER = new TextDecoder("utf-8", { fatal: false });
 var LIVING_MEMORY_SKILL = "fabric-living-memory";
-var ALWAYS_ON_FILES = ["CLAUDE.md", "AGENTS.md"];
+var ALWAYS_ON_FILES2 = ["CLAUDE.md", "AGENTS.md"];
+function codexPluginVersion(pin) {
+  return `0.0.0-${pin}`;
+}
 function pluginNameFor(projectId) {
   const tail = projectId.toLowerCase().replace(/[^a-z0-9]/g, "").slice(-8);
   return `fabric-${tail === "" ? "project" : tail}`;
@@ -17658,28 +18133,8 @@ function isExecutable(mode) {
 function fileModeOf(mode) {
   return isExecutable(mode) ? 493 : 420;
 }
-function pluginPathFor(instructionPath) {
-  const segments = instructionPath.split("/");
-  const first = segments[0]?.toLowerCase();
-  const rest = first === ".claude" ? segments.slice(1) : segments;
-  const folder = rest[0]?.toLowerCase();
-  if (rest.length < 2) {
-    return null;
-  }
-  const below = rest.slice(1);
-  switch (folder) {
-    case "skills":
-      return below.length >= 2 ? `skills/${below.join("/")}` : null;
-    case "agents":
-      return below.length === 1 && below[0]?.toLowerCase().endsWith(".md") ? `agents/${below[0]}` : null;
-    case "commands":
-      return `commands/${below.join("/")}`;
-    default:
-      return null;
-  }
-}
 function alwaysOnFile(files, tool = "claude-code") {
-  const order = tool === "codex" ? ["AGENTS.md", "CLAUDE.md"] : ALWAYS_ON_FILES;
+  const order = tool === "codex" ? ["AGENTS.md", "CLAUDE.md"] : ALWAYS_ON_FILES2;
   for (const name of order) {
     const found = files.find((entry) => entry.path === name);
     if (found !== void 0) {
@@ -17696,8 +18151,8 @@ function truncationNotice(file, pluginName) {
 
 [Fabric: this file is longer than the ${SESSION_CONTEXT_LIMIT.toLocaleString("en-US")} characters a session start can carry, so it was cut here. Read the rest in full before relying on it: instructions/${file} inside the ${pluginName} plugin, for example ~/.claude/plugins/cache/${pluginName}/${pluginName}/*/instructions/${file}]`;
 }
-function sessionContext(file, text3, pluginName) {
-  const heading = `Coding instructions for this project (${file}, from Fabric):
+function sessionContext(file, text3, pluginName, guidance = "") {
+  const heading = `${guidance}${guidance === "" ? "" : "\n"}Coding instructions for this project (${file}, from Fabric):
 
 `;
   const whole = heading + text3;
@@ -17726,7 +18181,7 @@ function folderLine(folder) {
   return `- \`${folder.folder}/\` -- ${where}`;
 }
 function livingMemorySkill(memory, tool) {
-  const delivery = tool === "claude-code" ? "Fabric delivers them: a hook sends new and changed files when your turn ends, and brings other people's changes in when a session starts. Do not run git for these files." : "Fabric delivers them when the next session starts (this tool has no end-of-turn hook). To deliver sooner, call the `fabric_memory_write` tool of the Fabric MCP server. Do not run git for these files.";
+  const delivery = tool === "claude-code" ? "Fabric delivers them: a hook sends new and changed files when your turn ends, and brings other people's changes in when a session starts. Do not run git for these files." : "Fabric delivers them when the next session starts (this tool has no end-of-turn hook). Do not run git for these files.";
   const header = [
     "---",
     `name: ${LIVING_MEMORY_SKILL}`,
@@ -17739,7 +18194,7 @@ function livingMemorySkill(memory, tool) {
   let body;
   if (memory.state === "unavailable") {
     body = [
-      "The list of this project's memory folders could not be read when this plugin was built. Run `fabric memory status` to see them, and do not save memory files until you know the folder."
+      "The list of this project's memory folders could not be read when this plugin was built. Call the `fabric_memory_targets` tool of the Fabric MCP server to see them, and do not save memory files until you know the folder."
     ];
   } else if (memory.folders.length === 0) {
     body = [
@@ -17753,105 +18208,137 @@ function livingMemorySkill(memory, tool) {
       "",
       delivery,
       "",
-      "Never save memory files anywhere else. A file in a pull-request folder is not part of the project's Living Memory until the pull request is merged."
+      "Never save memory files anywhere else. A file in a pull-request folder is not part of the project's Living Memory until the pull request is merged.",
+      "",
+      "Keep one work item's specs and tasks together in `docs/ai/specs/<work-item-id>/`, inside one of the folders above. To resume a work item, list that folder with the `fabric_memory_read` tool (pass `prefix`, then a file's `path` to read it), or read the local mirror: the same files, at the same paths, in the project folder.",
+      "",
+      "To check a delivery, read the `writeId` of each entry in the `outbox` of `.fabric/memory.lock` and pass it to the `fabric_memory_write_status` tool."
     ];
   }
   return `${[...header, ...body].join("\n")}
 `;
 }
-function descriptionFor() {
-  return "Coding instructions for a Fabric project, rendered from the project's published instructions.";
+function descriptionFor(projectId, gatewayUrl) {
+  let host = gatewayUrl;
+  try {
+    host = new URL(gatewayUrl).host;
+  } catch {
+  }
+  return `Coding instructions for Fabric project ${projectId} on ${host}, rendered from its published instructions.`;
 }
-function mcpConfiguration(tool, serverName, url) {
-  return json({
-    mcpServers: {
-      [serverName]: {
-        type: tool === "codex" ? "streamable-http" : "http",
-        url
-      }
-    }
-  });
+function mcpConfiguration(serverName, url) {
+  return json({ mcpServers: { [serverName]: { type: "http", url } } });
 }
 function buildPlugin(inputs) {
   const name = pluginNameFor(inputs.projectId);
   const out = /* @__PURE__ */ new Map();
-  const put = (path38, bytes, mode = 420) => {
-    out.set(path38, { path: path38, bytes, mode });
+  const put = (path42, bytes, mode = 420) => {
+    out.set(path42, { path: path42, bytes, mode });
   };
+  const sourceAtTarget = /* @__PURE__ */ new Map();
   for (const file of [...inputs.files].sort(
     (a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0
   )) {
-    const target = pluginPathFor(file.path);
-    if (target !== null) {
-      put(target, file.bytes, fileModeOf(file.mode));
+    const nativeTarget = pluginPathFor(file.path);
+    const target = file.path === "CLAUDE.md" || file.path === "AGENTS.md" ? `instructions/${file.path}` : projectRulePathFor(file.path) !== null ? `instructions/source/${file.path}` : nativeTarget;
+    if (target === null || [LIVING_MEMORY_SKILL, INSTRUCTION_ACCESS_SKILL].some(
+      (reserved) => target.toLowerCase().startsWith(`skills/${reserved}/`)
+    )) {
+      continue;
     }
+    put(
+      target,
+      file.bytes,
+      nativeTarget === null ? 420 : fileModeOf(file.mode)
+    );
+    sourceAtTarget.set(target, file.path);
   }
+  const localPaths = new Map(
+    [...sourceAtTarget].map(([target, source]) => [source, target])
+  );
   put(
     `skills/${LIVING_MEMORY_SKILL}/SKILL.md`,
     bytesOf(livingMemorySkill(inputs.memory, inputs.tool))
   );
-  for (const path38 of [...out.keys()]) {
-    if (path38.startsWith(`skills/${LIVING_MEMORY_SKILL}/`) && path38 !== `skills/${LIVING_MEMORY_SKILL}/SKILL.md`) {
-      out.delete(path38);
-    }
-  }
+  put(
+    `skills/${INSTRUCTION_ACCESS_SKILL}/SKILL.md`,
+    bytesOf(instructionAccessSkill())
+  );
+  put(
+    INSTRUCTION_CATALOG,
+    bytesOf(
+      instructionCatalog({
+        projectId: inputs.projectId,
+        source: inputs.instructionAccess.source,
+        listed: inputs.instructionAccess.listed,
+        localPaths
+      })
+    )
+  );
   if (inputs.tool === "claude-code") {
     put(
       ".claude-plugin/plugin.json",
       json({
         name,
-        description: descriptionFor(),
+        description: descriptionFor(
+          inputs.projectId,
+          inputs.gatewayUrl
+        ),
         author: { name: "Fabric" }
       })
     );
     put(
       ".mcp.json",
-      mcpConfiguration("claude-code", name, inputs.gatewayUrl)
+      mcpConfiguration(CLAUDE_PLUGIN_MCP_SERVER, inputs.gatewayUrl)
     );
     const always = alwaysOnFile(inputs.files);
-    if (always !== null) {
-      put(`instructions/${always.file}`, bytesOf(always.text));
-      put(
-        "hooks/session-context.json",
-        json({
-          hookSpecificOutput: {
-            hookEventName: "SessionStart",
-            additionalContext: sessionContext(
-              always.file,
-              always.text,
-              name
-            )
-          }
-        })
-      );
-      put(
-        "hooks/hooks.json",
-        json({
-          hooks: {
-            SessionStart: [
-              {
-                hooks: [
-                  {
-                    type: "command",
-                    command: SESSION_CONTEXT_COMMAND
-                  }
-                ]
-              }
-            ]
-          }
-        })
-      );
-    }
+    const guidance = instructionAccessBootstrap(name, inputs.tool);
+    put(
+      "hooks/session-context.json",
+      json({
+        hookSpecificOutput: {
+          hookEventName: "SessionStart",
+          additionalContext: always === null ? guidance : sessionContext(
+            always.file,
+            always.text,
+            name,
+            guidance
+          )
+        }
+      })
+    );
+    put(
+      "hooks/hooks.json",
+      json({
+        hooks: {
+          SessionStart: [
+            {
+              hooks: [
+                {
+                  type: "command",
+                  command: SESSION_CONTEXT_COMMAND
+                }
+              ]
+            }
+          ]
+        }
+      })
+    );
   } else {
     put(
-      "plugin.json",
+      ".codex-plugin/plugin.json",
       json({
         name,
-        version: `0.0.0-${inputs.pin}`,
-        description: descriptionFor()
+        version: codexPluginVersion(inputs.pin),
+        description: descriptionFor(
+          inputs.projectId,
+          inputs.gatewayUrl
+        ),
+        skills: "./skills/",
+        mcpServers: "./.mcp.json"
       })
     );
-    put("mcp.json", mcpConfiguration("codex", name, inputs.gatewayUrl));
+    put(".mcp.json", mcpConfiguration(name, inputs.gatewayUrl));
   }
   return [...out.values()].sort(
     (a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0
@@ -17875,8 +18362,113 @@ function isFabricAgentsOverride(text3) {
 }
 
 // src/lib/plugin/register.ts
-import { mkdir as mkdir11, readFile as readFile10, rename as rename5, rm as rm5, writeFile as writeFile7 } from "fs/promises";
+import { mkdir as mkdir11, readFile as readFile9, rename as rename5, rm as rm5, writeFile as writeFile7 } from "fs/promises";
 import path31 from "path";
+
+// src/lib/plugin/binding.ts
+import { readFile as readFile8 } from "fs/promises";
+import path30 from "path";
+var BINDING_FILE = ".fabric-binding.json";
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function originOf4(value) {
+  try {
+    return new URL(value).origin;
+  } catch {
+    return null;
+  }
+}
+function bindingText(binding) {
+  return `${JSON.stringify(binding, null, 2)}
+`;
+}
+async function readJson(file) {
+  try {
+    return JSON.parse(await readFile8(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function valueAfter(words2, flag) {
+  const at = words2.indexOf(flag);
+  return at >= 0 ? words2[at + 1] ?? null : null;
+}
+async function bindingFromSidecar(directory) {
+  const parsed = await readJson(path30.join(directory, BINDING_FILE));
+  if (!isRecord6(parsed) || typeof parsed.projectId !== "string") {
+    return null;
+  }
+  return {
+    projectId: parsed.projectId,
+    origin: typeof parsed.origin === "string" ? parsed.origin : null
+  };
+}
+async function legacyClaudeBinding(directory) {
+  const parsed = await readJson(
+    path30.join(directory, ".claude-plugin", "marketplace.json")
+  );
+  if (!isRecord6(parsed) || !Array.isArray(parsed.plugins)) {
+    return null;
+  }
+  for (const plugin of parsed.plugins) {
+    const source = isRecord6(plugin) ? plugin.source : null;
+    const command = isRecord6(source) ? source.command : null;
+    if (typeof command !== "string") {
+      continue;
+    }
+    const words2 = command.split(/\s+/);
+    const projectId = valueAfter(words2, "--project");
+    if (projectId !== null) {
+      const baseUrl = valueAfter(words2, "--base-url");
+      return {
+        projectId,
+        origin: baseUrl === null ? null : originOf4(baseUrl)
+      };
+    }
+  }
+  return null;
+}
+var GATEWAY_URL = /^(.+)\/api\/mcp-gateway\/projects\/([A-Za-z0-9_-]+)\/?$/;
+async function legacyCodexBinding(directory) {
+  const parsed = await readJson(path30.join(directory, ".mcp.json"));
+  if (!isRecord6(parsed) || !isRecord6(parsed.mcpServers)) {
+    return null;
+  }
+  for (const server of Object.values(parsed.mcpServers)) {
+    const url = isRecord6(server) ? server.url : null;
+    if (typeof url !== "string") {
+      continue;
+    }
+    const projectId = GATEWAY_URL.exec(url)?.[2];
+    if (projectId !== void 0) {
+      return { projectId, origin: originOf4(url) };
+    }
+  }
+  return null;
+}
+async function readBinding(directory, location) {
+  return await bindingFromSidecar(directory) ?? (location === "claude-marketplace" ? await legacyClaudeBinding(directory) : await legacyCodexBinding(directory));
+}
+async function assertLocationFree(input) {
+  const existing = await readBinding(input.directory, input.location);
+  if (existing === null) {
+    return;
+  }
+  const otherProject = existing.projectId !== input.wanted.projectId;
+  const otherDeployment = existing.origin !== null && input.wanted.origin !== null && existing.origin !== input.wanted.origin;
+  if (!otherProject && !otherDeployment) {
+    return;
+  }
+  const name = pluginNameFor(input.wanted.projectId);
+  const removal = input.location === "claude-marketplace" ? `run \`claude plugin uninstall ${name}@${name} --scope local\` in the folders that use it, then delete ${input.directory}` : `delete ${input.directory} and remove ${name} from the Codex marketplace file that lists it`;
+  throw new CliFailure(
+    `The plugin name ${name} is already taken by project ${existing.projectId}${existing.origin === null ? "" : ` on ${existing.origin}`}, so it was not changed for project ${input.wanted.projectId}${input.wanted.origin === null ? "" : ` on ${input.wanted.origin}`}. Replacing it would repoint the folders already set up for that project. To use this one, remove the other setup first: ${removal}, then run this again.`,
+    7
+  );
+}
+
+// src/lib/plugin/register.ts
 var COMMAND_MAX_LENGTH = 500;
 var RENDER_TIMEOUT_SECONDS = 120;
 function marketplaceNameFor(projectId) {
@@ -17936,7 +18528,7 @@ function claudeMarketplace(input) {
     plugins: [
       {
         name: pluginNameFor(input.projectId),
-        description: "Coding instructions for a Fabric project, rendered on demand.",
+        description: descriptionFor(input.projectId, input.origin),
         source: {
           source: "command",
           command: input.command,
@@ -17952,6 +18544,19 @@ async function writeClaudeMarketplace(input) {
     input.cacheDirectory,
     input.projectId
   );
+  const binding = {
+    projectId: input.projectId,
+    origin: originOf4(input.origin)
+  };
+  await assertLocationFree({
+    directory,
+    location: "claude-marketplace",
+    wanted: binding
+  });
+  await writeAtomically(
+    path31.join(directory, BINDING_FILE),
+    bindingText(binding)
+  );
   await writeAtomically(
     path31.join(directory, ".claude-plugin", "marketplace.json"),
     `${JSON.stringify(claudeMarketplace(input), null, 2)}
@@ -17998,7 +18603,7 @@ var CODEX_MARKETPLACE_RELATIVE = path31.join(
   "marketplace.json"
 );
 var CODEX_MARKETPLACE_NAME = "personal";
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function withCodexPlugin(marketplace, input) {
@@ -18016,7 +18621,7 @@ function withCodexPlugin(marketplace, input) {
 async function readCodexMarketplace(file) {
   let raw;
   try {
-    raw = await readFile10(file, "utf8");
+    raw = await readFile9(file, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") {
       return {
@@ -18039,7 +18644,7 @@ async function readCodexMarketplace(file) {
       7
     );
   }
-  if (!isRecord6(parsed) || typeof parsed.name !== "string" || !Array.isArray(parsed.plugins) || !parsed.plugins.every(isRecord6)) {
+  if (!isRecord7(parsed) || typeof parsed.name !== "string" || !Array.isArray(parsed.plugins) || !parsed.plugins.every(isRecord7)) {
     throw new CliFailure(
       `${file} does not look like a plugin marketplace (a "name" and a "plugins" list). It was left untouched.`,
       7
@@ -18068,7 +18673,7 @@ async function registerCodexPlugin(input) {
   });
   const before = JSON.stringify(marketplace);
   const changed = JSON.stringify(next) !== before;
-  if (changed || !await readFile10(file).then(
+  if (changed || !await readFile9(file).then(
     () => true,
     () => false
   )) {
@@ -18081,13 +18686,24 @@ async function registerCodexPlugin(input) {
     changed
   };
 }
+async function codexMarketplaceListing(input) {
+  try {
+    const { marketplace, existed } = await readCodexMarketplace(
+      path31.join(input.home, CODEX_MARKETPLACE_RELATIVE)
+    );
+    const name = pluginNameFor(input.projectId);
+    return existed && marketplace.plugins.some((plugin) => plugin.name === name) ? marketplace.name : null;
+  } catch {
+    return null;
+  }
+}
 async function writeAgentsOverride(input) {
   const file = path31.join(input.root, "AGENTS.override.md");
-  const existing = await readFile10(file, "utf8").catch(() => null);
+  const existing = await readFile9(file, "utf8").catch(() => null);
   if (existing !== null && !isFabricAgentsOverride(existing)) {
     return { kind: "left-alone", file };
   }
-  const tracked = await readFile10(
+  const tracked = await readFile9(
     path31.join(input.root, "AGENTS.md"),
     "utf8"
   ).catch(() => null);
@@ -18102,31 +18718,467 @@ async function writeAgentsOverride(input) {
   return { kind: "written", file };
 }
 
-// src/commands/instructions/render.ts
-import os2 from "os";
-import path34 from "path";
+// src/lib/plugin/codex-install.ts
+var INSTALL_TIMEOUT_MS = 12e4;
+var REFRESH_TIMEOUT_MS = 25e3;
+function codexPluginReference(projectId, marketplaceName) {
+  return `${pluginNameFor(projectId)}@${marketplaceName}`;
+}
+async function installCodexPlugin(input) {
+  const args = [
+    "plugin",
+    "add",
+    codexPluginReference(input.projectId, input.marketplaceName)
+  ];
+  const result = await input.run("codex", args, {
+    cwd: input.cwd,
+    timeoutMs: INSTALL_TIMEOUT_MS
+  });
+  return result.kind === "exited" && result.code === 0 ? { kind: "installed" } : { kind: "manual", line: pasteableLine(["codex", ...args]) };
+}
+async function refreshCodexInstall(input) {
+  try {
+    const marketplaceName = await codexMarketplaceListing(input);
+    if (marketplaceName === null) {
+      return;
+    }
+    const installed = path32.join(
+      input.codexHome,
+      "plugins",
+      "cache",
+      marketplaceName,
+      pluginNameFor(input.projectId),
+      input.version
+    );
+    if (await stat7(installed).then(
+      (found) => found.isDirectory(),
+      () => false
+    )) {
+      return;
+    }
+    await input.run(
+      "codex",
+      [
+        "plugin",
+        "add",
+        codexPluginReference(input.projectId, marketplaceName)
+      ],
+      { cwd: input.cwd, timeoutMs: REFRESH_TIMEOUT_MS }
+    );
+  } catch {
+  }
+}
+
+// src/lib/plugin/gateway.ts
+var REMOVE_TIMEOUT_MS = 3e4;
+async function removeLocalClaudeGateway(input) {
+  const name = serverNameFor(input.projectId);
+  const inspected = await inspectServers({
+    tool: "claude-code",
+    origin: input.origin,
+    projectId: input.projectId,
+    cwd: input.cwd,
+    home: input.home,
+    env: input.env,
+    platform: input.platform
+  });
+  if (inspected.state !== "read") {
+    return { kind: "unchecked" };
+  }
+  const ours = inspected.servers.some(
+    (server) => server.scope === "local" && server.name === name && server.kind === "this-project"
+  );
+  if (!ours) {
+    return { kind: "none" };
+  }
+  const removed = await input.run(
+    "claude",
+    ["mcp", "remove", name, "--scope", "local"],
+    { cwd: input.cwd, timeoutMs: REMOVE_TIMEOUT_MS }
+  );
+  return removed.kind === "exited" && removed.code === 0 ? { kind: "removed", name } : { kind: "failed", name };
+}
+
+// src/lib/plugin/rules-sync.ts
+import { createHash as createHash15 } from "crypto";
+import { rmdir as rmdir2 } from "fs/promises";
+import path33 from "path";
+
+// src/lib/plugin/rules.ts
+var RULES_MAX_FILES = 64;
+var RULES_MAX_BYTES = 256 * 1024;
+var AGENTS_RULES_LIMIT = 24e3;
+var byPath4 = (a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0;
+function selectRules(read, tool) {
+  const bytesOf2 = new Map(read.files.map((file) => [file.path, file.bytes]));
+  const seen = /* @__PURE__ */ new Set();
+  const rules = [];
+  for (const rule of [...planPluginFiles(read.listed, tool).rules].sort(
+    byPath4
+  )) {
+    const bytes = bytesOf2.get(rule.path);
+    if (bytes === void 0 || seen.has(rule.as)) {
+      continue;
+    }
+    seen.add(rule.as);
+    rules.push({ path: rule.as, source: rule.path, bytes });
+  }
+  return rules.sort(byPath4);
+}
+function capRules(rules) {
+  const kept = [];
+  let total = 0;
+  for (const rule of rules) {
+    if (kept.length >= RULES_MAX_FILES || total + rule.bytes.byteLength > RULES_MAX_BYTES) {
+      break;
+    }
+    kept.push(rule);
+    total += rule.bytes.byteLength;
+  }
+  return { kept, omitted: rules.length - kept.length };
+}
+var DECODER2 = new TextDecoder("utf-8", { fatal: false });
+function unquote(value) {
+  const trimmed = value.trim();
+  return /^(["']).*\1$/.test(trimmed) ? trimmed.slice(1, -1) : trimmed;
+}
+function parseRule(text3) {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)/.exec(text3);
+  if (match === null) {
+    return { paths: [], body: text3 };
+  }
+  const paths = [];
+  const lines2 = (match[1] ?? "").split(/\r?\n/);
+  for (let index = 0; index < lines2.length; index++) {
+    const head = /^paths:\s*(.*)$/.exec(lines2[index] ?? "");
+    if (head === null) {
+      continue;
+    }
+    const inline = (head[1] ?? "").trim();
+    if (inline.startsWith("[")) {
+      paths.push(
+        ...inline.replace(/^\[|\]$/g, "").split(",").map(unquote).filter((entry) => entry !== "")
+      );
+    } else if (inline !== "") {
+      paths.push(unquote(inline));
+    } else {
+      for (const next of lines2.slice(index + 1)) {
+        const item = /^\s*-\s+(.*)$/.exec(next);
+        if (item === null) {
+          break;
+        }
+        paths.push(unquote(item[1] ?? ""));
+      }
+    }
+    break;
+  }
+  return { paths, body: text3.slice(match[0].length) };
+}
+function agentsRulesSection(rules) {
+  if (rules.length === 0) {
+    return "";
+  }
+  const head = "## Project rules";
+  const parts = [];
+  let used = head.length;
+  let included = 0;
+  for (const rule of rules) {
+    const { paths, body } = parseRule(DECODER2.decode(rule.bytes));
+    const scope = paths.length === 0 ? "" : `
+_Applies when working on: ${paths.join(", ")}_
+`;
+    const block = `### Rule: ${rule.path}${scope}
+${body.trim()}`;
+    if (used + block.length + 2 > AGENTS_RULES_LIMIT) {
+      break;
+    }
+    parts.push(block);
+    used += block.length + 2;
+    included++;
+  }
+  const omitted = rules.length - included;
+  if (omitted > 0) {
+    parts.push(
+      `[Fabric: ${omitted} more rule ${omitted === 1 ? "file was" : "files were"} left out to keep this file short: ${rules.slice(included).map((rule) => rule.path).join(
+        ", "
+      )}. Load fabric-instruction-access to find their original source paths and read mapped local copies or available text through the project's Fabric MCP tools.]`
+    );
+  }
+  return `${head}
+
+${parts.join("\n\n")}`;
+}
+function agentsInstructions(memoryText, rules) {
+  const sections = [
+    memoryText === null ? "" : memoryText.trimEnd(),
+    agentsRulesSection(rules)
+  ].filter((section) => section !== "");
+  return sections.length === 0 ? null : sections.join("\n\n");
+}
+
+// src/lib/plugin/rules-sync.ts
+var MARKER_NAME = ".fabric-managed.json";
+var MARKER_VERSION2 = 1;
+var MAX_MARKER_BYTES2 = 256 * 1024;
+var MAX_RULE_READ_BYTES = 2 * 1024 * 1024;
+function rulesFolderFor(projectId) {
+  return `.claude/rules/${pluginNameFor(projectId)}`;
+}
+var sha256 = (bytes) => createHash15("sha256").update(bytes).digest("hex");
+async function readMarker2(root, folder) {
+  try {
+    const read = await readFileSafely(root, `${folder}/${MARKER_NAME}`, {
+      maxBytes: MAX_MARKER_BYTES2
+    });
+    if (read === null) {
+      return {};
+    }
+    const parsed = JSON.parse(
+      new TextDecoder().decode(read.bytes)
+    );
+    const files = parsed?.files;
+    if (parsed?.version !== MARKER_VERSION2 || typeof files !== "object" || files === null || Array.isArray(files)) {
+      return {};
+    }
+    const managed = {};
+    for (const [file, hash] of Object.entries(files)) {
+      if (typeof hash === "string" && /^[0-9a-f]{64}$/.test(hash) && checkRelativePath(file).ok) {
+        managed[file] = hash;
+      }
+    }
+    return managed;
+  } catch {
+    return {};
+  }
+}
+async function writeMarker(root, folder, managed) {
+  const sorted = Object.fromEntries(
+    Object.entries(managed).sort(
+      ([a], [b]) => a < b ? -1 : a > b ? 1 : 0
+    )
+  );
+  await writeFileSafely({
+    root,
+    relativePath: `${folder}/${MARKER_NAME}`,
+    bytes: new TextEncoder().encode(
+      `${JSON.stringify({ version: MARKER_VERSION2, files: sorted }, null, 2)}
+`
+    ),
+    mode: 420
+  });
+}
+async function removeMarker(root, folder) {
+  const relative = `${folder}/${MARKER_NAME}`;
+  const current = await readFileSafely(root, relative, {
+    maxBytes: MAX_MARKER_BYTES2
+  });
+  if (current !== null) {
+    await deleteFileSafely(root, relative, sha256(current.bytes));
+  }
+  await pruneEmpty(root, folder, MARKER_NAME);
+}
+async function pruneEmpty(root, folder, file) {
+  const parts = file.split("/").slice(0, -1);
+  for (let depth = parts.length; depth >= 0; depth--) {
+    const relative = [folder, ...parts.slice(0, depth)].join("/");
+    try {
+      await rmdir2(path33.join(root, relative));
+    } catch {
+      return;
+    }
+  }
+}
+async function syncProjectRules(input) {
+  const folder = rulesFolderFor(input.projectId);
+  const { kept: wanted, omitted } = capRules(input.rules);
+  const result = {
+    written: [],
+    removed: [],
+    unchanged: 0,
+    kept: [],
+    skipped: [],
+    omitted,
+    timedOut: false,
+    refused: null
+  };
+  const folderCheck = await assertWritableTarget(
+    input.root,
+    `${folder}/${MARKER_NAME}`
+  );
+  if (!folderCheck.ok) {
+    result.refused = `${folder} cannot be used (${folderCheck.reason}: ${folderCheck.detail})`;
+    return result;
+  }
+  const previous = await readMarker2(input.root, folder);
+  const next = {};
+  const expired = () => input.deadline !== void 0 && Date.now() > input.deadline;
+  const handled = /* @__PURE__ */ new Set();
+  for (const rule of wanted) {
+    const relative = rule.path;
+    if (!checkRelativePath(relative).ok || relative === MARKER_NAME) {
+      result.skipped.push({ path: relative, reason: "unsafe-path" });
+      continue;
+    }
+    handled.add(relative);
+    if (input.tracked?.has(relative)) {
+      result.skipped.push({ path: relative, reason: "tracked" });
+      continue;
+    }
+    if (expired()) {
+      result.timedOut = true;
+      if (previous[relative] !== void 0) {
+        next[relative] = previous[relative];
+      }
+      continue;
+    }
+    const target = `${folder}/${relative}`;
+    const wantedHash = sha256(rule.bytes);
+    try {
+      const check = await assertWritableTarget(input.root, target);
+      if (!check.ok) {
+        result.kept.push({ path: relative, reason: "unsafe" });
+        continue;
+      }
+      const existing = await readFileSafely(input.root, target, {
+        maxBytes: MAX_RULE_READ_BYTES
+      }).catch(() => "unreadable");
+      if (existing === "unreadable") {
+        result.kept.push({ path: relative, reason: "unsafe" });
+        continue;
+      }
+      if (existing === null) {
+        await writeFileSafely({
+          root: input.root,
+          relativePath: target,
+          bytes: rule.bytes,
+          mode: 420
+        });
+        result.written.push(relative);
+        next[relative] = wantedHash;
+        continue;
+      }
+      const currentHash = sha256(existing.bytes);
+      if (currentHash === wantedHash) {
+        result.unchanged++;
+        next[relative] = wantedHash;
+      } else if (previous[relative] === currentHash) {
+        await writeFileSafely({
+          root: input.root,
+          relativePath: target,
+          bytes: rule.bytes,
+          mode: 420
+        });
+        result.written.push(relative);
+        next[relative] = wantedHash;
+      } else {
+        result.kept.push({
+          path: relative,
+          reason: previous[relative] === void 0 ? "not-managed" : "edited"
+        });
+      }
+    } catch {
+      result.kept.push({ path: relative, reason: "unsafe" });
+    }
+  }
+  for (const [relative, hash] of Object.entries(previous)) {
+    if (handled.has(relative)) {
+      continue;
+    }
+    if (expired()) {
+      result.timedOut = true;
+      next[relative] = hash;
+      continue;
+    }
+    try {
+      const outcome = await deleteFileSafely(
+        input.root,
+        `${folder}/${relative}`,
+        hash
+      );
+      if (outcome === "modified") {
+        result.kept.push({ path: relative, reason: "edited" });
+      } else {
+        if (outcome === "deleted") {
+          result.removed.push(relative);
+        }
+        await pruneEmpty(input.root, folder, relative);
+      }
+    } catch {
+      result.kept.push({ path: relative, reason: "unsafe" });
+    }
+  }
+  const changed = JSON.stringify(Object.entries(next).sort()) !== JSON.stringify(Object.entries(previous).sort());
+  try {
+    if (Object.keys(next).length > 0) {
+      if (changed) {
+        await writeMarker(input.root, folder, next);
+      }
+    } else if (Object.keys(previous).length > 0) {
+      await removeMarker(input.root, folder);
+    }
+  } catch {
+    result.refused = `${folder}/${MARKER_NAME} could not be updated`;
+  }
+  return result;
+}
+function rulesSyncLines(result) {
+  const lines2 = [];
+  if (result.refused !== null) {
+    lines2.push(`rules not synced: ${result.refused}.`);
+  }
+  if (result.written.length > 0 || result.removed.length > 0) {
+    lines2.push(
+      `rules: ${result.written.length} written, ${result.removed.length} removed.`
+    );
+  }
+  for (const entry of result.kept) {
+    lines2.push(
+      entry.reason === "edited" ? `rules: kept ${entry.path}, which you edited; it is no longer updated from Fabric.` : entry.reason === "not-managed" ? `rules: kept ${entry.path}, which is your own file at that path.` : `rules: left ${entry.path} alone because it could not be written safely.`
+    );
+  }
+  for (const entry of result.skipped) {
+    lines2.push(
+      entry.reason === "tracked" ? `rules: skipped ${entry.path}, which this project's own git tracks.` : `rules: skipped ${entry.path}: not a path Fabric will write.`
+    );
+  }
+  if (result.omitted > 0) {
+    lines2.push(
+      `rules: ${result.omitted} more rule files were not delivered automatically (limit: 64 files or 256 KiB). Load fabric-instruction-access to find their original paths and read mapped local copies or available text through the project's Fabric MCP tools.`
+    );
+  }
+  if (result.timedOut) {
+    lines2.push(
+      "rules: ran out of time; the rest follow at the next session."
+    );
+  }
+  return lines2;
+}
+
+// src/commands/instructions/render.ts
+import os2 from "os";
+import path36 from "path";
 
 // src/lib/plugin/render.ts
-import { createHash as createHash17, randomBytes as randomBytes4 } from "crypto";
+import { createHash as createHash18, randomBytes as randomBytes4 } from "crypto";
 import {
   chmod as chmod2,
   mkdir as mkdir13,
   readdir as readdir3,
-  readFile as readFile12,
+  readFile as readFile11,
   rename as rename7,
   rm as rm7,
   stat as stat8,
   writeFile as writeFile9
 } from "fs/promises";
-import path33 from "path";
+import path35 from "path";
 
 // src/lib/plugin/source.ts
-import { createHash as createHash16 } from "crypto";
-import { mkdir as mkdir12, readFile as readFile11, rename as rename6, rm as rm6, writeFile as writeFile8 } from "fs/promises";
-import path32 from "path";
+import { createHash as createHash17 } from "crypto";
+import { mkdir as mkdir12, readFile as readFile10, rename as rename6, rm as rm6, writeFile as writeFile8 } from "fs/promises";
+import path34 from "path";
 
 // src/lib/git-blob.ts
-import { createHash as createHash15 } from "crypto";
+import { createHash as createHash16 } from "crypto";
 function objectFormatOf(oid) {
   if (/^[0-9a-f]{40}$/.test(oid)) {
     return "sha1";
@@ -18137,7 +19189,7 @@ function objectFormatOf(oid) {
   return null;
 }
 function gitBlobOid(bytes, format = "sha1") {
-  return createHash15(format).update(`blob ${bytes.byteLength}\0`).update(bytes).digest("hex");
+  return createHash16(format).update(`blob ${bytes.byteLength}\0`).update(bytes).digest("hex");
 }
 function matchesBlobOid(bytes, oid) {
   const format = objectFormatOf(oid);
@@ -18145,18 +19197,18 @@ function matchesBlobOid(bytes, oid) {
 }
 
 // src/lib/plugin/source.ts
-var READ_CONCURRENCY = 6;
-var MAX_PAGES_PER_FILE = 64;
+var READ_BATCH_SIZE = 200;
+var MAX_INLINE_BYTES = 256 * 1024;
 var ALWAYS_ON = /* @__PURE__ */ new Set(["CLAUDE.md", "AGENTS.md"]);
 function isWantedPath(instructionPath) {
-  return ALWAYS_ON.has(instructionPath) || pluginPathFor(instructionPath) !== null;
+  return ALWAYS_ON.has(instructionPath) || pluginPathFor(instructionPath) !== null || projectRulePathFor(instructionPath) !== null;
 }
 function blobPath(cacheDirectory, key) {
-  return path32.join(cacheDirectory, "blobs", key);
+  return path34.join(cacheDirectory, "blobs", key);
 }
 async function cached(cacheDirectory, key, valid) {
   try {
-    const bytes = await readFile11(blobPath(cacheDirectory, key));
+    const bytes = await readFile10(blobPath(cacheDirectory, key));
     return valid(bytes) ? bytes : null;
   } catch {
     return null;
@@ -18166,7 +19218,7 @@ async function remember(cacheDirectory, key, bytes) {
   const file = blobPath(cacheDirectory, key);
   const temporary = `${file}.${process.pid}.tmp`;
   try {
-    await mkdir12(path32.dirname(file), { recursive: true });
+    await mkdir12(path34.dirname(file), { recursive: true });
     await writeFile8(temporary, bytes);
     await rename6(temporary, file);
   } catch {
@@ -18174,38 +19226,13 @@ async function remember(cacheDirectory, key, bytes) {
   }
 }
 function sha256Of2(bytes) {
-  return createHash16("sha256").update(bytes).digest("hex");
-}
-async function inBatches(items, work) {
-  const queue = items.values();
-  const failures = [];
-  const worker = async () => {
-    for (; ; ) {
-      const next = queue.next();
-      if (next.done || failures.length > 0) {
-        return;
-      }
-      try {
-        await work(next.value);
-      } catch (error) {
-        failures.push(error);
-      }
-    }
-  };
-  await Promise.all(
-    Array.from(
-      { length: Math.min(READ_CONCURRENCY, items.length) },
-      worker
-    )
-  );
-  if (failures.length > 0) {
-    throw failures[0];
-  }
+  return createHash17("sha256").update(bytes).digest("hex");
 }
 async function readDirect(input) {
   const listing = await input.client.instructions.listRepositoryFiles(
     input.projectId,
-    { org: input.org }
+    { org: input.org },
+    { signal: input.signal }
   );
   if (listing.incomplete || listing.refusal !== null) {
     throw new Error(
@@ -18216,59 +19243,104 @@ async function readDirect(input) {
     generation: listing.generation,
     commitSha: listing.commitSha
   };
+  const listed = listing.files.map((file) => ({
+    path: file.path,
+    size: file.size,
+    kind: file.kind,
+    blobId: file.blobId,
+    mode: file.mode
+  }));
   const wanted = listing.files.filter((file) => isWantedPath(file.path));
   const files = [];
   const skipped3 = [];
-  const readOne = async (file) => {
+  const missing = [];
+  if (listing.files.some((file) => !checkRelativePath(file.path).ok) || findCollision(listing.files.map((file) => file.path)) !== null) {
+    throw new Error("The repository returned unsafe or colliding paths.");
+  }
+  for (const file of wanted) {
+    input.signal?.throwIfAborted();
     const blobId = file.blobId;
-    if (blobId !== void 0) {
-      const hit = await cached(
-        input.cacheDirectory,
-        `git-${blobId}`,
-        (b) => matchesBlobOid(b, blobId)
+    if (blobId === void 0 || objectFormatOf(blobId) === null) {
+      throw new Error(
+        `The repository did not identify the Git blob for ${file.path}.`
       );
-      if (hit !== null) {
-        files.push({
-          path: file.path,
-          bytes: hit,
-          mode: modeOf(file.mode)
-        });
-        return;
-      }
     }
-    const chunks = [];
-    let offset = 0;
-    for (let page = 0; page < MAX_PAGES_PER_FILE; page++) {
-      const read = await input.client.instructions.getRepositoryFile(
+    const hit = await cached(
+      input.cacheDirectory,
+      `git-${blobId}`,
+      (b) => b.byteLength <= MAX_INLINE_BYTES && matchesBlobOid(b, blobId)
+    );
+    if (hit !== null) {
+      files.push({
+        path: file.path,
+        bytes: hit,
+        mode: modeOf(file.mode)
+      });
+      continue;
+    }
+    missing.push(file);
+  }
+  for (let offset = 0; offset < missing.length; offset += READ_BATCH_SIZE) {
+    const batch = missing.slice(offset, offset + READ_BATCH_SIZE);
+    const paths = batch.map((file) => file.path);
+    let startIndex = 0;
+    for (; ; ) {
+      input.signal?.throwIfAborted();
+      const page = await input.client.instructions.readRepositoryFiles(
         input.projectId,
-        { ...pin, path: file.path, offset, org: input.org }
+        { ...pin, paths, startIndex },
+        { org: input.org, signal: input.signal }
       );
-      if (read.state !== "found") {
-        skipped3.push(file.path);
-        return;
+      input.signal?.throwIfAborted();
+      const end = page.nextIndex === null ? paths.length : page.nextIndex;
+      if (page.generation !== pin.generation || page.commitSha !== pin.commitSha || !Number.isInteger(end) || end <= startIndex || end > paths.length || !Array.isArray(page.files) || page.files.length !== end - startIndex) {
+        throw new Error(
+          "The repository returned an invalid pinned batch."
+        );
       }
-      chunks.push(read.body);
-      if (read.nextOffset === null) {
-        const bytes = new TextEncoder().encode(chunks.join(""));
-        if (blobId !== void 0 && matchesBlobOid(bytes, blobId)) {
-          await remember(
-            input.cacheDirectory,
-            `git-${blobId}`,
-            bytes
+      for (const [index, result] of page.files.entries()) {
+        const file = batch[startIndex + index];
+        if (file === void 0 || result.path !== file.path) {
+          throw new Error(
+            "The repository returned unexpected or missing paths."
+          );
+        }
+        const read = result.read;
+        if (read.state === "binary" || read.state === "tooLarge") {
+          skipped3.push(file.path);
+          continue;
+        }
+        if (read.state !== "found" || typeof read.text !== "string") {
+          throw new Error(
+            `The repository could not read ${file.path}.`
+          );
+        }
+        const bytes = new TextEncoder().encode(read.text);
+        if (bytes.byteLength !== read.size || bytes.byteLength > MAX_INLINE_BYTES || file.blobId === void 0 || !matchesBlobOid(bytes, file.blobId)) {
+          throw new Error(
+            `The repository returned different bytes for ${file.path}.`
           );
         }
+        await remember(
+          input.cacheDirectory,
+          `git-${file.blobId}`,
+          bytes
+        );
         files.push({ path: file.path, bytes, mode: modeOf(file.mode) });
-        return;
       }
-      offset = read.nextOffset;
+      if (page.nextIndex === null) {
+        break;
+      }
+      startIndex = end;
     }
-    throw new Error(`${file.path} is too long to read.`);
-  };
-  await inBatches(wanted, readOne);
+  }
+  input.signal?.throwIfAborted();
   return {
     pin: `repo:${pin.generation}:${pin.commitSha}`,
+    source: { kind: "repository", ...pin },
     files,
-    skipped: skipped3.sort()
+    skipped: skipped3.sort(),
+    listed
   };
 }
 function modeOf(mode) {
@@ -18281,9 +19353,22 @@ function modeOf(mode) {
 async function readUploaded(input) {
   const { published } = input;
   if (!published.published || published.snapshot === void 0) {
-    return { pin: "upload:none", files: [], skipped: [] };
+    return {
+      pin: "upload:none",
+      source: { kind: "upload", digest: null },
+      files: [],
+      skipped: [],
+      listed: []
+    };
   }
   const digest = published.snapshot.digest;
+  const listed = (published.manifest ?? []).map((entry) => ({
+    path: entry.path,
+    size: entry.size,
+    kind: entry.kind,
+    sha256: entry.sha256,
+    mode: entry.mode
+  }));
   const manifest = (published.manifest ?? []).filter(
     (entry) => isWantedPath(entry.path)
   );
@@ -18302,7 +19387,7 @@ async function readUploaded(input) {
     }
   }
   if (missing.length > 0) {
-    const byPath3 = new Map(missing.map((entry) => [entry.path, entry]));
+    const byPath5 = new Map(missing.map((entry) => [entry.path, entry]));
     await downloadFilesByUrl(
       {
         client: input.client,
@@ -18323,12 +19408,18 @@ async function readUploaded(input) {
         files.push({
           path: file.path,
           bytes,
-          mode: byPath3.get(file.path)?.mode ?? null
+          mode: byPath5.get(file.path)?.mode ?? null
         });
       }
     );
   }
-  return { pin: `upload:${digest}`, files, skipped: [] };
+  return {
+    pin: `upload:${digest}`,
+    source: { kind: "upload", digest },
+    files,
+    skipped: [],
+    listed
+  };
 }
 async function readInstructions(input) {
   const direct = input.published.direct;
@@ -18346,6 +19437,16 @@ async function readInstructions(input) {
 // src/lib/plugin/render.ts
 var KEPT_PINS = 3;
 var CODEX_PIN_MARKER = ".fabric-render";
+var LEFT_OUT_NAMED = 3;
+function leftOutLine(paths) {
+  if (paths.length === 0) {
+    return null;
+  }
+  const named = paths.slice(0, LEFT_OUT_NAMED).join(", ");
+  const more = paths.length > LEFT_OUT_NAMED ? ` and ${paths.length - LEFT_OUT_NAMED} more` : "";
+  const count = paths.length === 1 ? "1 instruction file is" : `${paths.length} instruction files are`;
+  return `${count} not part of the plugin (${named}${more}). Their paths remain in the fabric-instruction-access skill's catalog; use the project's Fabric MCP tools to read available text on demand. The Coding Instructions tab lists the layout reasons.`;
+}
 function memoryFoldersOf(targets) {
   return {
     state: "known",
@@ -18369,7 +19470,7 @@ async function readMemoryFolders(input) {
   }
 }
 function pinOf(sourcePin, memory, tool) {
-  return createHash17("sha256").update(
+  return createHash18("sha256").update(
     JSON.stringify({
       v: RENDER_VERSION,
       tool,
@@ -18386,8 +19487,8 @@ async function exists(file) {
 }
 async function writeTree(directory, files) {
   for (const file of files) {
-    const target = path33.join(directory, ...file.path.split("/"));
-    await mkdir13(path33.dirname(target), { recursive: true });
+    const target = path35.join(directory, ...file.path.split("/"));
+    await mkdir13(path35.dirname(target), { recursive: true });
     await writeFile9(target, file.bytes);
     await chmod2(target, file.mode).catch(() => void 0);
   }
@@ -18403,12 +19504,12 @@ async function prune(projectDirectory, keep) {
     const dated = await Promise.all(
       entries.filter((entry) => entry.isDirectory() && entry.name !== keep).map(async (entry) => ({
         name: entry.name,
-        modified: (await stat8(path33.join(projectDirectory, entry.name))).mtimeMs
+        modified: (await stat8(path35.join(projectDirectory, entry.name))).mtimeMs
       }))
     );
     dated.sort((a, b) => b.modified - a.modified);
     for (const old of dated.slice(KEPT_PINS - 1)) {
-      await rm7(path33.join(projectDirectory, old.name), {
+      await rm7(path35.join(projectDirectory, old.name), {
         recursive: true,
         force: true
       }).catch(() => void 0);
@@ -18417,8 +19518,8 @@ async function prune(projectDirectory, keep) {
   }
 }
 async function installClaude(projectDirectory, pin, files) {
-  const directory = path33.join(projectDirectory, pin);
-  if (await exists(path33.join(directory, ".claude-plugin", "plugin.json"))) {
+  const directory = path35.join(projectDirectory, pin);
+  if (await exists(path35.join(directory, ".claude-plugin", "plugin.json"))) {
     return { directory, reused: true };
   }
   await mkdir13(projectDirectory, { recursive: true });
@@ -18431,7 +19532,7 @@ async function installClaude(projectDirectory, pin, files) {
     await rm7(temporary, { recursive: true, force: true }).catch(
       () => void 0
     );
-    if (await exists(path33.join(directory, ".claude-plugin", "plugin.json"))) {
+    if (await exists(path35.join(directory, ".claude-plugin", "plugin.json"))) {
       return { directory, reused: true };
     }
     throw error;
@@ -18439,20 +19540,30 @@ async function installClaude(projectDirectory, pin, files) {
   await prune(projectDirectory, pin);
   return { directory, reused: false };
 }
-async function installCodex(directory, pin, files) {
-  const marker = await readFile12(
-    path33.join(directory, CODEX_PIN_MARKER),
+async function installCodex(directory, pin, files, binding) {
+  await assertLocationFree({
+    directory,
+    location: "codex-plugin",
+    wanted: binding
+  });
+  const marker = await readFile11(
+    path35.join(directory, CODEX_PIN_MARKER),
     "utf8"
   ).catch(() => null);
   if (marker?.trim() === pin) {
     return { directory, reused: true };
   }
-  await mkdir13(path33.dirname(directory), { recursive: true });
+  await mkdir13(path35.dirname(directory), { recursive: true });
   const temporary = temporaryNameFor(directory);
   const retired = temporaryNameFor(directory).replace(".tmp-", ".old-");
   try {
     await writeTree(temporary, [
       ...files,
+      {
+        path: BINDING_FILE,
+        bytes: new TextEncoder().encode(bindingText(binding)),
+        mode: 420
+      },
       {
         path: CODEX_PIN_MARKER,
         bytes: new TextEncoder().encode(`${pin}
@@ -18493,7 +19604,15 @@ async function renderPlugin(input) {
     fetchImpl: input.fetchImpl
   });
   for (const skipped3 of read.skipped) {
-    input.log?.(`${skipped3} is not text, so the plugin leaves it out.`);
+    input.log?.(
+      `${skipped3} is unavailable as inline text, so the plugin leaves its bytes out. Its path remains in the fabric-instruction-access catalog; MCP reads may report a binary or size refusal.`
+    );
+  }
+  const notPartOfPlugin = leftOutLine(
+    planPluginFiles(read.listed, input.tool).leftOut.filter((entry) => entry.reason !== "always-on-shadowed").map((entry) => entry.path)
+  );
+  if (notPartOfPlugin !== null) {
+    input.log?.(notPartOfPlugin);
   }
   const memory = await readMemoryFolders(input);
   const pin = pinOf(read.pin, memory, input.tool);
@@ -18503,25 +19622,39 @@ async function renderPlugin(input) {
     files: read.files,
     memory,
     gatewayUrl: projectResource(input.origin, "mcp", input.projectId),
-    pin
+    pin,
+    instructionAccess: { listed: read.listed, source: read.source }
   });
   const always = alwaysOnFile(read.files, input.tool);
+  const guidance = instructionAccessBootstrap(
+    pluginNameFor(input.projectId),
+    input.tool
+  );
   const installed = input.tool === "claude-code" ? await installClaude(
-    path33.join(input.cacheDirectory, "plugins", input.projectId),
+    path35.join(input.cacheDirectory, "plugins", input.projectId),
     pin,
     files
   ) : await installCodex(
-    path33.join(
+    path35.join(
       input.codexPluginsDirectory,
       pluginNameFor(input.projectId)
     ),
     pin,
-    files
+    files,
+    {
+      projectId: input.projectId,
+      origin: originOf4(input.origin)
+    }
   );
   return {
     ...installed,
     pin,
-    alwaysOn: always === null ? null : { file: always.file, text: always.text },
+    alwaysOn: {
+      file: always?.file ?? "Fabric instruction access",
+      text: `${guidance}${always === null ? "" : `
+${always.text}`}`
+    },
+    rules: selectRules(read, input.tool),
     files
   };
 }
@@ -18537,7 +19670,7 @@ function toolOf(target) {
   }
   throw new CliFailure("--target is claude-code or codex", 2);
 }
-async function renderForProject(input) {
+function connectForProject(input) {
   const origin = normalizeOrigin(
     input.baseUrl ?? getBaseUrl() ?? DEFAULT_ORIGIN
   );
@@ -18553,20 +19686,26 @@ async function renderForProject(input) {
       3
     );
   }
-  const client = getClient({
-    baseUrl: input.baseUrl,
-    project: input.project,
-    timeoutMs: REQUEST_TIMEOUT_MS
-  }).withoutContext();
-  const cacheDirectory = path34.join(path34.dirname(getConfigPath()), "cache");
+  return {
+    origin,
+    client: getClient({
+      baseUrl: input.baseUrl,
+      project: input.project,
+      timeoutMs: REQUEST_TIMEOUT_MS
+    }).withoutContext(),
+    cacheDirectory: path36.join(path36.dirname(getConfigPath()), "cache")
+  };
+}
+async function renderForProject(input) {
+  const { origin, client, cacheDirectory } = connectForProject(input);
   const rendered = await renderPlugin({
     client,
     projectId: input.project,
     org: input.org,
     origin,
     tool: input.tool,
-    cacheDirectory: input.out !== void 0 && input.tool === "claude-code" ? path34.resolve(input.out) : cacheDirectory,
-    codexPluginsDirectory: input.out !== void 0 && input.tool === "codex" ? path34.resolve(input.out) : path34.join(
+    cacheDirectory: input.out !== void 0 && input.tool === "claude-code" ? path36.resolve(input.out) : cacheDirectory,
+    codexPluginsDirectory: input.out !== void 0 && input.tool === "codex" ? path36.resolve(input.out) : path36.join(
       machine.home() ?? os2.homedir(),
       ".codex",
       "plugins"
@@ -18574,7 +19713,16 @@ async function renderForProject(input) {
     timeoutMs: REQUEST_TIMEOUT_MS,
     log: input.log
   });
-  return { directory: rendered.directory, alwaysOn: rendered.alwaysOn };
+  return {
+    directory: rendered.directory,
+    reused: rendered.reused,
+    pin: rendered.pin,
+    alwaysOn: rendered.alwaysOn,
+    agentsText: input.tool === "codex" ? agentsInstructions(
+      rendered.alwaysOn?.text ?? null,
+      rendered.rules
+    ) : null
+  };
 }
 async function refreshAgentsOverride(root, instructions) {
   const canonical = await resolveExistingRoot(root);
@@ -18621,12 +19769,26 @@ function registerRenderCommand(instructions) {
         log: (text3) => process.stderr.write(`fabric: ${text3}
 `)
       });
-      if (tool === "codex" && rendered.alwaysOn !== null) {
+      if (tool === "codex" && rendered.agentsText !== null) {
         await refreshAgentsOverride(
           opts.dest ?? process.cwd(),
-          rendered.alwaysOn.text
+          rendered.agentsText
         );
       }
+      if (tool === "codex" && opts.out === void 0) {
+        const env2 = machine.env();
+        const home = machine.home() ?? os2.homedir();
+        await refreshCodexInstall({
+          run: createAgentRunner({
+            lookup: { env: env2, platform: machine.platform() }
+          }),
+          home,
+          codexHome: env2.CODEX_HOME ?? path36.join(home, ".codex"),
+          projectId: opts.project,
+          version: codexPluginVersion(rendered.pin),
+          cwd: path36.resolve(opts.dest ?? process.cwd())
+        });
+      }
       if (!opts.hook) {
         process.stdout.write(`${rendered.directory}
 `);
@@ -18645,6 +19807,111 @@ function registerRenderCommand(instructions) {
   });
 }
 
+// src/commands/instructions/rules.ts
+import path37 from "path";
+var HOOK_BUDGET_MS = 4e4;
+var REQUEST_TIMEOUT_MS2 = 2e4;
+async function trackedBelow(toplevel, root, folder, deadline) {
+  const prefix = path37.relative(toplevel, path37.join(root, folder)).split(path37.sep).join("/");
+  const tracked = await trackedPaths(toplevel, [prefix], deadline);
+  return new Set(
+    tracked.kind === "ok" ? tracked.value.filter((entry) => entry.startsWith(`${prefix}/`)).map((entry) => entry.slice(prefix.length + 1)) : []
+  );
+}
+async function syncRulesForProject(input) {
+  const budget = input.budgetMs ?? HOOK_BUDGET_MS;
+  const deadline = Date.now() + budget;
+  const { client, cacheDirectory } = connectForProject(input);
+  const published = await client.instructions.getPublished(input.project, {
+    org: input.org
+  });
+  const read = await readInstructions({
+    client,
+    projectId: input.project,
+    org: input.org,
+    published,
+    cacheDirectory,
+    timeoutMs: REQUEST_TIMEOUT_MS2,
+    signal: AbortSignal.timeout(budget)
+  });
+  const rules = selectRules(read, "claude-code");
+  const root = await resolveExistingRoot(input.root);
+  const folder = rulesFolderFor(input.project);
+  const tree = await findWorkTree(root, Date.now() + 8e3);
+  const toplevel = tree.kind === "ok" ? tree.value.toplevel : null;
+  const result = await syncProjectRules({
+    root,
+    projectId: input.project,
+    rules,
+    tracked: toplevel === null ? void 0 : await trackedBelow(
+      toplevel,
+      root,
+      folder,
+      Date.now() + 8e3
+    ),
+    deadline
+  });
+  if (toplevel !== null && rules.length > 0 && result.refused === null) {
+    await excludeLocalFiles({
+      toplevel,
+      directory: root,
+      files: [folder],
+      deadline: Date.now() + 8e3
+    });
+  }
+  return result;
+}
+function registerRulesCommand(instructions) {
+  instructions.command("rules").description(
+    "Write the project's rules into .claude/rules/fabric-<id>/ for Claude Code (a plugin cannot carry rules)"
+  ).requiredOption("--project <id>", "Project ID").option(
+    "--base-url <origin>",
+    "Deployment to talk to (default: the one you are signed in to)"
+  ).option("--org <slug>", "Organization context").option(
+    "--dest <dir>",
+    "The project folder (default: the folder `init` set up, found from cwd)"
+  ).option("--hook", "Run as a session hook: print nothing, never fail").action(async (opts) => {
+    const note = (text3) => process.stderr.write(`fabric: ${text3}
+`);
+    try {
+      const project = opts.project;
+      let root;
+      if (opts.dest !== void 0) {
+        root = await resolveDestinationRoot(
+          path37.resolve(opts.dest)
+        );
+      } else {
+        const found = await findProjectRoot(process.cwd());
+        if (found === null || found.marker.projectId !== project) {
+          throw new CliFailure(
+            "this folder was not set up by `fabric instructions init` for this project; pass --dest",
+            2
+          );
+        }
+        root = found.root;
+      }
+      const result = await syncRulesForProject({
+        project,
+        baseUrl: opts.baseUrl,
+        org: opts.org,
+        root
+      });
+      for (const text3 of rulesSyncLines(result)) {
+        note(text3);
+      }
+    } catch (error) {
+      note(
+        `rules failed: ${error instanceof CliFailure ? error.message : describeError(error)}`
+      );
+      if (!opts.hook) {
+        process.exit(
+          error instanceof CliFailure ? error.exitCode : 1
+        );
+      }
+    }
+  });
+}
+
 // src/commands/instructions/init-plugin.ts
 function wordForPaste(value) {
   return pathAsCommandWord(value) ?? value;
@@ -18673,6 +19940,25 @@ async function approveClaudePlugin(input) {
   );
   return installed.kind === "exited" && installed.code === 0 ? { kind: "approved" } : { kind: "manual", lines: [commands.install] };
 }
+async function deliverRules(options, root) {
+  try {
+    const result = await syncRulesForProject({
+      project: options.project,
+      baseUrl: options.origin,
+      org: options.org,
+      root
+    });
+    const notes = rulesSyncLines(result);
+    return result.written.length + result.unchanged > 0 || notes.length > 0 ? [
+      `Project rules are delivered to ${rulesFolderFor(options.project)}/ (kept out of commits; refreshed at each session start).`,
+      ...notes
+    ] : [];
+  } catch (error) {
+    return [
+      `The project's rules could not be delivered now (${describeError(error)}); the session hook retries at each start.`
+    ];
+  }
+}
 function line(text3) {
   process.stdout.write(`${text3}
 `);
@@ -18701,7 +19987,7 @@ async function probeMemory(options, root) {
 }
 async function runPluginInit(options) {
   const explicit = options.tool === void 0 ? void 0 : toolOf2(options.tool);
-  const destination = path35.resolve(options.dest ?? process.cwd());
+  const destination = path38.resolve(options.dest ?? process.cwd());
   const root = await resolveDestinationRoot(destination);
   try {
     await assertKeyStaysOutside(root, getConfigPath());
@@ -18719,7 +20005,7 @@ async function runPluginInit(options) {
   const tools = explicit === void 0 ? detected.tools : [explicit];
   const launcher = await resolveHookLauncher({
     origin: options.origin,
-    configDirectory: path35.dirname(getConfigPath()),
+    configDirectory: path38.dirname(getConfigPath()),
     lookup: { env: machine.env(), platform: machine.platform() },
     bundle: isServedBundle() ? { scriptPath: bundleScriptPath() } : null
   });
@@ -18747,11 +20033,12 @@ async function runPluginInit(options) {
         org: options.org
       });
       marketplaceDirectory = await writeClaudeMarketplace({
-        cacheDirectory: path35.join(
-          path35.dirname(getConfigPath()),
+        cacheDirectory: path38.join(
+          path38.dirname(getConfigPath()),
           "cache"
         ),
         projectId: options.project,
+        origin: options.origin,
         command
       });
       const registered = await registerClaudePlugin({
@@ -18760,8 +20047,9 @@ async function runPluginInit(options) {
         marketplaceDirectory
       });
       excludes.push(CLAUDE_SETTINGS_RELATIVE_PATH);
+      steps.push(...await deliverRules(options, root));
       steps.push(
-        `Registered the ${pluginNameFor(options.project)} plugin in ${path35.relative(root, registered.settingsPath) || registered.settingsPath} (marketplace folder ${marketplaceDirectory}); Claude Code builds it from Fabric at the start of each session.`
+        `Registered the ${pluginNameFor(options.project)} plugin in ${path38.relative(root, registered.settingsPath) || registered.settingsPath} (marketplace folder ${marketplaceDirectory}); Claude Code builds it from Fabric at the start of each session.`
       );
     } else {
       const registration = await registerCodexPlugin({
@@ -18770,13 +20058,22 @@ async function runPluginInit(options) {
         pluginDirectory: rendered.directory
       });
       steps.push(
-        `Rendered the ${pluginNameFor(options.project)} plugin to ${rendered.directory} and listed it in ${registration.marketplaceFile} (marketplace "${registration.marketplaceName}"). Install it from Codex's plugin browser if it is not on yet.`
+        `Rendered the ${pluginNameFor(options.project)} plugin to ${rendered.directory} and listed it in ${registration.marketplaceFile} (marketplace "${registration.marketplaceName}").`
       );
-      if (rendered.alwaysOn !== null) {
-        await refreshAgentsOverride(root, rendered.alwaysOn.text);
+      const installed = await installCodexPlugin({
+        run: run4,
+        projectId: options.project,
+        marketplaceName: registration.marketplaceName,
+        cwd: root
+      });
+      steps.push(
+        installed.kind === "installed" ? `Installed the ${pluginNameFor(options.project)} plugin in Codex.` : `Codex did not install the plugin. Run: ${installed.line ?? "codex plugin add, with the plugin and marketplace names above"}`
+      );
+      if (rendered.agentsText !== null) {
+        await refreshAgentsOverride(root, rendered.agentsText);
         excludes.push("AGENTS.override.md");
         steps.push(
-          "Wrote AGENTS.override.md (kept out of commits): the project's AGENTS.md, then the instructions."
+          "Wrote AGENTS.override.md (kept out of commits): the project's AGENTS.md, then the instructions and the project's rules."
         );
       }
     }
@@ -18958,6 +20255,7 @@ function buildInstructionsCommand() {
     "Keep a checkout current with a project's published coding instructions"
   );
   registerRenderCommand(instructions);
+  registerRulesCommand(instructions);
   instructions.command("self-update", { hidden: true }).description("Refresh the kept copy of the served CLI, out of band").option("--base-url <origin>", BASE_URL_HELP).action(async (opts) => {
     await refreshKeptCopyAfterHook(
       opts,
@@ -19207,7 +20505,7 @@ async function traceHookFailure(opts, why) {
     return;
   }
   const reason = why.signedOut ? "not-signed-in" : why.upgrade ? "upgrade-required" : why.timedOut ? "deadline" : `failed-${why.exitCode}`;
-  await appendTrace(traceFile(path36.dirname(getConfigPath())), {
+  await appendTrace(traceFile(path39.dirname(getConfigPath())), {
     at: (/* @__PURE__ */ new Date()).toISOString(),
     projectId: opts.project ?? "",
     outcome: "skipped",
@@ -19240,7 +20538,7 @@ async function refreshKeptCopyAfterHook(opts, deadlineAt, { mayDefer = true } =
   const input = {
     origin,
     script: bundleScriptPath(),
-    configDirectory: path36.dirname(getConfigPath()),
+    configDirectory: path39.dirname(getConfigPath()),
     runningTarball: bundleTarballPath(),
     env: process.env,
     deadlineAt,
@@ -19258,7 +20556,7 @@ async function refreshKeptCopyAfterHook(opts, deadlineAt, { mayDefer = true } =
     });
   }
   if (outcome.kind !== "skipped") {
-    await appendTrace(traceFile(path36.dirname(getConfigPath())), {
+    await appendTrace(traceFile(path39.dirname(getConfigPath())), {
       at: (/* @__PURE__ */ new Date()).toISOString(),
       projectId: "",
       outcome: "self-update",
@@ -19318,7 +20616,7 @@ function gitDeadline() {
   return activeDeadlineAt === void 0 ? Date.now() + GIT_BUDGET_MS3 : activeDeadlineAt - hookTiming.gitMarginMs;
 }
 function destinationOf(opts) {
-  return path36.resolve(opts.dest ?? process.cwd());
+  return path39.resolve(opts.dest ?? process.cwd());
 }
 function instructionsClient(opts, timeoutMs, { neverRetry = false } = {}) {
   if (!getApiKey(deploymentOrigin(opts), opts.project)) {
@@ -19691,7 +20989,7 @@ async function directRepositoryCheckoutStatus(input) {
   };
 }
 async function readLockForProject2(destination, projectId) {
-  const lock = await readLock(destination);
+  const lock = await readLock2(destination);
   if (lock !== null && lock.projectId !== projectId) {
     throw outcomeFailure("lock-of-other-project", {});
   }
@@ -20104,7 +21402,7 @@ async function syncOnce(opts) {
       projectId: opts.project,
       deadline: gitDeadline(),
       optedOut: opts.fastForward === false,
-      traceFile: traceFile(path36.dirname(getConfigPath()))
+      traceFile: traceFile(path39.dirname(getConfigPath()))
     }) : null;
     hookTraced = fastForward !== null;
     lazyTransport?.rethrow();
@@ -20145,7 +21443,7 @@ async function syncOnce(opts) {
       projectId: opts.project,
       deadline: gitDeadline(),
       optedOut: opts.fastForward === false,
-      traceFile: traceFile(path36.dirname(getConfigPath())),
+      traceFile: traceFile(path39.dirname(getConfigPath())),
       timings: hookPhases
     }) : null;
     return {
@@ -20223,7 +21521,7 @@ async function syncOnce(opts) {
   try {
     for (let attempt2 = 0; plan.writes.length > 0 && attempt2 < 2; attempt2++) {
       try {
-        const byPath3 = new Map(
+        const byPath5 = new Map(
           manifest.map((entry) => [entry.path, entry])
         );
         const large = manifest.reduce((total, entry) => total + entry.size, 0) > IN_MEMORY_SNAPSHOT_BYTES;
@@ -20235,7 +21533,7 @@ async function syncOnce(opts) {
             digest: published.snapshot.digest,
             files: plan.writes.map((entry) => ({
               path: entry.path,
-              size: byPath3.get(entry.path)?.size ?? -1,
+              size: byPath5.get(entry.path)?.size ?? -1,
               sha256: entry.sha256 ?? ""
             })),
             timeoutMs: opts.hook ? hookDeadlineMs() : BUNDLE_TIMEOUT_MS,
@@ -20260,7 +21558,7 @@ async function syncOnce(opts) {
             archive,
             plan.writes.map((entry) => ({
               path: entry.path,
-              size: byPath3.get(entry.path)?.size ?? -1
+              size: byPath5.get(entry.path)?.size ?? -1
             }))
           );
         }
@@ -20803,7 +22101,7 @@ async function cloneProjectRepository(opts, destination, repository, transport)
 }
 async function insideInstructionsCheckout(opts) {
   const destination = await resolveExistingRoot(destinationOf(opts));
-  if (await readLock(destination) !== null) {
+  if (await readLock2(destination) !== null) {
     return true;
   }
   const guard = new SourceGuard(destination, opts.remote);
@@ -20880,7 +22178,7 @@ async function runInit(opts, format) {
       );
       cloned = true;
       if (cloneFolder !== void 0 && checkout.class === "unmapped") {
-        destination = path36.join(checkout.toplevel, checkout.rootPath);
+        destination = path39.join(checkout.toplevel, checkout.rootPath);
         existing = await resolveExistingRoot(destination);
         checkout = await classifyCheckout({
           destination: existing,
@@ -20948,12 +22246,12 @@ async function runInit(opts, format) {
     throw outcomeFailure("lessons-need-claude", {});
   }
   if (matching !== null) {
-    const prefix = path36.relative(matching.toplevel, root);
+    const prefix = path39.relative(matching.toplevel, root);
     const relativeSetupPaths = [
       ...tools.tools.map(
-        (tool) => path36.join(prefix, hookPathFor(tool)).replaceAll(path36.sep, "/")
+        (tool) => path39.join(prefix, hookPathFor(tool)).replaceAll(path39.sep, "/")
       ),
-      path36.join(prefix, LOCK_DIRECTORY, LOCK_FILENAME).replaceAll(path36.sep, "/")
+      path39.join(prefix, LOCK_DIRECTORY, LOCK_FILENAME).replaceAll(path39.sep, "/")
     ];
     const tracked = await trackedPaths(
       matching.toplevel,
@@ -20992,7 +22290,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: path36.dirname(getConfigPath()),
+    configDirectory: path39.dirname(getConfigPath()),
     lookup: { env: machine.env(), platform: machine.platform() },
     bundle: isServedBundle() ? { scriptPath: bundleScriptPath() } : null
   });
@@ -21164,7 +22462,7 @@ async function runInit(opts, format) {
       outcomeLine("cloned-into", {
         where: folderForCommand(
           opts.dest,
-          path36.relative(
+          path39.relative(
             await resolveExistingRoot(destinationOf(opts)),
             root
           )
@@ -21210,8 +22508,8 @@ async function runLessonPromptCommand(opts) {
     stdinText = await readAllStdin(process.stdin);
   } catch {
   }
-  const markerDir = path36.join(
-    path36.dirname(getConfigPath()),
+  const markerDir = path39.join(
+    path39.dirname(getConfigPath()),
     "lesson-prompts"
   );
   const result = await runLessonPrompt({
@@ -21373,6 +22671,9 @@ function buildMcpCommand() {
 // src/commands/memory/index.ts
 import { Command as Command15 } from "commander";
 
+// src/lib/memory/pull.ts
+import path41 from "path";
+
 // src/lib/memory/context.ts
 var FETCH_CONCURRENCY = 4;
 function now(context) {
@@ -21403,11 +22704,11 @@ async function inParallel(items, work) {
 }
 
 // src/lib/memory/local.ts
-import { createHash as createHash18 } from "crypto";
-import { lstat as lstat8, readdir as readdir5 } from "fs/promises";
-import path37 from "path";
+import { createHash as createHash19 } from "crypto";
+import { lstat as lstat7, readdir as readdir5 } from "fs/promises";
+import path40 from "path";
 function sha256Hex2(bytes) {
-  return createHash18("sha256").update(bytes).digest("hex");
+  return createHash19("sha256").update(bytes).digest("hex");
 }
 async function scanFolder(root, folder) {
   const scan = { files: [], skipped: [] };
@@ -21416,7 +22717,7 @@ async function scanFolder(root, folder) {
     const directory = pending.pop();
     let names2;
     try {
-      names2 = await readdir5(path37.join(root, ...directory.split("/")));
+      names2 = await readdir5(path40.join(root, ...directory.split("/")));
     } catch (error) {
       if (error.code === "ENOENT") {
         continue;
@@ -21428,8 +22729,8 @@ async function scanFolder(root, folder) {
       if (name.startsWith(".")) {
         continue;
       }
-      const stats = await lstat8(
-        path37.join(root, ...relative.split("/"))
+      const stats = await lstat7(
+        path40.join(root, ...relative.split("/"))
       ).catch(() => null);
       if (stats === null) {
         continue;
@@ -21491,7 +22792,7 @@ function emptyMemoryLock(projectId) {
     outbox: []
   };
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function damaged() {
@@ -21512,7 +22813,7 @@ async function readMemoryLock(root, projectId) {
   } catch {
     throw damaged();
   }
-  if (!isRecord7(parsed) || parsed.version !== MEMORY_LOCK_VERSION || typeof parsed.projectId !== "string" || !isRecord7(parsed.files) || !Array.isArray(parsed.outbox)) {
+  if (!isRecord8(parsed) || parsed.version !== MEMORY_LOCK_VERSION || typeof parsed.projectId !== "string" || !isRecord8(parsed.files) || !Array.isArray(parsed.outbox)) {
     throw damaged();
   }
   if (parsed.projectId !== projectId) {
@@ -21713,14 +23014,14 @@ function planPull(input) {
   const remotePaths = /* @__PURE__ */ new Set();
   for (const remote of input.remote) {
     remotePaths.add(remote.path);
-    const path38 = remote.path;
-    if (input.tracked.has(path38)) {
-      actions.push({ kind: "tracked", path: path38 });
+    const path42 = remote.path;
+    if (input.tracked.has(path42)) {
+      actions.push({ kind: "tracked", path: path42 });
       continue;
     }
-    const local = input.local.get(path38);
-    const entry = input.lock.files[path38];
-    const accept = input.acceptRemote.has(path38);
+    const local = input.local.get(path42);
+    const entry = input.lock.files[path42];
+    const accept = input.acceptRemote.has(path42);
     if (entry === void 0) {
       if (local === void 0) {
         actions.push({ kind: "write", file: remote, reason: "new" });
@@ -21735,7 +23036,7 @@ function planPull(input) {
       } else {
         actions.push({
           kind: "keep",
-          path: path38,
+          path: path42,
           reason: "untracked-differs"
         });
       }
@@ -21748,7 +23049,7 @@ function planPull(input) {
       actions.push(
         accept ? { kind: "write", file: remote, reason: "updated" } : {
           kind: "keep",
-          path: path38,
+          path: path42,
           reason: "deleted-locally-changed-remotely"
         }
       );
@@ -21773,33 +23074,35 @@ function planPull(input) {
     } else if (accept) {
       actions.push({ kind: "write", file: remote, reason: "updated" });
     } else {
-      actions.push({ kind: "keep", path: path38, reason: "modified" });
+      actions.push({ kind: "keep", path: path42, reason: "modified" });
     }
   }
-  for (const [path38, entry] of Object.entries(input.lock.files)) {
-    if (remotePaths.has(path38)) {
+  for (const [path42, entry] of Object.entries(input.lock.files)) {
+    if (remotePaths.has(path42)) {
       continue;
     }
     if (entry.origin === "push") {
       continue;
     }
-    const local = input.local.get(path38);
+    const local = input.local.get(path42);
     if (local === void 0) {
-      actions.push({ kind: "forget", path: path38 });
-    } else if (local === entry.contentHash) {
-      actions.push({
-        kind: "delete",
-        path: path38,
-        expectedHash: entry.contentHash
-      });
+      actions.push({ kind: "forget", path: path42 });
+    } else if (local === entry.contentHash || input.acceptRemote.has(path42)) {
+      actions.push({ kind: "delete", path: path42, expectedHash: local });
     } else {
       actions.push({
         kind: "keep",
-        path: path38,
+        path: path42,
         reason: "modified-and-removed"
       });
     }
   }
+  for (const path42 of input.acceptRemote) {
+    const local = input.local.get(path42);
+    if (local !== void 0 && !remotePaths.has(path42) && input.lock.files[path42] === void 0 && !input.tracked.has(path42)) {
+      actions.push({ kind: "delete", path: path42, expectedHash: local });
+    }
+  }
   return actions.sort((a, b) => {
     const left = actionPath(a);
     const right = actionPath(b);
@@ -21809,13 +23112,13 @@ function planPull(input) {
 function actionPath(action) {
   return action.kind === "write" || action.kind === "adopt" ? action.file.path : action.path;
 }
-function targetOf2(path38, targets) {
-  return targets.find((target) => path38.startsWith(`${target.folder}/`));
+function targetOf2(path42, targets) {
+  return targets.find((target) => path42.startsWith(`${target.folder}/`));
 }
-function recordFor(outbox, path38, contentHash) {
+function recordFor(outbox, path42, contentHash) {
   return outbox.find(
     (record) => record.paths.some(
-      (entry) => entry.path === path38 && entry.contentHash === contentHash
+      (entry) => entry.path === path42 && entry.contentHash === contentHash
     )
   );
 }
@@ -21841,29 +23144,29 @@ function planPush(input) {
     }
     plan.changes.push(change);
   };
-  for (const [path38, hash] of input.local) {
-    const target = targetOf2(path38, input.targets);
+  for (const [path42, hash] of input.local) {
+    const target = targetOf2(path42, input.targets);
     if (target === void 0) {
       continue;
     }
-    const entry = input.lock.files[path38];
-    if (input.tracked.has(path38)) {
-      plan.skipped.push({ path: path38, reason: "tracked" });
+    const entry = input.lock.files[path42];
+    if (input.tracked.has(path42)) {
+      plan.skipped.push({ path: path42, reason: "tracked" });
       continue;
     }
     if (entry === void 0) {
       consider(
-        { path: path38, targetId: target.id, kind: "new", contentHash: hash },
+        { path: path42, targetId: target.id, kind: "new", contentHash: hash },
         hash
       );
     } else if (entry.contentHash !== hash) {
       if (entry.blobOid === null) {
-        plan.skipped.push({ path: path38, reason: "version-unknown" });
+        plan.skipped.push({ path: path42, reason: "version-unknown" });
         continue;
       }
       consider(
         {
-          path: path38,
+          path: path42,
           targetId: target.id,
           kind: "modified",
           ifMatchOid: entry.blobOid,
@@ -21873,21 +23176,21 @@ function planPush(input) {
       );
     }
   }
-  for (const [path38, entry] of Object.entries(input.lock.files)) {
-    if (input.local.has(path38)) {
+  for (const [path42, entry] of Object.entries(input.lock.files)) {
+    if (input.local.has(path42)) {
       continue;
     }
-    const target = targetOf2(path38, input.targets);
+    const target = targetOf2(path42, input.targets);
     if (target === void 0) {
       continue;
     }
     if (entry.blobOid === null) {
-      plan.skipped.push({ path: path38, reason: "version-unknown" });
+      plan.skipped.push({ path: path42, reason: "version-unknown" });
       continue;
     }
     consider(
       {
-        path: path38,
+        path: path42,
         targetId: target.id,
         kind: "deleted",
         ifMatchOid: entry.blobOid
@@ -21976,10 +23279,16 @@ async function pull(context, options = {}) {
   }
   const folders = targets.map((target) => target.folder);
   const tracked = await context.git.tracked(folders) ?? /* @__PURE__ */ new Set();
+  const acceptRemote = new Set(
+    (options.acceptRemote ?? []).filter(
+      (file) => path41.posix.normalize(file) === file && folders.some((folder) => file.startsWith(`${folder}/`))
+    )
+  );
   const local = /* @__PURE__ */ new Map();
   const relevant = /* @__PURE__ */ new Set([
     ...remote.map((file) => file.path),
-    ...Object.keys(lock.files)
+    ...Object.keys(lock.files),
+    ...acceptRemote
   ]);
   for (const file of relevant) {
     const hash = await hashLocalFile2(context.root, file);
@@ -21992,7 +23301,7 @@ async function pull(context, options = {}) {
     local,
     lock,
     tracked,
-    acceptRemote: new Set(options.acceptRemote ?? [])
+    acceptRemote
   });
   await applyPull(context, lock, actions, result);
   await resolveOutbox(context, lock);
@@ -22405,10 +23714,10 @@ function recordLines(record) {
       const lines2 = [
         `  conflict in ${where}: nothing was written; these changed on the server since you last pulled:`
       ];
-      for (const path38 of record.paths) {
-        if (path38.verdict !== void 0) {
+      for (const path42 of record.paths) {
+        if (path42.verdict !== void 0) {
           lines2.push(
-            `    ${path38.path}: ${path38.verdict.code}${path38.verdict.currentOid ? ` (now ${path38.verdict.currentOid.slice(0, 10)})` : ""}`
+            `    ${path42.path}: ${path42.verdict.code}${path42.verdict.currentOid ? ` (now ${path42.verdict.currentOid.slice(0, 10)})` : ""}`
           );
         }
       }
@@ -22420,7 +23729,7 @@ function recordLines(record) {
     case "REFUSED":
       return [
         `  refused in ${where}: ${record.detail ?? "see the server"}. Fix the files named below, then push again, or run \`fabric memory status --clear\` to dismiss.`,
-        ...record.paths.filter((path38) => path38.verdict !== void 0).map((path38) => `    ${path38.path}: ${path38.verdict?.code}`)
+        ...record.paths.filter((path42) => path42.verdict !== void 0).map((path42) => `    ${path42.path}: ${path42.verdict?.code}`)
       ];
     case "FAILED":
       return [
@@ -22450,9 +23759,9 @@ function pullLines(result) {
     );
   }
   lines2.push(...keptLines(result));
-  for (const path38 of result.trackedByGit) {
+  for (const path42 of result.trackedByGit) {
     lines2.push(
-      `skipped ${path38}: your repository tracks it; use git for that file.`
+      `skipped ${path42}: your repository tracks it; use git for that file.`
     );
   }
   for (const settled of result.settled) {