@fabricorg/cli 0.2.0 → 0.3.0

package/dist/fabric.js

@@ -52,7 +52,7 @@ var __async = (__this, __arguments, generator) => {
 };
 
 // src/bin/fabric.ts
-import { Command as Command19 } from "commander";
+import { Command as Command20 } from "commander";
 
 // src/commands/agents/index.ts
 import { Command } from "commander";
@@ -295,7 +295,7 @@ ${valStr}` : `${pad}${k}: ${valStr}`;
 }
 
 // src/lib/client.ts
-function getClient() {
+function getClient(overrides = {}) {
   const apiKey = getApiKey();
   if (!apiKey) {
     printError(
@@ -304,7 +304,10 @@ function getClient() {
     );
   }
   try {
-    return new FabricClient({ apiKey, baseUrl: getBaseUrl() });
+    return new FabricClient(__spreadValues(__spreadValues({
+      apiKey,
+      baseUrl: getBaseUrl()
+    }, overrides.timeoutMs !== void 0 ? { timeoutMs: overrides.timeoutMs } : {}), overrides.retry !== void 0 ? { retry: overrides.retry } : {}));
   } catch (err) {
     if (err instanceof FabricAuthError) {
       printError(err.message, 3);
@@ -314,39 +317,45 @@ function getClient() {
 }
 
 // src/lib/context.ts
-function refusePersonal(source) {
-  return printError(
-    `${source} selects personal context, which no longer exists \u2014 every command runs inside an organization.
-Name one with --org <slug>, or set a default with:
-  fabric ctx use org <slug>`,
-    2
-  );
-}
-function resolveContext(personal, org, required = true) {
+var PERSONAL_RETIRED_HINT = "selects personal context, which no longer exists \u2014 every command runs inside an organization.\nName one with --org <slug>, or set a default with:\n  fabric ctx use org <slug>";
+function tryResolveContext(personal, org, required = true) {
   if (personal) {
-    refusePersonal("--personal");
+    return {
+      ok: false,
+      message: `--personal ${PERSONAL_RETIRED_HINT}`,
+      exitCode: 2
+    };
   }
   if (org) {
-    return { type: "org", slug: org };
+    return { ok: true, context: { type: "org", slug: org } };
   }
   const stored = getDefaultContext();
-  if (stored) {
-    if (stored.type === "personal") {
-      refusePersonal(
-        process.env.FABRIC_PERSONAL === "1" ? "FABRIC_PERSONAL=1" : "Your stored default context"
-      );
-    }
-    if (stored.type === "org") {
-      return { type: "org", slug: stored.slug };
-    }
+  if ((stored == null ? void 0 : stored.type) === "personal") {
+    const source = process.env.FABRIC_PERSONAL === "1" ? "FABRIC_PERSONAL=1" : "Your stored default context";
+    return {
+      ok: false,
+      message: `${source} ${PERSONAL_RETIRED_HINT}`,
+      exitCode: 2
+    };
+  }
+  if ((stored == null ? void 0 : stored.type) === "org") {
+    return { ok: true, context: { type: "org", slug: stored.slug } };
   }
   if (required) {
-    printError(
-      "Context is required. Use --org <slug>, or set a default with:\n  fabric ctx use org <slug>",
-      2
-    );
+    return {
+      ok: false,
+      message: "Context is required. Use --org <slug>, or set a default with:\n  fabric ctx use org <slug>",
+      exitCode: 2
+    };
+  }
+  return { ok: true, context: void 0 };
+}
+function resolveContext(personal, org, required = true) {
+  const resolution = tryResolveContext(personal, org, required);
+  if (!resolution.ok) {
+    printError(resolution.message, resolution.exitCode);
   }
-  return void 0;
+  return resolution.context;
 }
 
 // src/commands/agents/index.ts
@@ -1269,179 +1278,1932 @@ function buildFramesCommand() {
   return frames;
 }
 
-// src/commands/mcp/index.ts
+// src/commands/instructions/index.ts
+import path4 from "path";
 import { Command as Command11 } from "commander";
-function buildMcpCommand() {
-  const mcp = new Command11("mcp").description(
-    "Manage MCP servers and configurations"
+
+// src/lib/instructions/apply.ts
+import { createHash as createHash2 } from "crypto";
+import { chmod } from "fs/promises";
+
+// src/lib/instructions/paths.ts
+var DRIVE_LETTER = /^[A-Za-z]:/;
+var RESERVED_DEVICE_NAME = /^(?:CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(?:\.|$)/i;
+var RESERVED_ROOTS = [".git", ".fabric"];
+var RESERVED_EXACT_PATHS = [".claude/settings.local.json"];
+function hasControlCharacter(input) {
+  for (let index = 0; index < input.length; index++) {
+    const code = input.charCodeAt(index);
+    if (code <= 31 || code === 127) {
+      return true;
+    }
+  }
+  return false;
+}
+function checkRelativePath(input) {
+  if (input.length === 0) {
+    return { ok: false, reason: "empty", detail: input };
+  }
+  if (hasControlCharacter(input)) {
+    return { ok: false, reason: "control_char", detail: input };
+  }
+  if (input.includes("\\")) {
+    return { ok: false, reason: "backslash", detail: input };
+  }
+  if (input.startsWith("/") || DRIVE_LETTER.test(input)) {
+    return { ok: false, reason: "absolute", detail: input };
+  }
+  if (input.endsWith("/")) {
+    return { ok: false, reason: "trailing_separator", detail: input };
+  }
+  const segments = input.split("/");
+  if (segments.some((s) => s.length === 0)) {
+    return { ok: false, reason: "empty", detail: input };
+  }
+  if (segments.some((s) => s === "." || s === "..")) {
+    return { ok: false, reason: "traversal", detail: input };
+  }
+  for (const segment of segments) {
+    if (/[. ]$/.test(segment)) {
+      return {
+        ok: false,
+        reason: "trailing_dot_or_space",
+        detail: input
+      };
+    }
+    if (RESERVED_DEVICE_NAME.test(segment)) {
+      return {
+        ok: false,
+        reason: "reserved_device_name",
+        detail: input
+      };
+    }
+    if (segment.includes(":")) {
+      return {
+        ok: false,
+        reason: "alternate_data_stream",
+        detail: input
+      };
+    }
+  }
+  return { ok: true, path: input };
+}
+function isReservedPath(input) {
+  var _a2;
+  const first = (_a2 = input.split("/")[0]) == null ? void 0 : _a2.toLowerCase();
+  if (RESERVED_ROOTS.some((root) => first === root)) {
+    return true;
+  }
+  const key = collisionKey(input);
+  return RESERVED_EXACT_PATHS.some(
+    (reserved) => collisionKey(reserved) === key
   );
-  mcp.command("servers").description("List accessible MCP servers (system + custom)").option("--org <slug>", "Organization context").option("--personal", "Retired \u2014 context is organization-only").option(
-    "--format <format>",
-    "Output format: table|json|yaml|csv",
-    "table"
-  ).option("-q, --quiet", "Print server keys only").action(
-    (opts) => __async(null, null, function* () {
-      const ctx = resolveContext(opts.personal, opts.org, false);
-      const client = getClient();
-      let list;
-      try {
-        list = yield client.mcp.listServers({
-          org: (ctx == null ? void 0 : ctx.type) === "org" ? ctx.slug : void 0
-        });
-      } catch (err) {
-        printError(err.message, 1);
+}
+function collisionKey(input) {
+  return input.normalize("NFC").toLowerCase();
+}
+function findCollision(paths) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const candidate of paths) {
+    const key = collisionKey(candidate);
+    const previous = seen.get(key);
+    if (previous !== void 0) {
+      return { first: previous, second: candidate };
+    }
+    seen.set(key, candidate);
+  }
+  return null;
+}
+function describeRejection(rejection) {
+  switch (rejection.reason) {
+    case "empty":
+      return `empty or malformed path (${JSON.stringify(rejection.detail)})`;
+    case "absolute":
+      return `absolute path refused: ${rejection.detail}`;
+    case "traversal":
+      return `path traversal refused: ${rejection.detail}`;
+    case "backslash":
+      return `backslash in path refused: ${rejection.detail}`;
+    case "control_char":
+      return `control character in path refused: ${JSON.stringify(rejection.detail)}`;
+    case "trailing_separator":
+      return `path names a directory, not a file: ${rejection.detail}`;
+    case "trailing_dot_or_space":
+      return `path segment ending in a dot or space refused: ${rejection.detail}`;
+    case "reserved_device_name":
+      return `reserved device name refused: ${rejection.detail}`;
+    case "alternate_data_stream":
+      return `colon in path refused: ${rejection.detail}`;
+    case "reserved_path":
+      return `this tool never writes or deletes ${RESERVED_ROOTS.join(", ")} or ${RESERVED_EXACT_PATHS.join(", ")}: ${rejection.detail}`;
+    case "not_a_regular_file":
+      return `path is not a regular file: ${rejection.detail}`;
+    case "escapes_destination":
+      return `path resolves outside the destination: ${rejection.detail}`;
+    case "symlink":
+      return `refusing to follow a symlink: ${rejection.detail}`;
+    case "not_a_directory":
+      return `a path component is not a directory: ${rejection.detail}`;
+    case "collision":
+      return `two paths name the same file on a case- or Unicode-insensitive filesystem: ${rejection.detail}`;
+  }
+}
+
+// src/lib/instructions/safe-write.ts
+import { createHash, randomBytes } from "crypto";
+import {
+  lstat,
+  mkdir,
+  open,
+  readFile,
+  realpath,
+  rename,
+  unlink
+} from "fs/promises";
+import path from "path";
+var ALLOWED_MODES = /* @__PURE__ */ new Set([420, 493]);
+function isAllowedMode(mode) {
+  if (mode === null || mode === void 0) {
+    return true;
+  }
+  if (!Number.isInteger(mode) || mode < 0) {
+    return false;
+  }
+  const type = mode & 61440;
+  if (type !== 0 && type !== 32768) {
+    return false;
+  }
+  return ALLOWED_MODES.has(mode & 4095);
+}
+function permissionBits(mode) {
+  if (mode === null || mode === void 0) {
+    return null;
+  }
+  return mode & 4095;
+}
+function resolveDestinationRoot(destination) {
+  return __async(this, null, function* () {
+    yield mkdir(destination, { recursive: true });
+    return realpath(destination);
+  });
+}
+function assertSafeTarget(root, relativePath) {
+  return __async(this, null, function* () {
+    const target = path.resolve(root, relativePath);
+    if (target === root || !target.startsWith(root + path.sep)) {
+      return {
+        ok: false,
+        reason: "escapes_destination",
+        detail: relativePath
+      };
+    }
+    const segments = relativePath.split("/");
+    let current = root;
+    let deepestExisting = root;
+    for (const [index, segment] of segments.entries()) {
+      current = path.join(current, segment);
+      const stats = yield lstatOrNull(current);
+      if (stats === null) {
+        break;
+      }
+      if (stats.isSymbolicLink()) {
+        return { ok: false, reason: "symlink", detail: current };
+      }
+      if (index < segments.length - 1 && !stats.isDirectory()) {
+        return { ok: false, reason: "not_a_directory", detail: current };
+      }
+      deepestExisting = current;
+    }
+    if (deepestExisting !== root) {
+      const canonical = yield realpath(deepestExisting).catch(() => null);
+      if (canonical !== null && canonical !== root && !canonical.startsWith(root + path.sep)) {
+        return {
+          ok: false,
+          reason: "escapes_destination",
+          detail: relativePath
+        };
       }
-      if (opts.quiet) {
-        for (const s of list) {
-          process.stdout.write(`${s.key}
-`);
-        }
-        return;
+    }
+    return { ok: true, path: target };
+  });
+}
+function assertWritableTarget(root, relativePath) {
+  return __async(this, null, function* () {
+    const check = yield assertSafeTarget(root, relativePath);
+    if (!check.ok) {
+      return check;
+    }
+    const stats = yield lstatOrNull(check.path);
+    if (stats === null) {
+      return check;
+    }
+    if (stats.isSymbolicLink()) {
+      return { ok: false, reason: "symlink", detail: check.path };
+    }
+    if (!stats.isFile()) {
+      return { ok: false, reason: "not_a_regular_file", detail: check.path };
+    }
+    return check;
+  });
+}
+function readFileSafely(root, relativePath) {
+  return __async(this, null, function* () {
+    const check = yield assertWritableTarget(root, relativePath);
+    if (!check.ok) {
+      throw new Error(`Refusing to sync: ${describeRejection(check)}.`);
+    }
+    const stats = yield lstatOrNull(check.path);
+    if (stats === null) {
+      return null;
+    }
+    try {
+      return { bytes: yield readFile(check.path), mode: stats.mode };
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return null;
       }
-      printOutput(list, {
-        format: opts.format,
-        columns: [
-          "key",
-          "name",
-          "transport",
-          "category",
-          "isSystemProvided"
-        ]
-      });
-    })
-  );
-  const configs = new Command11("configs").description(
-    "Manage MCP configurations"
-  );
-  configs.command("list", { isDefault: true }).description("List your MCP configurations").option("--org <slug>", "Organization context").option("--personal", "Retired \u2014 context is organization-only").option(
-    "--format <format>",
-    "Output format: table|json|yaml|csv",
-    "table"
-  ).option("-q, --quiet", "Print IDs only").action(
-    (opts) => __async(null, null, function* () {
-      const ctx = resolveContext(opts.personal, opts.org, false);
-      const client = getClient();
-      let list;
-      try {
-        list = yield client.mcp.listConfigs({
-          org: (ctx == null ? void 0 : ctx.type) === "org" ? ctx.slug : void 0
-        });
-      } catch (err) {
-        printError(err.message, 1);
+      throw error;
+    }
+  });
+}
+function resolveExistingRoot(destination) {
+  return __async(this, null, function* () {
+    return realpath(destination).catch(() => path.resolve(destination));
+  });
+}
+function makeParents(root, relativePath) {
+  return __async(this, null, function* () {
+    const segments = relativePath.split("/").slice(0, -1);
+    let current = root;
+    for (const segment of segments) {
+      current = path.join(current, segment);
+      const stats = yield lstatOrNull(current);
+      if (stats === null) {
+        yield mkdir(current).catch((error) => __async(null, null, function* () {
+          if (error.code !== "EEXIST") {
+            throw error;
+          }
+          const raced = yield lstatOrNull(current);
+          if (raced == null ? void 0 : raced.isSymbolicLink()) {
+            throw new Error(
+              `Refusing to sync: ${describeRejection({ ok: false, reason: "symlink", detail: current })}.`
+            );
+          }
+        }));
+        continue;
       }
-      if (opts.quiet) {
-        for (const c of list) {
-          process.stdout.write(`${c.id}
-`);
-        }
-        return;
+      if (stats.isSymbolicLink()) {
+        throw new Error(
+          `Refusing to sync: ${describeRejection({ ok: false, reason: "symlink", detail: current })}.`
+        );
       }
-      printOutput(list, {
-        format: opts.format,
-        columns: [
-          "id",
-          "serverName",
-          "displayName",
-          "authType",
-          "enabled",
-          "status"
-        ]
-      });
-    })
-  );
-  configs.command("show <id>").description("Show a specific MCP configuration").option("--org <slug>", "Organization context").option("--personal", "Retired \u2014 context is organization-only").option("--format <format>", "Output format: table|json|yaml", "table").action(
-    (id, opts) => __async(null, null, function* () {
-      var _a2, _b, _c, _d, _e, _f, _g;
-      const ctx = resolveContext(opts.personal, opts.org, false);
-      const client = getClient();
-      let config2;
-      try {
-        config2 = yield client.mcp.getConfig(id, {
-          org: (ctx == null ? void 0 : ctx.type) === "org" ? ctx.slug : void 0
-        });
-      } catch (err) {
-        printError(err.message, 1);
+      if (!stats.isDirectory()) {
+        throw new Error(
+          `Refusing to sync: ${describeRejection({ ok: false, reason: "not_a_directory", detail: current })}.`
+        );
       }
-      const fmt = opts.format;
-      if (fmt === "json" || fmt === "yaml") {
-        printOutput(config2, { format: fmt });
-        return;
+    }
+  });
+}
+function writeFileSafely(input) {
+  return __async(this, null, function* () {
+    var _a2;
+    const check = yield assertSafeTarget(input.root, input.relativePath);
+    if (!check.ok) {
+      throw new Error(`Refusing to sync: ${describeRejection(check)}.`);
+    }
+    if (!isAllowedMode(input.mode)) {
+      throw new Error(
+        `Refusing to sync: ${input.relativePath} asks for file mode ${((_a2 = input.mode) != null ? _a2 : 0).toString(8)}, and only 644 and 755 are accepted.`
+      );
+    }
+    yield makeParents(input.root, input.relativePath);
+    const target = check.path;
+    const directory = path.dirname(target);
+    const directoryBefore = yield lstatOrNull(directory);
+    const temporary = path.join(
+      directory,
+      `.${path.basename(target)}.${randomBytes(8).toString("hex")}.tmp`
+    );
+    let handle = null;
+    try {
+      handle = yield open(temporary, "wx", 384);
+      yield handle.writeFile(input.bytes);
+      const bits = permissionBits(input.mode);
+      if (bits !== null && process.platform !== "win32") {
+        yield handle.chmod(bits);
+      }
+      yield handle.close();
+      handle = null;
+      const parentStats = yield lstatOrNull(directory);
+      if (parentStats === null || parentStats.isSymbolicLink()) {
+        throw new Error(
+          `Refusing to sync: ${describeRejection({ ok: false, reason: "symlink", detail: directory })}.`
+        );
       }
-      printRecord({
-        ID: config2.id,
-        Server: (_a2 = config2.serverName) != null ? _a2 : config2.mcpServerId,
-        "Server Key": (_b = config2.serverKey) != null ? _b : "(none)",
-        "Display Name": (_c = config2.displayName) != null ? _c : "(none)",
-        "Base URL": (_d = config2.baseUrl) != null ? _d : "(none)",
-        Transport: (_e = config2.transport) != null ? _e : "(default)",
-        "Auth Type": config2.authType,
-        Enabled: config2.enabled ? "yes" : "no",
-        Status: config2.status,
-        "Last Health Check": (_g = (_f = config2.lastHealthCheckAt) == null ? void 0 : _f.slice(0, 19)) != null ? _g : "(never)",
-        Created: config2.createdAt.slice(0, 10)
-      });
-    })
-  );
-  configs.command("delete <id>").description("Delete an MCP configuration").option("--org <slug>", "Organization context").option("--personal", "Retired \u2014 context is organization-only").option("-y, --yes", "Skip confirmation prompt").action(
-    (id, opts) => __async(null, null, function* () {
-      const ctx = resolveContext(opts.personal, opts.org, false);
-      const client = getClient();
-      if (!opts.yes) {
-        process.stderr.write(
-          `Delete MCP config ${id}? This cannot be undone. Pass --yes to confirm.
-`
+      const targetStats = yield lstatOrNull(target);
+      if (targetStats == null ? void 0 : targetStats.isSymbolicLink()) {
+        throw new Error(
+          `Refusing to sync: ${describeRejection({ ok: false, reason: "symlink", detail: target })}.`
         );
-        process.exit(2);
       }
-      try {
-        yield client.mcp.deleteConfig(id, {
-          org: (ctx == null ? void 0 : ctx.type) === "org" ? ctx.slug : void 0
+      yield rename(temporary, target);
+    } catch (error) {
+      yield handle == null ? void 0 : handle.close().catch(() => {
+      });
+      if (yield isSameDirectory(directory, directoryBefore)) {
+        yield unlink(temporary).catch(() => {
         });
-      } catch (err) {
-        printError(err.message, 1);
       }
-      process.stdout.write(`MCP config ${id} deleted.
-`);
-    })
-  );
-  mcp.addCommand(configs);
-  mcp.command("serve").description(
-    "Run a stdio MCP server exposing this workspace's whole integration catalog. Point Claude Desktop, Cursor, or any MCP client at it."
-  ).action(() => __async(null, null, function* () {
-    const { runStdio } = yield import("@fabricorg/sdk-mcp/stdio");
-    yield runStdio();
-  }));
-  return mcp;
+      throw error;
+    }
+  });
 }
-
-// src/commands/orgs/index.ts
-import { Command as Command12 } from "commander";
-function buildOrgsCommand() {
-  const orgs = new Command12("orgs").description("Manage organizations");
-  orgs.command("list").description("List organizations you belong to").option(
-    "--format <format>",
-    "Output format: table|json|yaml|csv",
-    "table"
-  ).option("-q, --quiet", "Print slugs only").action((opts) => __async(null, null, function* () {
-    const client = getClient();
-    let list;
-    try {
-      list = yield client.orgs.list();
-    } catch (err) {
-      printError(err.message, 1);
+function isSameDirectory(directory, before) {
+  return __async(this, null, function* () {
+    if (before === null) {
+      return false;
     }
-    if (opts.quiet) {
-      for (const org of list) {
-        process.stdout.write(`${org.slug}
-`);
-      }
-      return;
+    const now = yield lstatOrNull(directory);
+    return now !== null && now.dev === before.dev && now.ino === before.ino;
+  });
+}
+function deleteFileSafely(root, relativePath, expectedSha256) {
+  return __async(this, null, function* () {
+    const check = yield assertSafeTarget(root, relativePath);
+    if (!check.ok) {
+      throw new Error(`Refusing to sync: ${describeRejection(check)}.`);
     }
-    printOutput(list, {
-      format: opts.format,
-      columns: ["name", "slug", "role", "joinedAt"]
-    });
-  }));
+    const stats = yield lstatOrNull(check.path);
+    if (stats === null) {
+      return "missing";
+    }
+    if (stats.isSymbolicLink()) {
+      throw new Error(
+        `Refusing to sync: ${describeRejection({ ok: false, reason: "symlink", detail: check.path })}.`
+      );
+    }
+    if (!stats.isFile()) {
+      throw new Error(
+        `Refusing to sync: ${describeRejection({ ok: false, reason: "not_a_regular_file", detail: check.path })}.`
+      );
+    }
+    let actual;
+    try {
+      actual = createHash("sha256").update(yield readFile(check.path)).digest("hex");
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return "missing";
+      }
+      throw error;
+    }
+    if (actual !== expectedSha256) {
+      return "modified";
+    }
+    try {
+      yield unlink(check.path);
+      return "deleted";
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return "missing";
+      }
+      throw error;
+    }
+  });
+}
+function lstatOrNull(target) {
+  return __async(this, null, function* () {
+    try {
+      return yield lstat(target);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return null;
+      }
+      throw error;
+    }
+  });
+}
+function resolvesInside(root, candidate) {
+  return __async(this, null, function* () {
+    const canonicalRoot = yield realpath(root).catch(() => path.resolve(root));
+    const canonicalCandidate = yield realpathDeepest(candidate);
+    return canonicalCandidate === canonicalRoot || canonicalCandidate.startsWith(canonicalRoot + path.sep);
+  });
+}
+function realpathDeepest(candidate) {
+  return __async(this, null, function* () {
+    const absolute = path.resolve(candidate);
+    const tail = [];
+    let current = absolute;
+    for (; ; ) {
+      const resolved = yield realpath(current).catch(() => null);
+      if (resolved !== null) {
+        return tail.length === 0 ? resolved : path.join(resolved, ...tail);
+      }
+      const parent = path.dirname(current);
+      if (parent === current) {
+        return absolute;
+      }
+      tail.unshift(path.basename(current));
+      current = parent;
+    }
+  });
+}
+
+// src/lib/instructions/apply.ts
+function applyPlan(input) {
+  return __async(this, null, function* () {
+    var _a2, _b;
+    const { root, plan, contents } = input;
+    for (const entry of [
+      ...plan.writes,
+      ...plan.verified,
+      ...plan.deletes,
+      ...plan.keptRenamed
+    ]) {
+      const check = yield assertWritableTarget(root, entry.path);
+      if (!check.ok) {
+        throw new Error(
+          `Refusing to sync: ${describeRejection(check)}. Nothing was written.`
+        );
+      }
+    }
+    for (const entry of plan.writes) {
+      if (!isAllowedMode(entry.mode)) {
+        throw new Error(
+          `Refusing to sync: ${entry.path} asks for file mode ${((_a2 = entry.mode) != null ? _a2 : 0).toString(8)}, and only 644 and 755 are accepted. Nothing was written.`
+        );
+      }
+      const bytes = contents.get(entry.path);
+      if (!bytes) {
+        throw new Error(
+          `The downloaded bundle is missing ${entry.path}. Nothing was written.`
+        );
+      }
+      const actual = createHash2("sha256").update(bytes).digest("hex");
+      if (actual !== entry.sha256) {
+        throw new Error(
+          `Checksum mismatch for ${entry.path}: the published snapshot expects ${entry.sha256} and the downloaded bundle contains ${actual}. Nothing was written.`
+        );
+      }
+    }
+    const written = [];
+    const deleted = [];
+    const remoded = [];
+    const keptModified = [];
+    for (const entry of plan.writes) {
+      const bytes = contents.get(entry.path);
+      yield writeFileSafely({
+        root,
+        relativePath: entry.path,
+        bytes,
+        mode: (_b = entry.mode) != null ? _b : null
+      });
+      written.push(entry.path);
+    }
+    for (const entry of plan.verified) {
+      if (yield applyMode(root, entry)) {
+        remoded.push(entry.path);
+      }
+    }
+    for (const entry of plan.deletes) {
+      if (entry.sha256 === void 0) {
+        throw new Error(
+          `Refusing to delete ${entry.path}: the plan carries no hash for it.`
+        );
+      }
+      const outcome = yield deleteFileSafely(root, entry.path, entry.sha256);
+      if (outcome === "deleted") {
+        deleted.push(entry.path);
+      } else if (outcome === "modified") {
+        keptModified.push(entry.path);
+      }
+    }
+    return { written, deleted, remoded, keptModified };
+  });
+}
+function applyMode(root, entry) {
+  return __async(this, null, function* () {
+    var _a2;
+    const bits = permissionBits(entry.mode);
+    if (bits === null || process.platform === "win32") {
+      return false;
+    }
+    if (!isAllowedMode(entry.mode)) {
+      throw new Error(
+        `Refusing to sync: ${entry.path} asks for file mode ${((_a2 = entry.mode) != null ? _a2 : 0).toString(8)}, and only 644 and 755 are accepted.`
+      );
+    }
+    const check = yield assertWritableTarget(root, entry.path);
+    if (!check.ok) {
+      throw new Error(`Refusing to sync: ${describeRejection(check)}.`);
+    }
+    try {
+      yield chmod(check.path, bits);
+      return true;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return false;
+      }
+      throw error;
+    }
+  });
+}
+
+// src/lib/instructions/bundle.ts
+import { unzipSync } from "fflate";
+function fetchBundle(url, options) {
+  return __async(this, null, function* () {
+    var _a2, _b, _c, _d;
+    const fetchImpl = (_a2 = options.fetchImpl) != null ? _a2 : fetch;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), options.timeoutMs);
+    const onExternalAbort = () => controller.abort();
+    (_b = options.signal) == null ? void 0 : _b.addEventListener("abort", onExternalAbort, { once: true });
+    if ((_c = options.signal) == null ? void 0 : _c.aborted) {
+      controller.abort();
+    }
+    try {
+      const response = yield fetchImpl(url, { signal: controller.signal });
+      if (!response.ok) {
+        throw new Error(
+          `Downloading the coding-instructions bundle failed with HTTP ${response.status}.`
+        );
+      }
+      const declared = Number(response.headers.get("content-length"));
+      if (Number.isFinite(declared) && declared > options.maxBytes) {
+        throw new Error(
+          `The coding-instructions bundle declares ${declared} bytes and this snapshot's manifest allows at most ${options.maxBytes}. Nothing was written.`
+        );
+      }
+      return yield readBounded(response, options.maxBytes);
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error(
+          `Downloading the coding-instructions bundle timed out after ${options.timeoutMs}ms.`
+        );
+      }
+      throw error;
+    } finally {
+      clearTimeout(timer);
+      (_d = options.signal) == null ? void 0 : _d.removeEventListener("abort", onExternalAbort);
+    }
+  });
+}
+function readBounded(response, maxBytes) {
+  return __async(this, null, function* () {
+    const body = response.body;
+    if (!body) {
+      const bytes = new Uint8Array(yield response.arrayBuffer());
+      if (bytes.length > maxBytes) {
+        throw new Error(
+          `The coding-instructions bundle is larger than the ${maxBytes} bytes this snapshot's manifest allows. Nothing was written.`
+        );
+      }
+      return bytes;
+    }
+    const reader = body.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+      for (; ; ) {
+        const { done, value } = yield reader.read();
+        if (done) {
+          break;
+        }
+        if (!value) {
+          continue;
+        }
+        total += value.length;
+        if (total > maxBytes) {
+          throw new Error(
+            `The coding-instructions bundle is larger than the ${maxBytes} bytes this snapshot's manifest allows. Nothing was written.`
+          );
+        }
+        chunks.push(value);
+      }
+    } finally {
+      yield reader.cancel().catch(() => {
+      });
+    }
+    const archive = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+      archive.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return archive;
+  });
+}
+function extractBundle(archive, wanted) {
+  const sizes = /* @__PURE__ */ new Map();
+  for (const entry of wanted) {
+    sizes.set(entry.path, entry.size);
+  }
+  if (sizes.size === 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const unzipped = unzipSync(archive, {
+    filter: (file) => {
+      const expected = sizes.get(file.name);
+      if (expected === void 0) {
+        return false;
+      }
+      if (seen.has(file.name)) {
+        throw new Error(
+          `The downloaded bundle contains ${file.name} more than once. Nothing was written.`
+        );
+      }
+      seen.add(file.name);
+      if (file.originalSize !== void 0 && file.originalSize !== expected) {
+        throw new Error(
+          `The downloaded bundle declares ${file.originalSize} bytes for ${file.name} and the manifest says ${expected}. Nothing was written.`
+        );
+      }
+      return true;
+    }
+  });
+  const contents = /* @__PURE__ */ new Map();
+  for (const [name, bytes] of Object.entries(unzipped)) {
+    const expected = sizes.get(name);
+    if (expected === void 0) {
+      continue;
+    }
+    if (bytes.length !== expected) {
+      throw new Error(
+        `The downloaded bundle holds ${bytes.length} bytes for ${name} and the manifest says ${expected}. Nothing was written.`
+      );
+    }
+    contents.set(name, bytes);
+  }
+  return contents;
+}
+
+// src/lib/instructions/hook.ts
+import { readFile as readFile2 } from "fs/promises";
+import path2 from "path";
+var CLAUDE_SETTINGS_RELATIVE_PATH = path2.join(
+  ".claude",
+  "settings.local.json"
+);
+var CLAUDE_SETTINGS_POSIX_PATH = ".claude/settings.local.json";
+var HOOK_TIMEOUT_SECONDS = 15;
+var HOOK_SUBCOMMANDS = /* @__PURE__ */ new Set(["check", "sync"]);
+function buildHookCommand(projectId, apply, org) {
+  const verb = apply ? "sync" : "check";
+  const context = org ? ` --org ${org}` : "";
+  return `fabric instructions ${verb} --project ${projectId}${context} --hook`;
+}
+function assertKeyStaysOutside(destination, configPath) {
+  return __async(this, null, function* () {
+    if (yield resolvesInside(destination, configPath)) {
+      throw new Error(
+        `The CLI stores its API key at ${configPath}, which resolves inside ${destination}. Writing a session hook here would leave a live credential in the repository. Move the CLI config outside the project (set XDG_CONFIG_HOME) or export FABRIC_API_KEY instead, then run this again.`
+      );
+    }
+  });
+}
+function mergeSessionStartHook(input) {
+  return __async(this, null, function* () {
+    const settingsPath = path2.join(input.root, CLAUDE_SETTINGS_RELATIVE_PATH);
+    let existingRaw = null;
+    try {
+      existingRaw = yield readFile2(settingsPath, "utf8");
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+    let settings = {};
+    if (existingRaw !== null && existingRaw.trim().length > 0) {
+      let parsed;
+      try {
+        parsed = JSON.parse(existingRaw);
+      } catch (e) {
+        throw new Error(
+          `${settingsPath} is not valid JSON. Fix or remove it, then run this again \u2014 it was left untouched.`
+        );
+      }
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new Error(
+          `${settingsPath} does not contain a JSON object. It was left untouched.`
+        );
+      }
+      settings = parsed;
+    }
+    if (settings.hooks !== void 0 && !isRecord(settings.hooks)) {
+      throw refuseShape(settingsPath, '"hooks" is not an object');
+    }
+    const hooks = isRecord(settings.hooks) ? __spreadValues({}, settings.hooks) : {};
+    if (hooks.SessionStart !== void 0 && !Array.isArray(hooks.SessionStart)) {
+      throw refuseShape(settingsPath, '"hooks.SessionStart" is not an array');
+    }
+    const rawGroups = Array.isArray(hooks.SessionStart) ? hooks.SessionStart : [];
+    for (const [index, group] of rawGroups.entries()) {
+      if (!isRecord(group)) {
+        throw refuseShape(
+          settingsPath,
+          `"hooks.SessionStart[${index}]" is not an object`
+        );
+      }
+      if (group.hooks !== void 0 && !Array.isArray(group.hooks)) {
+        throw refuseShape(
+          settingsPath,
+          `"hooks.SessionStart[${index}].hooks" is not an array`
+        );
+      }
+    }
+    const sessionStart = rawGroups.map(
+      (group) => __spreadProps(__spreadValues({}, group), {
+        hooks: Array.isArray(group == null ? void 0 : group.hooks) ? [...group.hooks] : []
+      })
+    );
+    const replacement = {
+      type: "command",
+      command: input.command,
+      timeout: HOOK_TIMEOUT_SECONDS
+    };
+    let replacedCount = 0;
+    const pruned = [];
+    for (const group of sessionStart) {
+      const kept = group.hooks.filter(
+        (hook) => !isFabricHookFor(hook, input.projectId)
+      );
+      const removed = group.hooks.length - kept.length;
+      replacedCount += removed;
+      if (kept.length === 0 && removed > 0) {
+        continue;
+      }
+      pruned.push(__spreadProps(__spreadValues({}, group), { hooks: kept }));
+    }
+    pruned.push({ hooks: [replacement] });
+    const next = __spreadProps(__spreadValues({}, settings), {
+      hooks: __spreadProps(__spreadValues({}, hooks), { SessionStart: pruned })
+    });
+    yield writeFileSafely({
+      root: input.root,
+      relativePath: CLAUDE_SETTINGS_POSIX_PATH,
+      bytes: new TextEncoder().encode(
+        `${JSON.stringify(next, null, 2).replace(/\r\n/g, "\n")}
+`
+      )
+    });
+    return {
+      settingsPath,
+      command: input.command,
+      createdFile: existingRaw === null,
+      replacedCount
+    };
+  });
+}
+function isFabricHookFor(hook, projectId) {
+  if (!isRecord(hook) || typeof hook.command !== "string") {
+    return false;
+  }
+  const tokens = hook.command.trim().split(/\s+/);
+  if (tokens[0] !== "fabric" || tokens[1] !== "instructions") {
+    return false;
+  }
+  if (tokens[2] === void 0 || !HOOK_SUBCOMMANDS.has(tokens[2])) {
+    return false;
+  }
+  return readProjectToken(tokens) === projectId;
+}
+function readProjectToken(tokens) {
+  var _a2;
+  let found = null;
+  let occurrences = 0;
+  for (let index = 3; index < tokens.length; index++) {
+    const token = tokens[index];
+    if (token === "--project") {
+      occurrences++;
+      found = (_a2 = tokens[index + 1]) != null ? _a2 : null;
+      continue;
+    }
+    if (token.startsWith("--project=")) {
+      occurrences++;
+      found = token.slice("--project=".length);
+    }
+  }
+  return occurrences === 1 ? found : null;
+}
+function refuseShape(settingsPath, what) {
+  return new Error(
+    `${settingsPath} has a shape this tool does not recognise: ${what}. Fix or remove it, then run this again \u2014 it was left untouched.`
+  );
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/lib/instructions/lock.ts
+import { readFile as readFile3 } from "fs/promises";
+import path3 from "path";
+var LOCK_DIRECTORY = ".fabric";
+var LOCK_FILENAME = "instructions.lock";
+var LOCK_VERSION = 1;
+var LOCK_RELATIVE_PATH = `${LOCK_DIRECTORY}/${LOCK_FILENAME}`;
+var SHA256_HEX = /^[0-9a-f]{64}$/;
+function lockPath(destination) {
+  return path3.join(destination, LOCK_DIRECTORY, LOCK_FILENAME);
+}
+function readLock(destination) {
+  return __async(this, null, function* () {
+    const file = lockPath(destination);
+    let raw;
+    try {
+      raw = yield readFile3(file, "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return null;
+      }
+      throw error;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (e) {
+      throw new Error(
+        `${file} is unreadable: it is not valid JSON. Delete it to start from a clean sync.`
+      );
+    }
+    const problem = lockProblem(parsed);
+    if (problem !== null) {
+      throw new Error(
+        `${file} is unreadable: ${problem}. Delete it to start from a clean sync.`
+      );
+    }
+    return parsed;
+  });
+}
+function serializeLock(lock) {
+  return `${JSON.stringify(lock, null, 2).replace(/\r\n/g, "\n")}
+`;
+}
+function writeLock(root, lock) {
+  return __async(this, null, function* () {
+    yield writeFileSafely({
+      root,
+      relativePath: LOCK_RELATIVE_PATH,
+      bytes: new TextEncoder().encode(serializeLock(lock))
+    });
+  });
+}
+function lockProblem(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return "it is not a JSON object";
+  }
+  const candidate = value;
+  if (candidate.version !== LOCK_VERSION) {
+    return `its version is ${JSON.stringify(candidate.version)} and this build writes version ${LOCK_VERSION}`;
+  }
+  for (const field of [
+    "projectId",
+    "snapshotId",
+    "digest",
+    "syncedAt"
+  ]) {
+    const actual = candidate[field];
+    if (typeof actual !== "string" || actual.length === 0) {
+      return `its "${field}" is not a non-empty string`;
+    }
+  }
+  if (typeof candidate.snapshotVersion !== "number" || !Number.isInteger(candidate.snapshotVersion) || candidate.snapshotVersion < 0) {
+    return 'its "snapshotVersion" is not a non-negative integer';
+  }
+  if (typeof candidate.files !== "object" || candidate.files === null || Array.isArray(candidate.files)) {
+    return 'its "files" is not an object';
+  }
+  for (const [filePath, entry] of Object.entries(
+    candidate.files
+  )) {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+      return `its entry for ${JSON.stringify(filePath)} is not an object`;
+    }
+    const record = entry;
+    if (typeof record.sha256 !== "string" || !SHA256_HEX.test(record.sha256)) {
+      return `its entry for ${JSON.stringify(filePath)} has no 64-character hex sha256`;
+    }
+    if (record.mode !== null && (typeof record.mode !== "number" || !Number.isInteger(record.mode) || record.mode < 0)) {
+      return `its entry for ${JSON.stringify(filePath)} has a mode that is neither null nor a non-negative integer`;
+    }
+  }
+  return null;
+}
+
+// src/lib/instructions/manifest.ts
+import { createHash as createHash3 } from "crypto";
+var SHA256_HEX2 = /^[0-9a-f]{64}$/;
+var MANIFEST_LIMITS = {
+  maxFiles: 5e3,
+  maxTotalBytes: 52428800,
+  maxFileBytes: 5242880,
+  maxPathBytes: 1024,
+  maxDepth: 64
+};
+var ZIP_ENTRY_OVERHEAD_BYTES = 512;
+function maxArchiveBytes(entries) {
+  let total = 1048576;
+  for (const entry of entries) {
+    total += entry.size + ZIP_ENTRY_OVERHEAD_BYTES + 2 * Buffer.byteLength(entry.path, "utf8");
+  }
+  return total;
+}
+function computeSnapshotDigest(entries) {
+  const lines = [...entries].sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0).map((entry) => `${entry.path}\0${entry.sha256}
+`).join("");
+  return createHash3("sha256").update(Buffer.from(lines, "utf8")).digest("hex");
+}
+function assertValidManifest(input) {
+  const { manifest, snapshot } = input;
+  if (!Array.isArray(manifest)) {
+    throw new Error(
+      `The server described version ${snapshot.version} as published but sent no file manifest. Nothing was changed.`
+    );
+  }
+  if (manifest.length > MANIFEST_LIMITS.maxFiles) {
+    throw new Error(
+      `The manifest for version ${snapshot.version} lists ${manifest.length} files and a published snapshot holds at most ${MANIFEST_LIMITS.maxFiles}. Nothing was changed.`
+    );
+  }
+  const entries = [];
+  for (const raw of manifest) {
+    entries.push(validateEntry(raw));
+  }
+  const totalBytes = entries.reduce((total, entry) => total + entry.size, 0);
+  if (totalBytes > MANIFEST_LIMITS.maxTotalBytes) {
+    throw new Error(
+      `The manifest for version ${snapshot.version} describes ${totalBytes} bytes and a published snapshot holds at most ${MANIFEST_LIMITS.maxTotalBytes}. Nothing was changed.`
+    );
+  }
+  const collision = findCollision(entries.map((entry) => entry.path));
+  if (collision !== null) {
+    throw new Error(
+      `Refusing to sync: ${describeRejection({
+        ok: false,
+        reason: "collision",
+        detail: `${collision.first} and ${collision.second}`
+      })}.`
+    );
+  }
+  if (entries.length !== snapshot.fileCount) {
+    throw new Error(
+      `The manifest for version ${snapshot.version} lists ${entries.length} files and the snapshot says ${snapshot.fileCount}. Nothing was changed.`
+    );
+  }
+  const recomputed = computeSnapshotDigest(entries);
+  if (recomputed !== snapshot.digest) {
+    throw new Error(
+      `The manifest for version ${snapshot.version} does not match its own digest (${snapshot.digest}); it hashes to ${recomputed}. Nothing was changed.`
+    );
+  }
+  return entries;
+}
+function validateEntry(raw) {
+  var _a2, _b;
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new Error(
+      "The server sent a manifest entry that is not an object. Nothing was changed."
+    );
+  }
+  const entry = raw;
+  if (typeof entry.path !== "string") {
+    throw new Error(
+      "The server sent a manifest entry with no path. Nothing was changed."
+    );
+  }
+  const check = checkRelativePath(entry.path);
+  if (!check.ok) {
+    throw new Error(
+      `Refusing to sync: ${describeRejection(check)}. The published snapshot names a path this tool will not write.`
+    );
+  }
+  const pathBytes = Buffer.byteLength(entry.path, "utf8");
+  if (pathBytes > MANIFEST_LIMITS.maxPathBytes) {
+    throw new Error(
+      `The manifest entry for ${entry.path.slice(0, 80)}\u2026 has a ${pathBytes}-byte path and at most ${MANIFEST_LIMITS.maxPathBytes} is accepted. Nothing was changed.`
+    );
+  }
+  if (entry.path.split("/").length > MANIFEST_LIMITS.maxDepth) {
+    throw new Error(
+      `The manifest entry for ${entry.path} is nested deeper than ${MANIFEST_LIMITS.maxDepth} directories. Nothing was changed.`
+    );
+  }
+  if (isReservedPath(entry.path)) {
+    throw new Error(
+      `Refusing to sync: ${describeRejection({
+        ok: false,
+        reason: "reserved_path",
+        detail: entry.path
+      })}.`
+    );
+  }
+  if (typeof entry.sha256 !== "string" || !SHA256_HEX2.test(entry.sha256)) {
+    throw new Error(
+      `The manifest entry for ${entry.path} has no 64-character hex sha256. Nothing was changed.`
+    );
+  }
+  if (typeof entry.size !== "number" || !Number.isInteger(entry.size) || entry.size < 0) {
+    throw new Error(
+      `The manifest entry for ${entry.path} has no non-negative integer size. Nothing was changed.`
+    );
+  }
+  if (entry.size > MANIFEST_LIMITS.maxFileBytes) {
+    throw new Error(
+      `The manifest entry for ${entry.path} declares ${entry.size} bytes and a published file holds at most ${MANIFEST_LIMITS.maxFileBytes}. Nothing was changed.`
+    );
+  }
+  if (entry.mode !== null && (typeof entry.mode !== "number" || !Number.isInteger(entry.mode))) {
+    throw new Error(
+      `The manifest entry for ${entry.path} has a mode that is neither null nor an integer. Nothing was changed.`
+    );
+  }
+  if (!isAllowedMode(entry.mode)) {
+    throw new Error(
+      `Refusing to sync: ${entry.path} asks for file mode ${((_a2 = entry.mode) != null ? _a2 : 0).toString(8)}, and only 644 and 755 are accepted.`
+    );
+  }
+  return {
+    path: entry.path,
+    sha256: entry.sha256,
+    size: entry.size,
+    mode: entry.mode,
+    kind: (_b = entry.kind) != null ? _b : "OTHER"
+  };
+}
+
+// src/lib/instructions/plan.ts
+import { createHash as createHash4 } from "crypto";
+function hashLocalFile(root, relativePath) {
+  return __async(this, null, function* () {
+    const read = yield readFileSafely(root, relativePath);
+    return read === null ? null : createHash4("sha256").update(read.bytes).digest("hex");
+  });
+}
+function lockPaths(lock) {
+  return lock === null ? [] : Object.keys(lock.files);
+}
+function assertSafeLockPaths(paths) {
+  for (const lockedPath of paths) {
+    const check = checkRelativePath(lockedPath);
+    if (!check.ok) {
+      throw new Error(
+        `Refusing to sync: ${describeRejection(check)}. The lock names a path this tool will not touch.`
+      );
+    }
+    if (isReservedPath(lockedPath)) {
+      throw new Error(
+        `Refusing to sync: ${describeRejection({
+          ok: false,
+          reason: "reserved_path",
+          detail: lockedPath
+        })}. The lock names a path this tool will not touch.`
+      );
+    }
+  }
+  const collision = findCollision(paths);
+  if (collision !== null) {
+    throw new Error(
+      `Refusing to sync: ${describeRejection({
+        ok: false,
+        reason: "collision",
+        detail: `${collision.first} and ${collision.second}`
+      })}. The lock names two paths this tool cannot tell apart.`
+    );
+  }
+}
+function verifyLedger(input) {
+  return __async(this, null, function* () {
+    assertSafeLockPaths(lockPaths(input.lock));
+    const drifted = [];
+    for (const [lockedPath, locked] of Object.entries(input.lock.files)) {
+      let read;
+      try {
+        read = yield readFileSafely(input.root, lockedPath);
+      } catch (error) {
+        drifted.push(
+          `${lockedPath} (${error instanceof Error ? error.message.replace(/^Refusing to sync: /, "").replace(/\.$/, "") : String(error)})`
+        );
+        continue;
+      }
+      if (read === null) {
+        drifted.push(`${lockedPath} (missing)`);
+        continue;
+      }
+      const actual = createHash4("sha256").update(read.bytes).digest("hex");
+      if (actual !== locked.sha256) {
+        drifted.push(`${lockedPath} (edited)`);
+        continue;
+      }
+      if (process.platform !== "win32" && locked.mode !== null && (read.mode & 4095) !== (locked.mode & 4095)) {
+        drifted.push(
+          `${lockedPath} (mode ${(read.mode & 4095).toString(8)}, published as ${(locked.mode & 4095).toString(8)})`
+        );
+      }
+    }
+    return drifted;
+  });
+}
+function computeSyncPlan(input) {
+  return __async(this, null, function* () {
+    var _a2, _b;
+    const { destination, manifest, lock } = input;
+    assertSafeLockPaths(lockPaths(lock));
+    const lockedFiles = new Map(Object.entries((_a2 = lock == null ? void 0 : lock.files) != null ? _a2 : {}));
+    const manifestPaths = new Set(manifest.map((entry) => entry.path));
+    const manifestKeys = new Map(
+      manifest.map(
+        (entry) => [collisionKey(entry.path), entry.path]
+      )
+    );
+    const entries = [];
+    for (const entry of manifest) {
+      const localHash = yield hashLocalFile(destination, entry.path);
+      if (localHash === entry.sha256) {
+        entries.push({
+          path: entry.path,
+          action: "verified",
+          sha256: entry.sha256,
+          mode: entry.mode
+        });
+        continue;
+      }
+      const lockedHash = (_b = lockedFiles.get(entry.path)) == null ? void 0 : _b.sha256;
+      const action = localHash === null ? "added" : localHash === lockedHash ? "updated" : "replaced";
+      entries.push({
+        path: entry.path,
+        action,
+        sha256: entry.sha256,
+        mode: entry.mode
+      });
+    }
+    for (const [lockedPath, locked] of lockedFiles) {
+      if (manifestPaths.has(lockedPath)) {
+        continue;
+      }
+      const renamedTo = manifestKeys.get(collisionKey(lockedPath));
+      if (renamedTo !== void 0) {
+        entries.push({
+          path: lockedPath,
+          action: "kept-renamed",
+          sha256: locked.sha256
+        });
+        continue;
+      }
+      const localHash = yield hashLocalFile(destination, lockedPath);
+      if (localHash === null) {
+        continue;
+      }
+      entries.push({
+        path: lockedPath,
+        action: localHash === locked.sha256 ? "deleted" : "kept-modified",
+        // Carried so the unlink can prove it is still removing the file
+        // this hash described, rather than whatever is at the path by the
+        // time the writes are done.
+        sha256: locked.sha256
+      });
+    }
+    entries.sort((a, b) => a.path.localeCompare(b.path));
+    return {
+      entries,
+      writes: entries.filter(
+        (entry) => entry.action === "added" || entry.action === "updated" || entry.action === "replaced"
+      ),
+      deletes: entries.filter((entry) => entry.action === "deleted"),
+      verified: entries.filter((entry) => entry.action === "verified"),
+      keptModified: entries.filter(
+        (entry) => entry.action === "kept-modified"
+      ),
+      keptRenamed: entries.filter((entry) => entry.action === "kept-renamed")
+    };
+  });
+}
+function nextLock(input) {
+  var _a2;
+  const files = Object.fromEntries(
+    input.manifest.map((entry) => [
+      entry.path,
+      { sha256: entry.sha256, mode: entry.mode }
+    ])
+  );
+  return {
+    version: LOCK_VERSION,
+    projectId: input.projectId,
+    snapshotId: input.snapshot.id,
+    snapshotVersion: input.snapshot.version,
+    digest: input.snapshot.digest,
+    syncedAt: ((_a2 = input.now) != null ? _a2 : /* @__PURE__ */ new Date()).toISOString(),
+    files
+  };
+}
+
+// src/commands/instructions/index.ts
+var HOOK_DEADLINE_MS = 1e4;
+var CHECK_TIMEOUT_MS = 5e3;
+var SYNC_TIMEOUT_MS = 15e3;
+var BUNDLE_TIMEOUT_MS = 6e4;
+var CliFailure = class extends Error {
+  constructor(message, exitCode) {
+    super(message);
+    this.exitCode = exitCode;
+    this.name = "CliFailure";
+  }
+};
+function buildInstructionsCommand() {
+  const instructions = new Command11("instructions").description(
+    "Keep a checkout current with a project's published coding instructions"
+  );
+  instructions.command("check").description(
+    "Report whether the local copy is behind the published one"
+  ).requiredOption("--project <id>", "Project ID").option("--dest <dir>", "Destination directory (default: cwd)").option("--org <slug>", "Organization context").option(
+    "--verify",
+    "Also hash the local files against the lock and report any that drifted"
+  ).option(
+    "--hook",
+    "Session-hook mode: plain text, never fails, never blocks a session"
+  ).option("--format <format>", "Output format: text|json").action(function(opts) {
+    return __async(this, null, function* () {
+      yield run(opts, "check", () => runCheck(opts, formatFor(this)));
+    });
+  });
+  instructions.command("sync").description(
+    "Write the published coding instructions into the checkout"
+  ).requiredOption("--project <id>", "Project ID").option("--dest <dir>", "Destination directory (default: cwd)").option("--org <slug>", "Organization context").option("--dry-run", "Print the plan and write nothing").option(
+    "--hook",
+    "Session-hook mode: plain text, never fails, never blocks a session"
+  ).option("--format <format>", "Output format: text|json").action(function(opts) {
+    return __async(this, null, function* () {
+      yield run(opts, "sync", () => runSync(opts, formatFor(this)));
+    });
+  });
+  instructions.command("init").description(
+    "Write a SessionStart hook for a coding tool and take the first copy"
+  ).requiredOption("--project <id>", "Project ID").requiredOption(
+    "--tool <tool>",
+    "Coding tool to configure: claude-code"
+  ).option("--dest <dir>", "Destination directory (default: cwd)").option("--org <slug>", "Organization context").option(
+    "--apply",
+    "Let the hook apply changes instead of only reporting them"
+  ).option("--format <format>", "Output format: text|json").action(function(opts) {
+    return __async(this, null, function* () {
+      yield run(
+        __spreadProps(__spreadValues({}, opts), { hook: false }),
+        "init",
+        () => runInit(opts, formatFor(this))
+      );
+    });
+  });
+  return instructions;
+}
+function formatFor(command) {
+  const resolved = command.optsWithGlobals();
+  return resolved.format === "json" ? "json" : "text";
+}
+function run(opts, verb, body) {
+  return __async(this, null, function* () {
+    try {
+      if (opts.hook) {
+        yield withDeadline(HOOK_DEADLINE_MS, body);
+      } else {
+        yield body();
+      }
+    } catch (error) {
+      const message = describeError(error);
+      if (opts.hook) {
+        process.stderr.write(
+          `fabric: coding instructions ${verb} skipped: ${message}
+`
+        );
+        process.exit(0);
+      }
+      process.stderr.write(`\u2717 ${message}
+`);
+      process.exit(error instanceof CliFailure ? error.exitCode : 1);
+    }
+  });
+}
+function withDeadline(totalMs, body) {
+  return __async(this, null, function* () {
+    const controller = new AbortController();
+    let timer;
+    const deadline = new Promise((_resolve, reject) => {
+      timer = setTimeout(() => {
+        controller.abort();
+        reject(
+          new Error(
+            `gave up after ${totalMs}ms so the session is not held up`
+          )
+        );
+      }, totalMs);
+    });
+    activeDeadline = controller.signal;
+    try {
+      yield Promise.race([body(), deadline]);
+    } finally {
+      activeDeadline = void 0;
+      if (timer) {
+        clearTimeout(timer);
+      }
+    }
+  });
+}
+var activeDeadline;
+function describeError(error) {
+  if (error instanceof Error) {
+    return error.message.replace(/\s*\n\s*/g, " ");
+  }
+  return String(error);
+}
+function asCliFailure(error) {
+  if (error instanceof CliFailure) {
+    return error;
+  }
+  const status = error.status;
+  const message = error instanceof Error ? error.message : String(error);
+  switch (status) {
+    case 401:
+      return new CliFailure(message, 3);
+    case 403:
+      return new CliFailure(message, 5);
+    case 404:
+      return new CliFailure(message, 4);
+    case 429:
+      return new CliFailure(message, 6);
+    case 400:
+    case 422:
+      return new CliFailure(message, 7);
+    default:
+      return new CliFailure(message, 1);
+  }
+}
+function destinationOf(opts) {
+  var _a2;
+  return path4.resolve((_a2 = opts.dest) != null ? _a2 : process.cwd());
+}
+function instructionsClient(opts, timeoutMs) {
+  if (!getApiKey()) {
+    throw new CliFailure(
+      "Not authenticated. Run: fabric auth login --key <api-key>",
+      3
+    );
+  }
+  return getClient(
+    opts.hook ? {
+      timeoutMs: Math.min(timeoutMs, HOOK_DEADLINE_MS),
+      retry: { maxRetries: 0 }
+    } : { timeoutMs }
+  ).withoutContext();
+}
+function orgSlugFor(opts) {
+  return opts.org;
+}
+function fetchPublished(client, opts, sinceDigest) {
+  return __async(this, null, function* () {
+    const org = orgSlugFor(opts);
+    let published;
+    try {
+      published = yield client.instructions.getPublished(opts.project, {
+        org,
+        sinceDigest
+      });
+    } catch (error) {
+      throw asCliFailure(error);
+    }
+    assertHookMayAct(opts, published);
+    return published;
+  });
+}
+function assertHookMayAct(opts, published) {
+  if (opts.hook && published.sourceOfTruth === "REPOSITORY") {
+    throw new CliFailure(
+      "this project's instructions now come from a git repository; run `fabric instructions init` again or remove the hook",
+      4
+    );
+  }
+}
+function readLockForProject(destination, projectId) {
+  return __async(this, null, function* () {
+    const lock = yield readLock(destination);
+    if (lock !== null && lock.projectId !== projectId) {
+      throw new CliFailure(
+        `${lockPath(destination)} belongs to project ${lock.projectId}, not ${projectId}. Use a different --dest, or remove that lock if this directory should now follow ${projectId}.`,
+        7
+      );
+    }
+    return lock;
+  });
+}
+function line(text) {
+  process.stdout.write(`${text}
+`);
+}
+function listPaths(label, paths) {
+  if (paths.length === 0) {
+    return;
+  }
+  line(`  ${label}:`);
+  for (const p of paths) {
+    line(`    ${p}`);
+  }
+}
+function runCheck(opts, format) {
+  return __async(this, null, function* () {
+    var _a2;
+    const destination = destinationOf(opts);
+    const root = yield resolveExistingRoot(destination);
+    const lock = yield readLockForProject(destination, opts.project);
+    const client = instructionsClient(opts, CHECK_TIMEOUT_MS);
+    const published = yield fetchPublished(client, opts, lock == null ? void 0 : lock.digest);
+    const drifted = opts.verify && lock !== null ? yield verifyLedger({ root, lock }) : [];
+    if (format === "json") {
+      printOutput(
+        __spreadValues({
+          projectId: opts.project,
+          destination,
+          synced: lock !== null,
+          localDigest: (_a2 = lock == null ? void 0 : lock.digest) != null ? _a2 : null,
+          verified: Boolean(opts.verify),
+          drifted
+        }, published),
+        { format: "json" }
+      );
+      return;
+    }
+    reportPublishedState(opts, destination, lock, published);
+    if (opts.verify) {
+      reportDrift(opts, destination, drifted);
+    }
+  });
+}
+function reportPublishedState(opts, destination, lock, published) {
+  var _a2, _b;
+  if (!published.published) {
+    line("This project has no published coding instructions yet.");
+    return;
+  }
+  const version = (_a2 = published.snapshot) == null ? void 0 : _a2.version;
+  if (!lock) {
+    line(
+      `Coding instructions have not been synced into ${destination} yet (published version ${version}, ${(_b = published.snapshot) == null ? void 0 : _b.fileCount} files).`
+    );
+    line(
+      `Run \`fabric instructions sync --project ${opts.project}\` to take a copy.`
+    );
+    return;
+  }
+  if (published.unchanged) {
+    line(`Published coding instructions unchanged (version ${version}).`);
+    return;
+  }
+  if (published.changes === null || published.changes === void 0) {
+    line(
+      `Coding instructions changed, and the version in ${destination} is not one the server still recognises, so what changed cannot be listed. A full sync is needed (published version ${version}).`
+    );
+    line(
+      `Run \`fabric instructions sync --project ${opts.project}\` to apply.`
+    );
+    return;
+  }
+  const { added, changed, removed } = published.changes;
+  line(
+    `Coding instructions updated: ${added.length} added, ${changed.length} changed, ${removed.length} removed (version ${version}).`
+  );
+  listPaths("added", added);
+  listPaths("changed", changed);
+  listPaths("removed", removed);
+  line(
+    `Run \`fabric instructions sync --project ${opts.project}\` to apply.`
+  );
+}
+function reportDrift(opts, destination, drifted) {
+  if (drifted.length === 0) {
+    line(`Every file in ${destination} matches the lock.`);
+    return;
+  }
+  line(`${drifted.length} local file(s) no longer match the lock:`);
+  listPaths("drifted", drifted);
+  line(
+    `Run \`fabric instructions sync --project ${opts.project}\` to put them back.`
+  );
+}
+function runSync(opts, format) {
+  return __async(this, null, function* () {
+    const result = yield syncOnce(opts);
+    if (format === "json") {
+      printOutput(result, { format: "json" });
+      return;
+    }
+    reportSync(result, opts);
+  });
+}
+function emptyOutcome(opts, destination) {
+  return {
+    projectId: opts.project,
+    destination,
+    published: true,
+    unchanged: false,
+    dryRun: Boolean(opts.dryRun),
+    version: null,
+    digest: null,
+    added: [],
+    updated: [],
+    replaced: [],
+    removed: [],
+    keptModified: [],
+    keptRenamed: [],
+    drifted: [],
+    verified: 0,
+    lockPath: lockPath(destination)
+  };
+}
+function syncOnce(opts) {
+  return __async(this, null, function* () {
+    const root = yield resolveDestinationRoot(destinationOf(opts));
+    const outcome = emptyOutcome(opts, root);
+    const lock = yield readLockForProject(root, opts.project);
+    const client = instructionsClient(opts, SYNC_TIMEOUT_MS);
+    let published = yield fetchPublished(client, opts, lock == null ? void 0 : lock.digest);
+    if (!published.published || !published.snapshot) {
+      throw new CliFailure(
+        "This project has no published coding instructions yet.",
+        4
+      );
+    }
+    outcome.version = published.snapshot.version;
+    outcome.digest = published.snapshot.digest;
+    if (published.unchanged) {
+      const drifted = lock === null ? [] : yield verifyLedger({ root, lock });
+      if (drifted.length === 0) {
+        outcome.unchanged = true;
+        return outcome;
+      }
+      outcome.drifted = drifted;
+      published = yield fetchPublished(client, opts);
+      if (!published.published || !published.snapshot) {
+        throw new CliFailure(
+          "This project has no published coding instructions yet.",
+          4
+        );
+      }
+      outcome.version = published.snapshot.version;
+      outcome.digest = published.snapshot.digest;
+    }
+    const manifest = assertValidManifest({
+      manifest: published.manifest,
+      snapshot: published.snapshot
+    });
+    const plan = yield computeSyncPlan({ destination: root, manifest, lock });
+    fillPlanPaths(outcome, plan);
+    if (opts.dryRun) {
+      return outcome;
+    }
+    let contents = /* @__PURE__ */ new Map();
+    if (plan.writes.length > 0) {
+      const org = orgSlugFor(opts);
+      let download;
+      try {
+        download = yield client.instructions.createDownloadUrl(
+          opts.project,
+          { org }
+        );
+      } catch (error) {
+        throw asCliFailure(error);
+      }
+      const sizes = new Map(
+        manifest.map((entry) => [entry.path, entry.size])
+      );
+      const archive = yield fetchBundle(download.url, {
+        timeoutMs: opts.hook ? HOOK_DEADLINE_MS : BUNDLE_TIMEOUT_MS,
+        // Bounded by what this manifest says it holds, not by what the
+        // response claims. The manifest has already been checked against
+        // the published snapshot limits, so this is a number the client
+        // decided.
+        maxBytes: maxArchiveBytes(manifest),
+        // In hook mode the same clock that bounds the command bounds the
+        // download, rather than a second independent budget after it.
+        signal: activeDeadline
+      });
+      contents = extractBundle(
+        archive,
+        plan.writes.map((entry) => {
+          var _a2;
+          return {
+            path: entry.path,
+            size: (_a2 = sizes.get(entry.path)) != null ? _a2 : -1
+          };
+        })
+      );
+    }
+    const applied = yield applyPlan({ root, plan, contents });
+    outcome.removed = applied.deleted;
+    outcome.keptModified = [
+      ...outcome.keptModified,
+      ...applied.keptModified
+    ].sort();
+    const lockToWrite = nextLock({
+      projectId: opts.project,
+      snapshot: {
+        id: published.snapshot.id,
+        version: published.snapshot.version,
+        digest: published.snapshot.digest
+      },
+      manifest
+    });
+    yield writeLock(root, lockToWrite);
+    return outcome;
+  });
+}
+function fillPlanPaths(outcome, plan) {
+  outcome.added = plan.entries.filter((entry) => entry.action === "added").map((entry) => entry.path);
+  outcome.updated = plan.entries.filter((entry) => entry.action === "updated").map((entry) => entry.path);
+  outcome.replaced = plan.entries.filter((entry) => entry.action === "replaced").map((entry) => entry.path);
+  outcome.removed = plan.deletes.map((entry) => entry.path);
+  outcome.keptModified = plan.keptModified.map((entry) => entry.path);
+  outcome.keptRenamed = plan.keptRenamed.map((entry) => entry.path);
+  outcome.verified = plan.verified.length;
+}
+function reportSync(outcome, opts) {
+  if (outcome.unchanged) {
+    line(
+      `Coding instructions are up to date (version ${outcome.version}).`
+    );
+    return;
+  }
+  const total = outcome.added.length + outcome.updated.length + outcome.replaced.length + outcome.removed.length;
+  if (outcome.drifted.length > 0) {
+    line(
+      `Coding instructions version ${outcome.version} is still the published one, but ${outcome.drifted.length} local file(s) no longer match it:`
+    );
+    listPaths("drifted", outcome.drifted);
+  }
+  const prefix = opts.dryRun ? "Would apply" : "Applied";
+  line(
+    `${prefix} coding instructions version ${outcome.version}: ${outcome.added.length} added, ${outcome.updated.length} updated, ${outcome.replaced.length} replaced, ${outcome.removed.length} removed (${outcome.verified} already current).`
+  );
+  listPaths("added", outcome.added);
+  listPaths("updated", outcome.updated);
+  listPaths("replaced local edits", outcome.replaced);
+  listPaths("removed", outcome.removed);
+  listPaths("kept, modified locally", outcome.keptModified);
+  listPaths("kept, renamed in the published snapshot", outcome.keptRenamed);
+  if (!opts.dryRun) {
+    line(`Lock: ${outcome.lockPath}`);
+  }
+  if (total === 0 && outcome.keptModified.length === 0 && outcome.keptRenamed.length === 0) {
+    line(`Everything in ${outcome.destination} already matched.`);
+  }
+}
+function runInit(opts, format) {
+  return __async(this, null, function* () {
+    if (opts.tool !== "claude-code") {
+      throw new CliFailure(
+        `Unsupported tool "${opts.tool}". Only --tool claude-code is supported today; other tools follow.`,
+        2
+      );
+    }
+    const root = yield resolveDestinationRoot(destinationOf(opts));
+    yield readLockForProject(root, opts.project);
+    try {
+      yield assertKeyStaysOutside(root, getConfigPath());
+    } catch (error) {
+      throw new CliFailure(describeError(error), 7);
+    }
+    const client = instructionsClient(opts, SYNC_TIMEOUT_MS);
+    const published = yield fetchPublished(client, opts);
+    if (published.sourceOfTruth === "REPOSITORY") {
+      throw new CliFailure(
+        "This project's coding instructions come from its repository, so they arrive with `git pull`. A session hook would fight it; nothing was written.",
+        7
+      );
+    }
+    const command = buildHookCommand(
+      opts.project,
+      Boolean(opts.apply),
+      opts.org
+    );
+    const merged = yield mergeSessionStartHook({
+      root,
+      projectId: opts.project,
+      command
+    });
+    const outcome = published.published ? (
+      // A second manifest call, deliberately: the one above answered "may
+      // a hook be installed for this project at all", and this one is the
+      // sync's own — it carries the lock's digest and is the call the
+      // hook will make from now on.
+      yield syncOnce(__spreadProps(__spreadValues({}, opts), { hook: false }))
+    ) : null;
+    if (format === "json") {
+      printOutput(
+        {
+          projectId: opts.project,
+          destination: root,
+          settingsPath: merged.settingsPath,
+          hookCommand: merged.command,
+          createdSettingsFile: merged.createdFile,
+          replacedHooks: merged.replacedCount,
+          sync: outcome
+        },
+        { format: "json" }
+      );
+      return;
+    }
+    line(
+      merged.replacedCount > 0 ? `Updated the SessionStart hook in ${merged.settingsPath}.` : `Added a SessionStart hook to ${merged.settingsPath}.`
+    );
+    line(`  ${command}`);
+    line(
+      opts.apply ? "  It applies changes at session start." : "  It only reports changes; add --apply to init to have it apply them."
+    );
+    if (outcome === null) {
+      line(
+        "This project has nothing published yet, so there is nothing to copy \u2014 the hook will pick it up once there is."
+      );
+    } else {
+      line("");
+      reportSync(outcome, opts);
+    }
+    line("");
+    line(
+      `${CLAUDE_SETTINGS_RELATIVE_PATH} and ${LOCK_DIRECTORY}/ are local to this machine. If this repository does not ignore them already, add them to your own ignore rules \u2014 this command does not edit .gitignore.`
+    );
+  });
+}
+
+// src/commands/mcp/index.ts
+import { Command as Command12 } from "commander";
+function buildMcpCommand() {
+  const mcp = new Command12("mcp").description(
+    "Manage MCP servers and configurations"
+  );
+  mcp.command("servers").description("List accessible MCP servers (system + custom)").option("--org <slug>", "Organization context").option("--personal", "Retired \u2014 context is organization-only").option(
+    "--format <format>",
+    "Output format: table|json|yaml|csv",
+    "table"
+  ).option("-q, --quiet", "Print server keys only").action(
+    (opts) => __async(null, null, function* () {
+      const ctx = resolveContext(opts.personal, opts.org, false);
+      const client = getClient();
+      let list;
+      try {
+        list = yield client.mcp.listServers({
+          org: (ctx == null ? void 0 : ctx.type) === "org" ? ctx.slug : void 0
+        });
+      } catch (err) {
+        printError(err.message, 1);
+      }
+      if (opts.quiet) {
+        for (const s of list) {
+          process.stdout.write(`${s.key}
+`);
+        }
+        return;
+      }
+      printOutput(list, {
+        format: opts.format,
+        columns: [
+          "key",
+          "name",
+          "transport",
+          "category",
+          "isSystemProvided"
+        ]
+      });
+    })
+  );
+  const configs = new Command12("configs").description(
+    "Manage MCP configurations"
+  );
+  configs.command("list", { isDefault: true }).description("List your MCP configurations").option("--org <slug>", "Organization context").option("--personal", "Retired \u2014 context is organization-only").option(
+    "--format <format>",
+    "Output format: table|json|yaml|csv",
+    "table"
+  ).option("-q, --quiet", "Print IDs only").action(
+    (opts) => __async(null, null, function* () {
+      const ctx = resolveContext(opts.personal, opts.org, false);
+      const client = getClient();
+      let list;
+      try {
+        list = yield client.mcp.listConfigs({
+          org: (ctx == null ? void 0 : ctx.type) === "org" ? ctx.slug : void 0
+        });
+      } catch (err) {
+        printError(err.message, 1);
+      }
+      if (opts.quiet) {
+        for (const c of list) {
+          process.stdout.write(`${c.id}
+`);
+        }
+        return;
+      }
+      printOutput(list, {
+        format: opts.format,
+        columns: [
+          "id",
+          "serverName",
+          "displayName",
+          "authType",
+          "enabled",
+          "status"
+        ]
+      });
+    })
+  );
+  configs.command("show <id>").description("Show a specific MCP configuration").option("--org <slug>", "Organization context").option("--personal", "Retired \u2014 context is organization-only").option("--format <format>", "Output format: table|json|yaml", "table").action(
+    (id, opts) => __async(null, null, function* () {
+      var _a2, _b, _c, _d, _e, _f, _g;
+      const ctx = resolveContext(opts.personal, opts.org, false);
+      const client = getClient();
+      let config2;
+      try {
+        config2 = yield client.mcp.getConfig(id, {
+          org: (ctx == null ? void 0 : ctx.type) === "org" ? ctx.slug : void 0
+        });
+      } catch (err) {
+        printError(err.message, 1);
+      }
+      const fmt = opts.format;
+      if (fmt === "json" || fmt === "yaml") {
+        printOutput(config2, { format: fmt });
+        return;
+      }
+      printRecord({
+        ID: config2.id,
+        Server: (_a2 = config2.serverName) != null ? _a2 : config2.mcpServerId,
+        "Server Key": (_b = config2.serverKey) != null ? _b : "(none)",
+        "Display Name": (_c = config2.displayName) != null ? _c : "(none)",
+        "Base URL": (_d = config2.baseUrl) != null ? _d : "(none)",
+        Transport: (_e = config2.transport) != null ? _e : "(default)",
+        "Auth Type": config2.authType,
+        Enabled: config2.enabled ? "yes" : "no",
+        Status: config2.status,
+        "Last Health Check": (_g = (_f = config2.lastHealthCheckAt) == null ? void 0 : _f.slice(0, 19)) != null ? _g : "(never)",
+        Created: config2.createdAt.slice(0, 10)
+      });
+    })
+  );
+  configs.command("delete <id>").description("Delete an MCP configuration").option("--org <slug>", "Organization context").option("--personal", "Retired \u2014 context is organization-only").option("-y, --yes", "Skip confirmation prompt").action(
+    (id, opts) => __async(null, null, function* () {
+      const ctx = resolveContext(opts.personal, opts.org, false);
+      const client = getClient();
+      if (!opts.yes) {
+        process.stderr.write(
+          `Delete MCP config ${id}? This cannot be undone. Pass --yes to confirm.
+`
+        );
+        process.exit(2);
+      }
+      try {
+        yield client.mcp.deleteConfig(id, {
+          org: (ctx == null ? void 0 : ctx.type) === "org" ? ctx.slug : void 0
+        });
+      } catch (err) {
+        printError(err.message, 1);
+      }
+      process.stdout.write(`MCP config ${id} deleted.
+`);
+    })
+  );
+  mcp.addCommand(configs);
+  mcp.command("serve").description(
+    "Run a stdio MCP server exposing this workspace's whole integration catalog. Point Claude Desktop, Cursor, or any MCP client at it."
+  ).action(() => __async(null, null, function* () {
+    const { runStdio } = yield import("@fabricorg/sdk-mcp/stdio");
+    yield runStdio();
+  }));
+  return mcp;
+}
+
+// src/commands/orgs/index.ts
+import { Command as Command13 } from "commander";
+function buildOrgsCommand() {
+  const orgs = new Command13("orgs").description("Manage organizations");
+  orgs.command("list").description("List organizations you belong to").option(
+    "--format <format>",
+    "Output format: table|json|yaml|csv",
+    "table"
+  ).option("-q, --quiet", "Print slugs only").action((opts) => __async(null, null, function* () {
+    const client = getClient();
+    let list;
+    try {
+      list = yield client.orgs.list();
+    } catch (err) {
+      printError(err.message, 1);
+    }
+    if (opts.quiet) {
+      for (const org of list) {
+        process.stdout.write(`${org.slug}
+`);
+      }
+      return;
+    }
+    printOutput(list, {
+      format: opts.format,
+      columns: ["name", "slug", "role", "joinedAt"]
+    });
+  }));
   orgs.command("show <slug>").description("Show details for an organization").option("--format <format>", "Output format: table|json|yaml", "table").action((slug, opts) => __async(null, null, function* () {
     var _a2;
     const client = getClient();
@@ -1474,9 +3236,9 @@ function buildOrgsCommand() {
 }
 
 // src/commands/projects/index.ts
-import { Command as Command13 } from "commander";
+import { Command as Command14 } from "commander";
 function buildProjectsCommand() {
-  const projects = new Command13("projects").description("Manage projects");
+  const projects = new Command14("projects").description("Manage projects");
   projects.command("list").description("List projects").option("--org <slug>", "Organization context").option("--personal", "Retired \u2014 context is organization-only").option(
     "--status <status>",
     "Filter by status: ACTIVE|DRAFT|COMPLETED|ARCHIVED"
@@ -1611,9 +3373,9 @@ function buildProjectsCommand() {
 }
 
 // src/commands/prompts/index.ts
-import { Command as Command14 } from "commander";
+import { Command as Command15 } from "commander";
 function buildPromptsCommand() {
-  const prompts = new Command14("prompts").description(
+  const prompts = new Command15("prompts").description(
     "Manage prompt templates"
   );
   prompts.command("list").description("List prompt templates").option("--org <slug>", "Organization context").option("--personal", "Retired \u2014 context is organization-only").option("--search <query>", "Search by name").option("--category <cat>", "Filter by category").option("--limit <n>", "Max results", "50").option(
@@ -1766,12 +3528,12 @@ ${content}
 }
 
 // src/commands/reports/index.ts
-import { Command as Command15 } from "commander";
+import { Command as Command16 } from "commander";
 function buildReportsCommand() {
-  const reports = new Command15("reports").description(
+  const reports = new Command16("reports").description(
     "Manage report templates and executions"
   );
-  const templates = new Command15("templates").description(
+  const templates = new Command16("templates").description(
     "Manage report templates"
   );
   templates.command("list", { isDefault: true }).description("List report templates").option("--org <slug>", "Organization context").option("--personal", "Retired \u2014 context is organization-only").option("--search <query>", "Search by name").option("--category <cat>", "Filter by category").option("--limit <n>", "Max results (default 20)", "20").option(
@@ -1845,7 +3607,7 @@ function buildReportsCommand() {
     })
   );
   reports.addCommand(templates);
-  const executions = new Command15("executions").description(
+  const executions = new Command16("executions").description(
     "View report executions"
   );
   executions.command("list", { isDefault: true }).description("List report executions").option("--org <slug>", "Organization context").option("--personal", "Retired \u2014 context is organization-only").option("--limit <n>", "Max results (default 20)", "20").option(
@@ -1889,9 +3651,9 @@ function buildReportsCommand() {
 }
 
 // src/commands/skills/index.ts
-import { Command as Command16 } from "commander";
+import { Command as Command17 } from "commander";
 function buildSkillsCommand() {
-  const skills = new Command16("skills").description(
+  const skills = new Command17("skills").description(
     "Browse skill definitions"
   );
   skills.command("list").description("List skills").option("--org <slug>", "Organization context").option("--personal", "Retired \u2014 context is organization-only").option("--search <query>", "Search by name").option("--category <cat>", "Filter by category").option("--limit <n>", "Max results", "50").option(
@@ -1958,9 +3720,9 @@ function buildSkillsCommand() {
 }
 
 // src/commands/workflows/index.ts
-import { Command as Command17 } from "commander";
+import { Command as Command18 } from "commander";
 function buildWorkflowsCommand() {
-  const workflows = new Command17("workflows").description("Manage workflows");
+  const workflows = new Command18("workflows").description("Manage workflows");
   workflows.command("list").description("List workflows").option("--org <slug>", "Organization context").option("--personal", "Retired \u2014 context is organization-only").option("--status <status>", "Filter: DRAFT|ACTIVE|PAUSED|ARCHIVED").option("--search <query>", "Search by name").option("--limit <n>", "Max results", "20").option(
     "--format <format>",
     "Output format: table|json|yaml|csv",
@@ -2088,9 +3850,9 @@ function buildWorkflowsCommand() {
 }
 
 // src/commands/workspaces/index.ts
-import { Command as Command18 } from "commander";
+import { Command as Command19 } from "commander";
 function buildWorkspacesCommand() {
-  const workspaces = new Command18("workspaces").description(
+  const workspaces = new Command19("workspaces").description(
     "Manage workspaces"
   );
   workspaces.command("list").description("List workspaces").option("--org <slug>", "Organization context").option("--personal", "Retired \u2014 context is organization-only").option("--search <query>", "Search by name").option("--status <status>", "Filter: ACTIVE|ARCHIVED").option("--limit <n>", "Max results (default 20)", "20").option(
@@ -2166,14 +3928,14 @@ function buildWorkspacesCommand() {
 }
 
 // src/bin/fabric.ts
-var program = new Command19();
+var program = new Command20();
 var _a;
 program.name("fabric").description("Fabric AI platform CLI").version("0.1.0").option(
   "--format <format>",
   "Output format: table|json|yaml|csv",
   (_a = process.env.FABRIC_FORMAT) != null ? _a : "table"
 );
-var auth = new Command19("auth").description(
+var auth = new Command20("auth").description(
   "Authenticate and manage API keys"
 );
 auth.addCommand(buildLoginCommand());
@@ -2189,13 +3951,14 @@ program.addCommand(buildWorkflowsCommand());
 program.addCommand(buildPromptsCommand());
 program.addCommand(buildAgentsCommand());
 program.addCommand(buildSkillsCommand());
+program.addCommand(buildInstructionsCommand());
 program.addCommand(buildMcpCommand());
 program.addCommand(buildFramesCommand());
 program.addCommand(buildWorkspacesCommand());
 program.addCommand(buildChatsCommand());
 program.addCommand(buildReportsCommand());
 program.addCommand(buildCompletionCommand());
-var config = new Command19("config").description("Show CLI configuration");
+var config = new Command20("config").description("Show CLI configuration");
 config.command("path").description("Print the path to the config file").action(() => {
   process.stdout.write(`${getConfigPath()}
 `);