@scheduler-systems/gal-run 0.0.337 → 0.0.338

package/dist/index.cjs

@@ -3970,7 +3970,7 @@ var cliVersion, defaultApiUrl, BUILD_CONSTANTS, constants_default;
 var init_constants = __esm({
   "src/constants.ts"() {
     "use strict";
-    cliVersion = true ? "0.0.337" : "0.0.0-dev";
+    cliVersion = true ? "0.0.338" : "0.0.0-dev";
     defaultApiUrl = true ? "https://api.gal.run" : "http://localhost:3000";
     BUILD_CONSTANTS = Object.freeze([cliVersion, defaultApiUrl]);
     constants_default = BUILD_CONSTANTS;
@@ -4880,7 +4880,7 @@ function detectEnvironment() {
     return "dev";
   }
   try {
-    const version = true ? "0.0.337" : void 0;
+    const version = true ? "0.0.338" : void 0;
     if (version && version.includes("-local")) {
       return "dev";
     }
@@ -5249,7 +5249,7 @@ function getId() {
 }
 function getCliVersion() {
   try {
-    return true ? "0.0.337" : "0.0.0-dev";
+    return true ? "0.0.338" : "0.0.0-dev";
   } catch {
     return "0.0.0-dev";
   }
@@ -7701,12 +7701,12 @@ function getFeatureFlags() {
   let isPartnerFromApi = false;
   if (!isInternalEnv) {
     try {
-      const { readFileSync: readFileSync38, existsSync: existsSync42 } = require("fs");
-      const { join: join46 } = require("path");
-      const { homedir: homedir25 } = require("os");
-      const configPath = join46(homedir25(), ".gal", "config.json");
-      if (existsSync42(configPath)) {
-        const config = JSON.parse(readFileSync38(configPath, "utf-8"));
+      const { readFileSync: readFileSync39, existsSync: existsSync43 } = require("fs");
+      const { join: join47 } = require("path");
+      const { homedir: homedir26 } = require("os");
+      const configPath = join47(homedir26(), ".gal", "config.json");
+      if (existsSync43(configPath)) {
+        const config = JSON.parse(readFileSync39(configPath, "utf-8"));
         const cacheAge = Date.now() - (config.flagsCachedAt || config.internalOrgsCheckedAt || 0);
         if (cacheAge < CACHE_MAX_AGE_MS) {
           const userOrgs = config.orgMemberships || [];
@@ -17165,7 +17165,7 @@ var require_thread_stream = __commonJS({
     var { version } = require_package2();
     var { EventEmitter: EventEmitter3 } = require("events");
     var { Worker } = require("worker_threads");
-    var { join: join46 } = require("path");
+    var { join: join47 } = require("path");
     var { pathToFileURL } = require("url");
     var { wait } = require_wait();
     var {
@@ -17201,7 +17201,7 @@ var require_thread_stream = __commonJS({
     function createWorker(stream, opts) {
       const { filename, workerData } = opts;
       const bundlerOverrides = "__bundlerPathsOverrides" in globalThis ? globalThis.__bundlerPathsOverrides : {};
-      const toExecute = bundlerOverrides["thread-stream-worker"] || join46(__dirname, "lib", "worker.js");
+      const toExecute = bundlerOverrides["thread-stream-worker"] || join47(__dirname, "lib", "worker.js");
       const worker = new Worker(toExecute, {
         ...opts.workerOpts,
         trackUnmanagedFds: false,
@@ -17587,7 +17587,7 @@ var require_transport = __commonJS({
     "use strict";
     var { createRequire: createRequire3 } = require("module");
     var getCallers = require_caller();
-    var { join: join46, isAbsolute, sep } = require("node:path");
+    var { join: join47, isAbsolute, sep } = require("node:path");
     var sleep2 = require_atomic_sleep();
     var onExit2 = require_on_exit_leak_free();
     var ThreadStream = require_thread_stream();
@@ -17650,7 +17650,7 @@ var require_transport = __commonJS({
         throw new Error("only one of target or targets can be specified");
       }
       if (targets) {
-        target = bundlerOverrides["pino-worker"] || join46(__dirname, "worker.js");
+        target = bundlerOverrides["pino-worker"] || join47(__dirname, "worker.js");
         options.targets = targets.filter((dest) => dest.target).map((dest) => {
           return {
             ...dest,
@@ -17668,7 +17668,7 @@ var require_transport = __commonJS({
           });
         });
       } else if (pipeline) {
-        target = bundlerOverrides["pino-worker"] || join46(__dirname, "worker.js");
+        target = bundlerOverrides["pino-worker"] || join47(__dirname, "worker.js");
         options.pipelines = [pipeline.map((dest) => {
           return {
             ...dest,
@@ -17690,7 +17690,7 @@ var require_transport = __commonJS({
           return origin;
         }
         if (origin === "pino/file") {
-          return join46(__dirname, "..", "file.js");
+          return join47(__dirname, "..", "file.js");
         }
         let fixTarget2;
         for (const filePath of callers) {
@@ -18679,7 +18679,7 @@ var require_safe_stable_stringify = __commonJS({
               return circularValue;
             }
             let res = "";
-            let join46 = ",";
+            let join47 = ",";
             const originalIndentation = indentation;
             if (Array.isArray(value)) {
               if (value.length === 0) {
@@ -18693,7 +18693,7 @@ var require_safe_stable_stringify = __commonJS({
                 indentation += spacer;
                 res += `
 ${indentation}`;
-                join46 = `,
+                join47 = `,
 ${indentation}`;
               }
               const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
@@ -18701,13 +18701,13 @@ ${indentation}`;
               for (; i < maximumValuesToStringify - 1; i++) {
                 const tmp2 = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
                 res += tmp2 !== void 0 ? tmp2 : "null";
-                res += join46;
+                res += join47;
               }
               const tmp = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
               res += tmp !== void 0 ? tmp : "null";
               if (value.length - 1 > maximumBreadth) {
                 const removedKeys = value.length - maximumBreadth - 1;
-                res += `${join46}"... ${getItemCount(removedKeys)} not stringified"`;
+                res += `${join47}"... ${getItemCount(removedKeys)} not stringified"`;
               }
               if (spacer !== "") {
                 res += `
@@ -18728,7 +18728,7 @@ ${originalIndentation}`;
             let separator = "";
             if (spacer !== "") {
               indentation += spacer;
-              join46 = `,
+              join47 = `,
 ${indentation}`;
               whitespace = " ";
             }
@@ -18742,13 +18742,13 @@ ${indentation}`;
               const tmp = stringifyFnReplacer(key2, value, stack, replacer, spacer, indentation);
               if (tmp !== void 0) {
                 res += `${separator}${strEscape(key2)}:${whitespace}${tmp}`;
-                separator = join46;
+                separator = join47;
               }
             }
             if (keyLength > maximumBreadth) {
               const removedKeys = keyLength - maximumBreadth;
               res += `${separator}"...":${whitespace}"${getItemCount(removedKeys)} not stringified"`;
-              separator = join46;
+              separator = join47;
             }
             if (spacer !== "" && separator.length > 1) {
               res = `
@@ -18789,7 +18789,7 @@ ${originalIndentation}`;
             }
             const originalIndentation = indentation;
             let res = "";
-            let join46 = ",";
+            let join47 = ",";
             if (Array.isArray(value)) {
               if (value.length === 0) {
                 return "[]";
@@ -18802,7 +18802,7 @@ ${originalIndentation}`;
                 indentation += spacer;
                 res += `
 ${indentation}`;
-                join46 = `,
+                join47 = `,
 ${indentation}`;
               }
               const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
@@ -18810,13 +18810,13 @@ ${indentation}`;
               for (; i < maximumValuesToStringify - 1; i++) {
                 const tmp2 = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
                 res += tmp2 !== void 0 ? tmp2 : "null";
-                res += join46;
+                res += join47;
               }
               const tmp = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
               res += tmp !== void 0 ? tmp : "null";
               if (value.length - 1 > maximumBreadth) {
                 const removedKeys = value.length - maximumBreadth - 1;
-                res += `${join46}"... ${getItemCount(removedKeys)} not stringified"`;
+                res += `${join47}"... ${getItemCount(removedKeys)} not stringified"`;
               }
               if (spacer !== "") {
                 res += `
@@ -18829,7 +18829,7 @@ ${originalIndentation}`;
             let whitespace = "";
             if (spacer !== "") {
               indentation += spacer;
-              join46 = `,
+              join47 = `,
 ${indentation}`;
               whitespace = " ";
             }
@@ -18838,7 +18838,7 @@ ${indentation}`;
               const tmp = stringifyArrayReplacer(key2, value[key2], stack, replacer, spacer, indentation);
               if (tmp !== void 0) {
                 res += `${separator}${strEscape(key2)}:${whitespace}${tmp}`;
-                separator = join46;
+                separator = join47;
               }
             }
             if (spacer !== "" && separator.length > 1) {
@@ -18896,20 +18896,20 @@ ${originalIndentation}`;
               indentation += spacer;
               let res2 = `
 ${indentation}`;
-              const join47 = `,
+              const join48 = `,
 ${indentation}`;
               const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
               let i = 0;
               for (; i < maximumValuesToStringify - 1; i++) {
                 const tmp2 = stringifyIndent(String(i), value[i], stack, spacer, indentation);
                 res2 += tmp2 !== void 0 ? tmp2 : "null";
-                res2 += join47;
+                res2 += join48;
               }
               const tmp = stringifyIndent(String(i), value[i], stack, spacer, indentation);
               res2 += tmp !== void 0 ? tmp : "null";
               if (value.length - 1 > maximumBreadth) {
                 const removedKeys = value.length - maximumBreadth - 1;
-                res2 += `${join47}"... ${getItemCount(removedKeys)} not stringified"`;
+                res2 += `${join48}"... ${getItemCount(removedKeys)} not stringified"`;
               }
               res2 += `
 ${originalIndentation}`;
@@ -18925,16 +18925,16 @@ ${originalIndentation}`;
               return '"[Object]"';
             }
             indentation += spacer;
-            const join46 = `,
+            const join47 = `,
 ${indentation}`;
             let res = "";
             let separator = "";
             let maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
             if (isTypedArrayWithEntries(value)) {
-              res += stringifyTypedArray(value, join46, maximumBreadth);
+              res += stringifyTypedArray(value, join47, maximumBreadth);
               keys = keys.slice(value.length);
               maximumPropertiesToStringify -= value.length;
-              separator = join46;
+              separator = join47;
             }
             if (deterministic) {
               keys = sort(keys, comparator);
@@ -18945,13 +18945,13 @@ ${indentation}`;
               const tmp = stringifyIndent(key2, value[key2], stack, spacer, indentation);
               if (tmp !== void 0) {
                 res += `${separator}${strEscape(key2)}: ${tmp}`;
-                separator = join46;
+                separator = join47;
               }
             }
             if (keyLength > maximumBreadth) {
               const removedKeys = keyLength - maximumBreadth;
               res += `${separator}"...": "${getItemCount(removedKeys)} not stringified"`;
-              separator = join46;
+              separator = join47;
             }
             if (separator !== "") {
               res = `
@@ -21327,11 +21327,11 @@ function createApprovedConfigCommand() {
     const spinner = options.json ? null : ora(`Fetching approved config for "${org}"...`).start();
     try {
       let findMdFiles2 = function(dir) {
-        if (!existsSync42(dir)) return [];
+        if (!existsSync43(dir)) return [];
         const entries = readdirSync17(dir, { withFileTypes: true });
         const files = [];
         for (const entry of entries) {
-          const fullPath = join46(dir, entry.name);
+          const fullPath = join47(dir, entry.name);
           if (entry.isDirectory()) files.push(...findMdFiles2(fullPath));
           else if (entry.name.endsWith(".md")) files.push(fullPath);
         }
@@ -21349,11 +21349,11 @@ function createApprovedConfigCommand() {
         }
         return;
       }
-      const { existsSync: existsSync42, readdirSync: readdirSync17, readFileSync: readFileSync38 } = await import("fs");
-      const { join: join46, relative: relative10, basename: basename9 } = await import("path");
+      const { existsSync: existsSync43, readdirSync: readdirSync17, readFileSync: readFileSync39 } = await import("fs");
+      const { join: join47, relative: relative10, basename: basename9 } = await import("path");
       const baseDir = options.dir || process.cwd();
-      const commandsDir = join46(baseDir, ".claude", "commands");
-      const agentsDir = join46(baseDir, ".claude", "agents");
+      const commandsDir = join47(baseDir, ".claude", "commands");
+      const agentsDir = join47(baseDir, ".claude", "agents");
       const localCommandNames = findMdFiles2(commandsDir).map(
         (f) => relative10(commandsDir, f).replace(/\.md$/, "").replace(/\//g, ":")
       );
@@ -32617,6 +32617,122 @@ var init_agents_md_generator = __esm({
   }
 });
 
+// src/utils/mcp-config-writer.ts
+function resolveEnvVars(value) {
+  let resolved = value.replace(/^~(?=\/|$)/, (0, import_os15.homedir)());
+  resolved = resolved.replace(/\$HOME\b/g, (0, import_os15.homedir)());
+  resolved = resolved.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_match, varName) => {
+    if (varName === "HOME") return (0, import_os15.homedir)();
+    const envVal = process.env[varName];
+    return envVal !== void 0 ? envVal : _match;
+  });
+  resolved = resolved.replace(/\$([A-Za-z_][A-Za-z0-9_]*)\b/g, (_match, varName) => {
+    if (varName === "HOME") return (0, import_os15.homedir)();
+    const envVal = process.env[varName];
+    return envVal !== void 0 ? envVal : _match;
+  });
+  return resolved;
+}
+function resolveEnvVarsDeep(value) {
+  if (typeof value === "string") {
+    return resolveEnvVars(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map(resolveEnvVarsDeep);
+  }
+  if (value && typeof value === "object") {
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+      result[k] = resolveEnvVarsDeep(v);
+    }
+    return result;
+  }
+  return value;
+}
+function readMcpJsonFile(mcpPath) {
+  if (!(0, import_fs18.existsSync)(mcpPath)) {
+    return { mcpServers: {} };
+  }
+  try {
+    const raw = (0, import_fs18.readFileSync)(mcpPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return { mcpServers: {} };
+    }
+    return parsed;
+  } catch {
+    return { mcpServers: {} };
+  }
+}
+function mergeMcpConfigs(existing, orgServers, orgName) {
+  const merged = { ...existing };
+  const existingServers = existing.mcpServers && typeof existing.mcpServers === "object" ? { ...existing.mcpServers } : {};
+  const orgServerNames = new Set(Object.keys(orgServers));
+  const preservedUserServers = [];
+  for (const name of Object.keys(existingServers)) {
+    if (!orgServerNames.has(name) && name !== "gal") {
+      preservedUserServers.push(name);
+    }
+  }
+  const mergedServers = { ...existingServers };
+  let orgServersApplied = 0;
+  for (const [name, config] of Object.entries(orgServers)) {
+    mergedServers[name] = config;
+    orgServersApplied++;
+  }
+  mergedServers["gal"] = {
+    type: "http",
+    transport: "http",
+    url: "https://api.gal.run/mcp",
+    ...orgName ? { headers: { "X-Gal-Organization": orgName } } : {}
+  };
+  for (const [name, config] of Object.entries(mergedServers)) {
+    mergedServers[name] = resolveEnvVarsDeep(config);
+  }
+  merged.mcpServers = mergedServers;
+  return { merged, orgServersApplied, preservedUserServers };
+}
+function parseOrgMcpServers(mcpContent) {
+  if (!mcpContent) return {};
+  try {
+    const parsed = JSON.parse(mcpContent);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      const obj = parsed;
+      if (obj.mcpServers && typeof obj.mcpServers === "object" && !Array.isArray(obj.mcpServers)) {
+        return obj.mcpServers;
+      }
+    }
+  } catch {
+  }
+  return {};
+}
+function syncMcpConfig(directory, mcpContent, orgName) {
+  const mcpPath = (0, import_path17.join)(directory, ".mcp.json");
+  const existing = readMcpJsonFile(mcpPath);
+  const orgServers = parseOrgMcpServers(mcpContent);
+  const { merged, orgServersApplied, preservedUserServers } = mergeMcpConfigs(
+    existing,
+    orgServers,
+    orgName
+  );
+  (0, import_fs18.writeFileSync)(mcpPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+  return {
+    filePath: mcpPath,
+    orgServersApplied,
+    preservedUserServers,
+    galServerIncluded: true
+  };
+}
+var import_fs18, import_path17, import_os15;
+var init_mcp_config_writer = __esm({
+  "src/utils/mcp-config-writer.ts"() {
+    "use strict";
+    import_fs18 = require("fs");
+    import_path17 = require("path");
+    import_os15 = require("os");
+  }
+});
+
 // src/utils/drift-check.ts
 var drift_check_exports = {};
 __export(drift_check_exports, {
@@ -32630,12 +32746,12 @@ function hashContent(content) {
   return (0, import_crypto5.createHash)("sha256").update(content).digest("hex").substring(0, 16);
 }
 function getUserSettingsPath() {
-  return (0, import_path17.join)((0, import_os15.homedir)(), ".claude", "settings.json");
+  return (0, import_path18.join)((0, import_os16.homedir)(), ".claude", "settings.json");
 }
 function readLocalSettings(settingsPath) {
-  if (!(0, import_fs18.existsSync)(settingsPath)) return null;
+  if (!(0, import_fs19.existsSync)(settingsPath)) return null;
   try {
-    return (0, import_fs18.readFileSync)(settingsPath, "utf-8");
+    return (0, import_fs19.readFileSync)(settingsPath, "utf-8");
   } catch {
     return null;
   }
@@ -32695,10 +32811,10 @@ function printDriftWarning(result) {
   console.log();
 }
 async function runSessionDriftCheck(projectRoot) {
-  const syncStatePath = (0, import_path17.join)(projectRoot, ".gal", "sync-state.json");
-  if (!(0, import_fs18.existsSync)(syncStatePath)) return null;
+  const syncStatePath = (0, import_path18.join)(projectRoot, ".gal", "sync-state.json");
+  if (!(0, import_fs19.existsSync)(syncStatePath)) return null;
   try {
-    const stateContent = (0, import_fs18.readFileSync)(syncStatePath, "utf-8");
+    const stateContent = (0, import_fs19.readFileSync)(syncStatePath, "utf-8");
     const state = JSON.parse(stateContent);
     const claudeState = state.platforms?.claude;
     const orgHash = claudeState?.lastSyncHash || state.lastSyncHash || null;
@@ -32728,13 +32844,13 @@ async function runSessionDriftCheck(projectRoot) {
     return null;
   }
 }
-var import_fs18, import_path17, import_os15, import_crypto5;
+var import_fs19, import_path18, import_os16, import_crypto5;
 var init_drift_check = __esm({
   "src/utils/drift-check.ts"() {
     "use strict";
-    import_fs18 = require("fs");
-    import_path17 = require("path");
-    import_os15 = require("os");
+    import_fs19 = require("fs");
+    import_path18 = require("path");
+    import_os16 = require("os");
     import_crypto5 = require("crypto");
     init_source();
     init_config_manager();
@@ -32746,30 +32862,30 @@ function countEnabledDispatchCategories(categories) {
   return getValidDispatchCategories(categories).filter((category) => category.enabled).length;
 }
 function installCursorGalCliRules(directory) {
-  const cursorRulesDir = (0, import_path18.join)(directory, ".cursor", "rules", "gal-cli");
-  const rulesPath = (0, import_path18.join)(cursorRulesDir, "RULE.md");
+  const cursorRulesDir = (0, import_path19.join)(directory, ".cursor", "rules", "gal-cli");
+  const rulesPath = (0, import_path19.join)(cursorRulesDir, "RULE.md");
   try {
-    if ((0, import_fs19.existsSync)(rulesPath)) {
-      const existingContent = (0, import_fs19.readFileSync)(rulesPath, "utf-8");
+    if ((0, import_fs20.existsSync)(rulesPath)) {
+      const existingContent = (0, import_fs20.readFileSync)(rulesPath, "utf-8");
       const versionMatch = existingContent.match(/GAL_CURSOR_RULES_VERSION = "([^"]+)"/);
       if (versionMatch && versionMatch[1] === GAL_CLI_CURSOR_RULES_VERSION) {
         return true;
       }
     }
-    if (!(0, import_fs19.existsSync)(cursorRulesDir)) {
-      (0, import_fs19.mkdirSync)(cursorRulesDir, { recursive: true });
+    if (!(0, import_fs20.existsSync)(cursorRulesDir)) {
+      (0, import_fs20.mkdirSync)(cursorRulesDir, { recursive: true });
     }
-    (0, import_fs19.writeFileSync)(rulesPath, GAL_CLI_CURSOR_RULES, "utf-8");
+    (0, import_fs20.writeFileSync)(rulesPath, GAL_CLI_CURSOR_RULES, "utf-8");
     return true;
   } catch {
     return false;
   }
 }
 function writeSyncStateV2(orgName, platformStates, hookSettings) {
-  const galDir = (0, import_path18.join)(process.cwd(), ".gal");
-  const statePath = (0, import_path18.join)(galDir, "sync-state.json");
-  if (!(0, import_fs19.existsSync)(galDir)) {
-    (0, import_fs19.mkdirSync)(galDir, { recursive: true });
+  const galDir = (0, import_path19.join)(process.cwd(), ".gal");
+  const statePath = (0, import_path19.join)(galDir, "sync-state.json");
+  if (!(0, import_fs20.existsSync)(galDir)) {
+    (0, import_fs20.mkdirSync)(galDir, { recursive: true });
   }
   const platforms = {};
   for (const [platform5, state2] of platformStates) {
@@ -32790,7 +32906,7 @@ function writeSyncStateV2(orgName, platformStates, hookSettings) {
     // After a successful sync, approved hash matches local hash
     approvedConfigHash: primaryState?.lastSyncHash
   };
-  (0, import_fs19.writeFileSync)(statePath, JSON.stringify(state, null, 2), "utf-8");
+  (0, import_fs20.writeFileSync)(statePath, JSON.stringify(state, null, 2), "utf-8");
 }
 function writeSyncState(orgName, localHash, approvedHash, version, syncedFiles = [], policyName, hookSettings) {
   const platformStates = /* @__PURE__ */ new Map();
@@ -32846,16 +32962,16 @@ function findChangedKeys(existing, incoming, prefix = "") {
 }
 function readSyncState() {
   const projectRoot = findProjectRoot();
-  const statePath = (0, import_path18.join)(projectRoot, ".gal", "sync-state.json");
-  if (!(0, import_fs19.existsSync)(statePath)) {
+  const statePath = (0, import_path19.join)(projectRoot, ".gal", "sync-state.json");
+  if (!(0, import_fs20.existsSync)(statePath)) {
     return null;
   }
   try {
-    const content = (0, import_fs19.readFileSync)(statePath, "utf-8");
+    const content = (0, import_fs20.readFileSync)(statePath, "utf-8");
     const rawState = JSON.parse(content);
     if (!rawState.schemaVersion) {
       const migratedState = migrateSyncStateV1ToV2(rawState);
-      (0, import_fs19.writeFileSync)(statePath, JSON.stringify(migratedState, null, 2), "utf-8");
+      (0, import_fs20.writeFileSync)(statePath, JSON.stringify(migratedState, null, 2), "utf-8");
       return migratedState;
     }
     return rawState;
@@ -33172,30 +33288,30 @@ function createSyncCommand() {
           }
           const allowlist = await res.json();
           spinner2.succeed(source_default.green("Domain allowlist fetched"));
-          const galDir = (0, import_path18.join)(directory, ".gal");
-          if (!(0, import_fs19.existsSync)(galDir)) {
-            (0, import_fs19.mkdirSync)(galDir, { recursive: true });
+          const galDir = (0, import_path19.join)(directory, ".gal");
+          if (!(0, import_fs20.existsSync)(galDir)) {
+            (0, import_fs20.mkdirSync)(galDir, { recursive: true });
           }
-          const allowlistPath = (0, import_path18.join)(galDir, "domain-allowlist.json");
-          (0, import_fs19.writeFileSync)(allowlistPath, JSON.stringify(allowlist, null, 2) + "\n", "utf-8");
+          const allowlistPath = (0, import_path19.join)(galDir, "domain-allowlist.json");
+          (0, import_fs20.writeFileSync)(allowlistPath, JSON.stringify(allowlist, null, 2) + "\n", "utf-8");
           console.log(source_default.green(`
   Synced domain allowlist to .gal/domain-allowlist.json`));
           console.log(source_default.dim(`  Domains: ${allowlist.allowedDomains?.length || 0}`));
           console.log(source_default.dim(`  MCP endpoints: ${allowlist.allowedMcpEndpoints?.length || 0}`));
           console.log(source_default.dim(`  Enforced: ${allowlist.enforced ? "yes" : "no (audit-only)"}`));
-          const policiesDir = (0, import_path18.join)(directory, ".github", "policies");
-          if ((0, import_fs19.existsSync)((0, import_path18.join)(directory, ".github"))) {
-            if (!(0, import_fs19.existsSync)(policiesDir)) {
-              (0, import_fs19.mkdirSync)(policiesDir, { recursive: true });
+          const policiesDir = (0, import_path19.join)(directory, ".github", "policies");
+          if ((0, import_fs20.existsSync)((0, import_path19.join)(directory, ".github"))) {
+            if (!(0, import_fs20.existsSync)(policiesDir)) {
+              (0, import_fs20.mkdirSync)(policiesDir, { recursive: true });
             }
-            const policyPath = (0, import_path18.join)(policiesDir, "domain-allowlist.json");
+            const policyPath = (0, import_path19.join)(policiesDir, "domain-allowlist.json");
             const policyContent = {
               version: allowlist.version || 1,
               approvedDomains: allowlist.allowedDomains || [],
               approvedMcpEndpoints: allowlist.allowedMcpEndpoints || [],
               description: "Domains approved for AI agent WebFetch/WebSearch access. Managed by GAL org-level policy."
             };
-            (0, import_fs19.writeFileSync)(policyPath, JSON.stringify(policyContent, null, 2) + "\n", "utf-8");
+            (0, import_fs20.writeFileSync)(policyPath, JSON.stringify(policyContent, null, 2) + "\n", "utf-8");
             console.log(source_default.dim(`  Also updated .github/policies/domain-allowlist.json`));
           }
           console.log();
@@ -33521,11 +33637,11 @@ function createSyncCommand() {
         process.exit(0);
       }
       const directory = findProjectRoot(settingsOpts.directory || process.cwd());
-      const settingsPath = (0, import_path18.join)(directory, ".claude", "settings.json");
+      const settingsPath = (0, import_path19.join)(directory, ".claude", "settings.json");
       let existingSettings = {};
-      if ((0, import_fs19.existsSync)(settingsPath)) {
+      if ((0, import_fs20.existsSync)(settingsPath)) {
         try {
-          existingSettings = JSON.parse((0, import_fs19.readFileSync)(settingsPath, "utf-8"));
+          existingSettings = JSON.parse((0, import_fs20.readFileSync)(settingsPath, "utf-8"));
         } catch {
           console.error(source_default.red("Error: Could not parse existing .claude/settings.json"));
           process.exit(1);
@@ -33561,11 +33677,11 @@ function createSyncCommand() {
           deny: mergedDeny
         }
       };
-      const claudeDir = (0, import_path18.join)(directory, ".claude");
-      if (!(0, import_fs19.existsSync)(claudeDir)) {
-        (0, import_fs19.mkdirSync)(claudeDir, { recursive: true });
+      const claudeDir = (0, import_path19.join)(directory, ".claude");
+      if (!(0, import_fs20.existsSync)(claudeDir)) {
+        (0, import_fs20.mkdirSync)(claudeDir, { recursive: true });
       }
-      (0, import_fs19.writeFileSync)(settingsPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+      (0, import_fs20.writeFileSync)(settingsPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
       console.log(source_default.green(`
 \u2714 Added ${added.length} deny rule(s) to ${settingsPath}`));
       for (const rule of added) {
@@ -33584,67 +33700,67 @@ function scanLocalConfigs(directory, platformFilter) {
   for (const platform5 of platforms) {
     if (platformFilter && platform5 !== platformFilter) continue;
     const platformDir = getPlatformDirectory(platform5);
-    const fullPath = (0, import_path18.join)(directory, platformDir);
-    if (!(0, import_fs19.existsSync)(fullPath)) continue;
+    const fullPath = (0, import_path19.join)(directory, platformDir);
+    if (!(0, import_fs20.existsSync)(fullPath)) continue;
     const files = [];
-    const settingsPath = (0, import_path18.join)(fullPath, "settings.json");
-    if ((0, import_fs19.existsSync)(settingsPath)) {
+    const settingsPath = (0, import_path19.join)(fullPath, "settings.json");
+    if ((0, import_fs20.existsSync)(settingsPath)) {
       files.push({
         path: settingsPath,
         type: "settings",
-        content: (0, import_fs19.readFileSync)(settingsPath, "utf-8")
+        content: (0, import_fs20.readFileSync)(settingsPath, "utf-8")
       });
     }
-    const rulesDir = (0, import_path18.join)(fullPath, "rules");
-    if ((0, import_fs19.existsSync)(rulesDir)) {
-      const ruleFiles = (0, import_fs19.readdirSync)(rulesDir).filter(
+    const rulesDir = (0, import_path19.join)(fullPath, "rules");
+    if ((0, import_fs20.existsSync)(rulesDir)) {
+      const ruleFiles = (0, import_fs20.readdirSync)(rulesDir).filter(
         (f) => f.endsWith(".md") || f.endsWith(".mdc")
       );
       for (const file of ruleFiles) {
-        const filePath = (0, import_path18.join)(rulesDir, file);
+        const filePath = (0, import_path19.join)(rulesDir, file);
         files.push({
           path: filePath,
           type: "rule",
-          content: (0, import_fs19.readFileSync)(filePath, "utf-8")
+          content: (0, import_fs20.readFileSync)(filePath, "utf-8")
         });
       }
     }
     if (platform5 === "cursor") {
-      const cursorRulesPath = (0, import_path18.join)(directory, ".cursorrules");
-      if ((0, import_fs19.existsSync)(cursorRulesPath)) {
+      const cursorRulesPath = (0, import_path19.join)(directory, ".cursorrules");
+      if ((0, import_fs20.existsSync)(cursorRulesPath)) {
         files.push({
           path: cursorRulesPath,
           type: "rule",
-          content: (0, import_fs19.readFileSync)(cursorRulesPath, "utf-8")
+          content: (0, import_fs20.readFileSync)(cursorRulesPath, "utf-8")
         });
       }
     }
     if (platform5 === "claude") {
-      const commandsDir = (0, import_path18.join)(fullPath, "commands");
-      if ((0, import_fs19.existsSync)(commandsDir)) {
-        const commandFiles = (0, import_fs19.readdirSync)(commandsDir).filter(
+      const commandsDir = (0, import_path19.join)(fullPath, "commands");
+      if ((0, import_fs20.existsSync)(commandsDir)) {
+        const commandFiles = (0, import_fs20.readdirSync)(commandsDir).filter(
           (f) => f.endsWith(".md")
         );
         for (const file of commandFiles) {
-          const filePath = (0, import_path18.join)(commandsDir, file);
+          const filePath = (0, import_path19.join)(commandsDir, file);
           files.push({
             path: filePath,
             type: "command",
-            content: (0, import_fs19.readFileSync)(filePath, "utf-8")
+            content: (0, import_fs20.readFileSync)(filePath, "utf-8")
           });
         }
       }
-      const hooksDir = (0, import_path18.join)(fullPath, "hooks");
-      if ((0, import_fs19.existsSync)(hooksDir)) {
-        const hookFiles = (0, import_fs19.readdirSync)(hooksDir).filter(
+      const hooksDir = (0, import_path19.join)(fullPath, "hooks");
+      if ((0, import_fs20.existsSync)(hooksDir)) {
+        const hookFiles = (0, import_fs20.readdirSync)(hooksDir).filter(
           (f) => f.endsWith(".py") || f.endsWith(".sh")
         );
         for (const file of hookFiles) {
-          const filePath = (0, import_path18.join)(hooksDir, file);
+          const filePath = (0, import_path19.join)(hooksDir, file);
           files.push({
             path: filePath,
             type: "hook",
-            content: (0, import_fs19.readFileSync)(filePath, "utf-8")
+            content: (0, import_fs20.readFileSync)(filePath, "utf-8")
           });
         }
       }
@@ -33757,16 +33873,16 @@ Sync Status for ${orgName}:
   }
 }
 function writeCursorConfig(directory, configData, syncedFiles, syncedItems) {
-  const cursorDir = (0, import_path18.join)(directory, ".cursor");
+  const cursorDir = (0, import_path19.join)(directory, ".cursor");
   if (configData.rules && configData.rules.length > 0) {
-    const rulesDir = (0, import_path18.join)(cursorDir, "rules");
-    if (!(0, import_fs19.existsSync)(rulesDir)) {
-      (0, import_fs19.mkdirSync)(rulesDir, { recursive: true });
+    const rulesDir = (0, import_path19.join)(cursorDir, "rules");
+    if (!(0, import_fs20.existsSync)(rulesDir)) {
+      (0, import_fs20.mkdirSync)(rulesDir, { recursive: true });
     }
     for (const rule of configData.rules) {
       const fileName = rule.name.endsWith(".mdc") || rule.name.endsWith(".md") ? rule.name : `${rule.name}.mdc`;
-      const filePath = (0, import_path18.join)(rulesDir, fileName);
-      (0, import_fs19.writeFileSync)(filePath, rule.content, "utf-8");
+      const filePath = (0, import_path19.join)(rulesDir, fileName);
+      (0, import_fs20.writeFileSync)(filePath, rule.content, "utf-8");
       const relativePath = `.cursor/rules/${fileName}`;
       syncedFiles.push(relativePath);
       syncedItems.push({
@@ -33778,8 +33894,8 @@ function writeCursorConfig(directory, configData, syncedFiles, syncedItems) {
     }
   }
   if (configData.cursorRules?.content) {
-    const cursorRulesPath = (0, import_path18.join)(directory, ".cursorrules");
-    (0, import_fs19.writeFileSync)(cursorRulesPath, configData.cursorRules.content, "utf-8");
+    const cursorRulesPath = (0, import_path19.join)(directory, ".cursorrules");
+    (0, import_fs20.writeFileSync)(cursorRulesPath, configData.cursorRules.content, "utf-8");
     syncedFiles.push(".cursorrules");
     syncedItems.push({
       path: ".cursorrules",
@@ -33789,11 +33905,11 @@ function writeCursorConfig(directory, configData, syncedFiles, syncedItems) {
     });
   }
   if (configData.settings?.content) {
-    if (!(0, import_fs19.existsSync)(cursorDir)) {
-      (0, import_fs19.mkdirSync)(cursorDir, { recursive: true });
+    if (!(0, import_fs20.existsSync)(cursorDir)) {
+      (0, import_fs20.mkdirSync)(cursorDir, { recursive: true });
     }
-    const settingsPath = (0, import_path18.join)(cursorDir, "settings.json");
-    (0, import_fs19.writeFileSync)(settingsPath, configData.settings.content, "utf-8");
+    const settingsPath = (0, import_path19.join)(cursorDir, "settings.json");
+    (0, import_fs20.writeFileSync)(settingsPath, configData.settings.content, "utf-8");
     syncedFiles.push(".cursor/settings.json");
     syncedItems.push({
       path: ".cursor/settings.json",
@@ -33804,10 +33920,10 @@ function writeCursorConfig(directory, configData, syncedFiles, syncedItems) {
   }
 }
 function writeClaudeConfig(directory, configData, syncedFiles, syncedItems, orgName) {
-  const claudeDir = (0, import_path18.join)(directory, ".claude");
+  const claudeDir = (0, import_path19.join)(directory, ".claude");
   if (configData.instructions?.content) {
-    const claudeMdPath = (0, import_path18.join)(directory, "CLAUDE.md");
-    (0, import_fs19.writeFileSync)(claudeMdPath, configData.instructions.content, "utf-8");
+    const claudeMdPath = (0, import_path19.join)(directory, "CLAUDE.md");
+    (0, import_fs20.writeFileSync)(claudeMdPath, configData.instructions.content, "utf-8");
     syncedFiles.push("CLAUDE.md");
     syncedItems.push({
       path: "CLAUDE.md",
@@ -33817,19 +33933,19 @@ function writeClaudeConfig(directory, configData, syncedFiles, syncedItems, orgN
     });
   }
   if (configData.commands && configData.commands.length > 0) {
-    const commandsDir = (0, import_path18.join)(claudeDir, "commands");
-    if (!(0, import_fs19.existsSync)(commandsDir)) {
-      (0, import_fs19.mkdirSync)(commandsDir, { recursive: true });
+    const commandsDir = (0, import_path19.join)(claudeDir, "commands");
+    if (!(0, import_fs20.existsSync)(commandsDir)) {
+      (0, import_fs20.mkdirSync)(commandsDir, { recursive: true });
     }
     for (const cmd of configData.commands) {
       const pathFromName = cmd.name.replace(/:/g, "/");
       const fileName = pathFromName.endsWith(".md") ? pathFromName : `${pathFromName}.md`;
-      const filePath = (0, import_path18.join)(commandsDir, fileName);
-      const fileDir = (0, import_path18.dirname)(filePath);
-      if (!(0, import_fs19.existsSync)(fileDir)) {
-        (0, import_fs19.mkdirSync)(fileDir, { recursive: true });
+      const filePath = (0, import_path19.join)(commandsDir, fileName);
+      const fileDir = (0, import_path19.dirname)(filePath);
+      if (!(0, import_fs20.existsSync)(fileDir)) {
+        (0, import_fs20.mkdirSync)(fileDir, { recursive: true });
       }
-      (0, import_fs19.writeFileSync)(filePath, cmd.content, "utf-8");
+      (0, import_fs20.writeFileSync)(filePath, cmd.content, "utf-8");
       const relativePath = `.claude/commands/${fileName}`;
       syncedFiles.push(relativePath);
       const { description, allowedTools } = parseCommandFrontmatter(cmd.content);
@@ -33844,13 +33960,13 @@ function writeClaudeConfig(directory, configData, syncedFiles, syncedItems, orgN
     }
   }
   if (configData.hooks && configData.hooks.length > 0) {
-    const hooksDir = (0, import_path18.join)(claudeDir, "hooks");
-    if (!(0, import_fs19.existsSync)(hooksDir)) {
-      (0, import_fs19.mkdirSync)(hooksDir, { recursive: true });
+    const hooksDir = (0, import_path19.join)(claudeDir, "hooks");
+    if (!(0, import_fs20.existsSync)(hooksDir)) {
+      (0, import_fs20.mkdirSync)(hooksDir, { recursive: true });
     }
     for (const hook of configData.hooks) {
-      const filePath = (0, import_path18.join)(hooksDir, hook.name);
-      (0, import_fs19.writeFileSync)(filePath, hook.content, "utf-8");
+      const filePath = (0, import_path19.join)(hooksDir, hook.name);
+      (0, import_fs20.writeFileSync)(filePath, hook.content, "utf-8");
       const relativePath = `.claude/hooks/${hook.name}`;
       syncedFiles.push(relativePath);
       syncedItems.push({
@@ -33862,18 +33978,18 @@ function writeClaudeConfig(directory, configData, syncedFiles, syncedItems, orgN
     }
   }
   if (configData.settings?.content) {
-    if (!(0, import_fs19.existsSync)(claudeDir)) {
-      (0, import_fs19.mkdirSync)(claudeDir, { recursive: true });
+    if (!(0, import_fs20.existsSync)(claudeDir)) {
+      (0, import_fs20.mkdirSync)(claudeDir, { recursive: true });
     }
-    const settingsPath = (0, import_path18.join)(claudeDir, "settings.json");
-    if ((0, import_fs19.existsSync)(settingsPath)) {
-      const existingContent = (0, import_fs19.readFileSync)(settingsPath, "utf-8");
+    const settingsPath = (0, import_path19.join)(claudeDir, "settings.json");
+    if ((0, import_fs20.existsSync)(settingsPath)) {
+      const existingContent = (0, import_fs20.readFileSync)(settingsPath, "utf-8");
       const newContent = configData.settings.content;
       const existingHash = calculateConfigHash(existingContent);
       const newHash = calculateConfigHash(newContent);
       if (existingHash !== newHash) {
         const backupPath = `${settingsPath}.bak`;
-        (0, import_fs19.writeFileSync)(backupPath, existingContent, "utf-8");
+        (0, import_fs20.writeFileSync)(backupPath, existingContent, "utf-8");
         console.log(source_default.yellow("\n  Settings changes detected:"));
         try {
           const existingParsed = JSON.parse(existingContent);
@@ -33894,20 +34010,20 @@ function writeClaudeConfig(directory, configData, syncedFiles, syncedItems, orgN
         console.log();
       }
     }
-    const userSettingsPath = (0, import_path18.join)((0, import_os16.homedir)(), ".claude", "settings.json");
-    if ((0, import_fs19.existsSync)(userSettingsPath)) {
-      const userContent = (0, import_fs19.readFileSync)(userSettingsPath, "utf-8");
+    const userSettingsPath = (0, import_path19.join)((0, import_os17.homedir)(), ".claude", "settings.json");
+    if ((0, import_fs20.existsSync)(userSettingsPath)) {
+      const userContent = (0, import_fs20.readFileSync)(userSettingsPath, "utf-8");
       const userHash = calculateConfigHash(userContent);
       const orgHash = calculateConfigHash(configData.settings.content);
       if (userHash !== orgHash) {
         const userBackupPath = `${userSettingsPath}.bak`;
-        (0, import_fs19.writeFileSync)(userBackupPath, userContent, "utf-8");
+        (0, import_fs20.writeFileSync)(userBackupPath, userContent, "utf-8");
         console.log(source_default.yellow("  User-level settings differ from org baseline."));
         console.log(source_default.dim(`  Backup: ${userBackupPath}`));
         console.log();
       }
     }
-    (0, import_fs19.writeFileSync)(settingsPath, configData.settings.content, "utf-8");
+    (0, import_fs20.writeFileSync)(settingsPath, configData.settings.content, "utf-8");
     syncedFiles.push(".claude/settings.json");
     syncedItems.push({
       path: ".claude/settings.json",
@@ -33917,19 +34033,19 @@ function writeClaudeConfig(directory, configData, syncedFiles, syncedItems, orgN
     });
   }
   if (configData.subagents && configData.subagents.length > 0) {
-    const agentsDir = (0, import_path18.join)(claudeDir, "agents");
-    if (!(0, import_fs19.existsSync)(agentsDir)) {
-      (0, import_fs19.mkdirSync)(agentsDir, { recursive: true });
+    const agentsDir = (0, import_path19.join)(claudeDir, "agents");
+    if (!(0, import_fs20.existsSync)(agentsDir)) {
+      (0, import_fs20.mkdirSync)(agentsDir, { recursive: true });
     }
     for (const agent of configData.subagents) {
       const pathFromName = agent.name.replace(/:/g, "/");
       const fileName = pathFromName.endsWith(".md") ? pathFromName : `${pathFromName}.md`;
-      const filePath = (0, import_path18.join)(agentsDir, fileName);
-      const fileDir = (0, import_path18.dirname)(filePath);
-      if (!(0, import_fs19.existsSync)(fileDir)) {
-        (0, import_fs19.mkdirSync)(fileDir, { recursive: true });
+      const filePath = (0, import_path19.join)(agentsDir, fileName);
+      const fileDir = (0, import_path19.dirname)(filePath);
+      if (!(0, import_fs20.existsSync)(fileDir)) {
+        (0, import_fs20.mkdirSync)(fileDir, { recursive: true });
       }
-      (0, import_fs19.writeFileSync)(filePath, agent.content, "utf-8");
+      (0, import_fs20.writeFileSync)(filePath, agent.content, "utf-8");
       const relativePath = `.claude/agents/${fileName}`;
       syncedFiles.push(relativePath);
       const { description } = parseCommandFrontmatter(agent.content);
@@ -33943,17 +34059,17 @@ function writeClaudeConfig(directory, configData, syncedFiles, syncedItems, orgN
     }
   }
   if (configData.skills && configData.skills.length > 0) {
-    const skillsDir = (0, import_path18.join)(claudeDir, "skills");
-    if (!(0, import_fs19.existsSync)(skillsDir)) {
-      (0, import_fs19.mkdirSync)(skillsDir, { recursive: true });
+    const skillsDir = (0, import_path19.join)(claudeDir, "skills");
+    if (!(0, import_fs20.existsSync)(skillsDir)) {
+      (0, import_fs20.mkdirSync)(skillsDir, { recursive: true });
     }
     for (const skill of configData.skills) {
-      const skillDir = (0, import_path18.join)(skillsDir, skill.name);
-      if (!(0, import_fs19.existsSync)(skillDir)) {
-        (0, import_fs19.mkdirSync)(skillDir, { recursive: true });
+      const skillDir = (0, import_path19.join)(skillsDir, skill.name);
+      if (!(0, import_fs20.existsSync)(skillDir)) {
+        (0, import_fs20.mkdirSync)(skillDir, { recursive: true });
       }
-      const skillPath = (0, import_path18.join)(skillDir, "SKILL.md");
-      (0, import_fs19.writeFileSync)(skillPath, skill.content, "utf-8");
+      const skillPath = (0, import_path19.join)(skillDir, "SKILL.md");
+      (0, import_fs20.writeFileSync)(skillPath, skill.content, "utf-8");
       const relativePath = `.claude/skills/${skill.name}/SKILL.md`;
       syncedFiles.push(relativePath);
       syncedItems.push({
@@ -33966,14 +34082,14 @@ function writeClaudeConfig(directory, configData, syncedFiles, syncedItems, orgN
     }
   }
   if (configData.rules && configData.rules.length > 0) {
-    const rulesDir = (0, import_path18.join)(claudeDir, "rules");
-    if (!(0, import_fs19.existsSync)(rulesDir)) {
-      (0, import_fs19.mkdirSync)(rulesDir, { recursive: true });
+    const rulesDir = (0, import_path19.join)(claudeDir, "rules");
+    if (!(0, import_fs20.existsSync)(rulesDir)) {
+      (0, import_fs20.mkdirSync)(rulesDir, { recursive: true });
     }
     for (const rule of configData.rules) {
       const fileName = rule.name.endsWith(".md") ? rule.name : `${rule.name}.md`;
-      const filePath = (0, import_path18.join)(rulesDir, fileName);
-      (0, import_fs19.writeFileSync)(filePath, rule.content, "utf-8");
+      const filePath = (0, import_path19.join)(rulesDir, fileName);
+      (0, import_fs20.writeFileSync)(filePath, rule.content, "utf-8");
       const relativePath = `.claude/rules/${fileName}`;
       syncedFiles.push(relativePath);
       syncedItems.push({
@@ -33984,79 +34100,25 @@ function writeClaudeConfig(directory, configData, syncedFiles, syncedItems, orgN
       });
     }
   }
-  writeMcpConfig(directory, configData.mcp?.content || "{}", syncedFiles, syncedItems, orgName);
-}
-function expandEnvVarsInValue(value) {
-  if (typeof value === "string") {
-    return value.replace(/\$HOME/g, (0, import_os16.homedir)()).replace(/~/g, (0, import_os16.homedir)());
-  }
-  if (Array.isArray(value)) {
-    return value.map(expandEnvVarsInValue);
-  }
-  if (value && typeof value === "object") {
-    const result = {};
-    for (const [k, v] of Object.entries(value)) {
-      result[k] = expandEnvVarsInValue(v);
-    }
-    return result;
-  }
-  return value;
-}
-function writeMcpConfig(directory, mcpContent, syncedFiles, syncedItems, orgName) {
-  const mcpPath = (0, import_path18.join)(directory, ".mcp.json");
-  let merged = { mcpServers: {} };
-  try {
-    const existing = JSON.parse((0, import_fs19.readFileSync)(mcpPath, "utf-8"));
-    merged = { ...existing, mcpServers: { ...existing.mcpServers } };
-  } catch {
-  }
-  try {
-    const approved = JSON.parse(mcpContent);
-    if (approved.mcpServers) {
-      for (const [name, config] of Object.entries(approved.mcpServers)) {
-        merged.mcpServers[name] = config;
-      }
-    }
-  } catch (e) {
-    console.error("Invalid MCP config content:", e);
-    return;
-  }
-  merged.mcpServers["gal"] = {
-    type: "http",
-    transport: "http",
-    url: "https://api.gal.run/mcp",
-    ...orgName ? { headers: { "X-Gal-Organization": orgName } } : {}
-  };
-  for (const [name, config] of Object.entries(merged.mcpServers)) {
-    merged.mcpServers[name] = expandEnvVarsInValue(config);
-  }
-  (0, import_fs19.writeFileSync)(mcpPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
-  syncedFiles.push(".mcp.json");
-  syncedItems.push({
-    path: ".mcp.json",
-    type: "mcp",
-    name: ".mcp.json",
-    platform: "claude"
-  });
 }
 function writeCodexConfig(directory, configData, syncedFiles, syncedItems) {
-  const codexDir = (0, import_path18.join)(directory, ".codex");
-  const codexDirExists = (0, import_fs19.existsSync)(codexDir);
+  const codexDir = (0, import_path19.join)(directory, ".codex");
+  const codexDirExists = (0, import_fs20.existsSync)(codexDir);
   if (!codexDirExists) {
     return;
   }
   if (configData.skills && configData.skills.length > 0) {
-    const skillsDir = (0, import_path18.join)(codexDir, "skills");
-    if (!(0, import_fs19.existsSync)(skillsDir)) {
-      (0, import_fs19.mkdirSync)(skillsDir, { recursive: true });
+    const skillsDir = (0, import_path19.join)(codexDir, "skills");
+    if (!(0, import_fs20.existsSync)(skillsDir)) {
+      (0, import_fs20.mkdirSync)(skillsDir, { recursive: true });
     }
     for (const skill of configData.skills) {
-      const skillDir = (0, import_path18.join)(skillsDir, skill.name);
-      if (!(0, import_fs19.existsSync)(skillDir)) {
-        (0, import_fs19.mkdirSync)(skillDir, { recursive: true });
+      const skillDir = (0, import_path19.join)(skillsDir, skill.name);
+      if (!(0, import_fs20.existsSync)(skillDir)) {
+        (0, import_fs20.mkdirSync)(skillDir, { recursive: true });
       }
-      const skillPath = (0, import_path18.join)(skillDir, "SKILL.md");
-      (0, import_fs19.writeFileSync)(skillPath, skill.content, "utf-8");
+      const skillPath = (0, import_path19.join)(skillDir, "SKILL.md");
+      (0, import_fs20.writeFileSync)(skillPath, skill.content, "utf-8");
       const relativePath = `.codex/skills/${skill.name}/SKILL.md`;
       syncedFiles.push(relativePath);
       syncedItems.push({
@@ -34068,8 +34130,8 @@ function writeCodexConfig(directory, configData, syncedFiles, syncedItems) {
     }
   }
   if (configData.settings?.content) {
-    const settingsPath = (0, import_path18.join)(codexDir, "settings.json");
-    (0, import_fs19.writeFileSync)(settingsPath, configData.settings.content, "utf-8");
+    const settingsPath = (0, import_path19.join)(codexDir, "settings.json");
+    (0, import_fs20.writeFileSync)(settingsPath, configData.settings.content, "utf-8");
     syncedFiles.push(".codex/settings.json");
     syncedItems.push({
       path: ".codex/settings.json",
@@ -34085,15 +34147,15 @@ function codexPromptFileNameFromCommand(commandName) {
 }
 function writeCodexPrompts(commands) {
   if (!commands || commands.length === 0) return 0;
-  const promptsDir = (0, import_path18.join)((0, import_os16.homedir)(), ".codex", "prompts");
-  if (!(0, import_fs19.existsSync)(promptsDir)) {
-    (0, import_fs19.mkdirSync)(promptsDir, { recursive: true });
+  const promptsDir = (0, import_path19.join)((0, import_os17.homedir)(), ".codex", "prompts");
+  if (!(0, import_fs20.existsSync)(promptsDir)) {
+    (0, import_fs20.mkdirSync)(promptsDir, { recursive: true });
   }
   let written = 0;
   for (const command of commands) {
     const fileName = codexPromptFileNameFromCommand(command.name);
-    const filePath = (0, import_path18.join)(promptsDir, fileName);
-    (0, import_fs19.writeFileSync)(filePath, command.content, "utf-8");
+    const filePath = (0, import_path19.join)(promptsDir, fileName);
+    (0, import_fs20.writeFileSync)(filePath, command.content, "utf-8");
     written += 1;
   }
   return written;
@@ -34125,119 +34187,119 @@ function writeGeminiCommandsAndSkills(directory, configData) {
   let commandsWritten = 0;
   let skillsWritten = 0;
   if (configData.commands && configData.commands.length > 0) {
-    const commandsDir = (0, import_path18.join)(directory, GEMINI_COMMANDS_DIR);
-    if (!(0, import_fs19.existsSync)(commandsDir)) {
-      (0, import_fs19.mkdirSync)(commandsDir, { recursive: true });
+    const commandsDir = (0, import_path19.join)(directory, GEMINI_COMMANDS_DIR);
+    if (!(0, import_fs20.existsSync)(commandsDir)) {
+      (0, import_fs20.mkdirSync)(commandsDir, { recursive: true });
     }
     for (const cmd of configData.commands) {
       const pathFromName = cmd.name.replace(/:/g, "/");
-      const filePath = (0, import_path18.join)(commandsDir, `${pathFromName}.toml`);
-      const fileDir = (0, import_path18.dirname)(filePath);
-      if (!(0, import_fs19.existsSync)(fileDir)) {
-        (0, import_fs19.mkdirSync)(fileDir, { recursive: true });
+      const filePath = (0, import_path19.join)(commandsDir, `${pathFromName}.toml`);
+      const fileDir = (0, import_path19.dirname)(filePath);
+      if (!(0, import_fs20.existsSync)(fileDir)) {
+        (0, import_fs20.mkdirSync)(fileDir, { recursive: true });
       }
       const description = extractDescription2(cmd.content);
       const toml = buildGeminiCommandToml(cmd.name, description, cmd.content);
-      (0, import_fs19.writeFileSync)(filePath, toml, "utf-8");
+      (0, import_fs20.writeFileSync)(filePath, toml, "utf-8");
       commandsWritten += 1;
     }
   }
   if (configData.skills && configData.skills.length > 0) {
-    const skillsDir = (0, import_path18.join)(directory, GEMINI_SKILLS_DIR);
-    if (!(0, import_fs19.existsSync)(skillsDir)) {
-      (0, import_fs19.mkdirSync)(skillsDir, { recursive: true });
+    const skillsDir = (0, import_path19.join)(directory, GEMINI_SKILLS_DIR);
+    if (!(0, import_fs20.existsSync)(skillsDir)) {
+      (0, import_fs20.mkdirSync)(skillsDir, { recursive: true });
     }
     for (const skill of configData.skills) {
-      const skillDir = (0, import_path18.join)(skillsDir, skill.name);
-      if (!(0, import_fs19.existsSync)(skillDir)) {
-        (0, import_fs19.mkdirSync)(skillDir, { recursive: true });
+      const skillDir = (0, import_path19.join)(skillsDir, skill.name);
+      if (!(0, import_fs20.existsSync)(skillDir)) {
+        (0, import_fs20.mkdirSync)(skillDir, { recursive: true });
       }
-      const skillPath = (0, import_path18.join)(skillDir, "SKILL.md");
-      (0, import_fs19.writeFileSync)(skillPath, skill.content, "utf-8");
+      const skillPath = (0, import_path19.join)(skillDir, "SKILL.md");
+      (0, import_fs20.writeFileSync)(skillPath, skill.content, "utf-8");
       skillsWritten += 1;
     }
   }
   return { commandsWritten, skillsWritten };
 }
 function writeApprovedClaudeConfig(directory, configData) {
-  const approvedRoot = (0, import_path18.join)(directory, ".gal", "approved", "claude");
-  const approvedClaudeDir = (0, import_path18.join)(approvedRoot, ".claude");
-  if (!(0, import_fs19.existsSync)(approvedClaudeDir)) {
-    (0, import_fs19.mkdirSync)(approvedClaudeDir, { recursive: true });
+  const approvedRoot = (0, import_path19.join)(directory, ".gal", "approved", "claude");
+  const approvedClaudeDir = (0, import_path19.join)(approvedRoot, ".claude");
+  if (!(0, import_fs20.existsSync)(approvedClaudeDir)) {
+    (0, import_fs20.mkdirSync)(approvedClaudeDir, { recursive: true });
   }
   if (configData.instructions?.content) {
-    const claudeMdPath = (0, import_path18.join)(approvedRoot, "CLAUDE.md");
-    (0, import_fs19.writeFileSync)(claudeMdPath, configData.instructions.content, "utf-8");
+    const claudeMdPath = (0, import_path19.join)(approvedRoot, "CLAUDE.md");
+    (0, import_fs20.writeFileSync)(claudeMdPath, configData.instructions.content, "utf-8");
   }
   if (configData.commands && configData.commands.length > 0) {
-    const commandsDir = (0, import_path18.join)(approvedClaudeDir, "commands");
-    if (!(0, import_fs19.existsSync)(commandsDir)) {
-      (0, import_fs19.mkdirSync)(commandsDir, { recursive: true });
+    const commandsDir = (0, import_path19.join)(approvedClaudeDir, "commands");
+    if (!(0, import_fs20.existsSync)(commandsDir)) {
+      (0, import_fs20.mkdirSync)(commandsDir, { recursive: true });
     }
     for (const cmd of configData.commands) {
       const pathFromName = cmd.name.replace(/:/g, "/");
       const fileName = pathFromName.endsWith(".md") ? pathFromName : `${pathFromName}.md`;
-      const filePath = (0, import_path18.join)(commandsDir, fileName);
-      const fileDir = (0, import_path18.dirname)(filePath);
-      if (!(0, import_fs19.existsSync)(fileDir)) {
-        (0, import_fs19.mkdirSync)(fileDir, { recursive: true });
+      const filePath = (0, import_path19.join)(commandsDir, fileName);
+      const fileDir = (0, import_path19.dirname)(filePath);
+      if (!(0, import_fs20.existsSync)(fileDir)) {
+        (0, import_fs20.mkdirSync)(fileDir, { recursive: true });
       }
-      (0, import_fs19.writeFileSync)(filePath, cmd.content, "utf-8");
+      (0, import_fs20.writeFileSync)(filePath, cmd.content, "utf-8");
     }
   }
   if (configData.hooks && configData.hooks.length > 0) {
-    const hooksDir = (0, import_path18.join)(approvedClaudeDir, "hooks");
-    if (!(0, import_fs19.existsSync)(hooksDir)) {
-      (0, import_fs19.mkdirSync)(hooksDir, { recursive: true });
+    const hooksDir = (0, import_path19.join)(approvedClaudeDir, "hooks");
+    if (!(0, import_fs20.existsSync)(hooksDir)) {
+      (0, import_fs20.mkdirSync)(hooksDir, { recursive: true });
     }
     for (const hook of configData.hooks) {
-      const filePath = (0, import_path18.join)(hooksDir, hook.name);
-      (0, import_fs19.writeFileSync)(filePath, hook.content, "utf-8");
+      const filePath = (0, import_path19.join)(hooksDir, hook.name);
+      (0, import_fs20.writeFileSync)(filePath, hook.content, "utf-8");
     }
   }
   if (configData.settings?.content) {
-    const settingsPath = (0, import_path18.join)(approvedClaudeDir, "settings.json");
-    (0, import_fs19.writeFileSync)(settingsPath, configData.settings.content, "utf-8");
+    const settingsPath = (0, import_path19.join)(approvedClaudeDir, "settings.json");
+    (0, import_fs20.writeFileSync)(settingsPath, configData.settings.content, "utf-8");
   }
   if (configData.subagents && configData.subagents.length > 0) {
-    const agentsDir = (0, import_path18.join)(approvedClaudeDir, "agents");
-    if (!(0, import_fs19.existsSync)(agentsDir)) {
-      (0, import_fs19.mkdirSync)(agentsDir, { recursive: true });
+    const agentsDir = (0, import_path19.join)(approvedClaudeDir, "agents");
+    if (!(0, import_fs20.existsSync)(agentsDir)) {
+      (0, import_fs20.mkdirSync)(agentsDir, { recursive: true });
     }
     for (const agent of configData.subagents) {
       const pathFromName = agent.name.replace(/:/g, "/");
       const fileName = pathFromName.endsWith(".md") ? pathFromName : `${pathFromName}.md`;
-      const filePath = (0, import_path18.join)(agentsDir, fileName);
-      const fileDir = (0, import_path18.dirname)(filePath);
-      if (!(0, import_fs19.existsSync)(fileDir)) {
-        (0, import_fs19.mkdirSync)(fileDir, { recursive: true });
+      const filePath = (0, import_path19.join)(agentsDir, fileName);
+      const fileDir = (0, import_path19.dirname)(filePath);
+      if (!(0, import_fs20.existsSync)(fileDir)) {
+        (0, import_fs20.mkdirSync)(fileDir, { recursive: true });
       }
-      (0, import_fs19.writeFileSync)(filePath, agent.content, "utf-8");
+      (0, import_fs20.writeFileSync)(filePath, agent.content, "utf-8");
     }
   }
   if (configData.skills && configData.skills.length > 0) {
-    const skillsDir = (0, import_path18.join)(approvedClaudeDir, "skills");
-    if (!(0, import_fs19.existsSync)(skillsDir)) {
-      (0, import_fs19.mkdirSync)(skillsDir, { recursive: true });
+    const skillsDir = (0, import_path19.join)(approvedClaudeDir, "skills");
+    if (!(0, import_fs20.existsSync)(skillsDir)) {
+      (0, import_fs20.mkdirSync)(skillsDir, { recursive: true });
     }
     for (const skill of configData.skills) {
-      const skillDir = (0, import_path18.join)(skillsDir, skill.name);
-      if (!(0, import_fs19.existsSync)(skillDir)) {
-        (0, import_fs19.mkdirSync)(skillDir, { recursive: true });
+      const skillDir = (0, import_path19.join)(skillsDir, skill.name);
+      if (!(0, import_fs20.existsSync)(skillDir)) {
+        (0, import_fs20.mkdirSync)(skillDir, { recursive: true });
       }
-      const skillPath = (0, import_path18.join)(skillDir, "SKILL.md");
-      (0, import_fs19.writeFileSync)(skillPath, skill.content, "utf-8");
+      const skillPath = (0, import_path19.join)(skillDir, "SKILL.md");
+      (0, import_fs20.writeFileSync)(skillPath, skill.content, "utf-8");
     }
   }
   if (configData.rules && configData.rules.length > 0) {
-    const rulesDir = (0, import_path18.join)(approvedClaudeDir, "rules");
-    if (!(0, import_fs19.existsSync)(rulesDir)) {
-      (0, import_fs19.mkdirSync)(rulesDir, { recursive: true });
+    const rulesDir = (0, import_path19.join)(approvedClaudeDir, "rules");
+    if (!(0, import_fs20.existsSync)(rulesDir)) {
+      (0, import_fs20.mkdirSync)(rulesDir, { recursive: true });
     }
     for (const rule of configData.rules) {
       const fileName = rule.name.endsWith(".md") ? rule.name : `${rule.name}.md`;
-      const filePath = (0, import_path18.join)(rulesDir, fileName);
-      (0, import_fs19.writeFileSync)(filePath, rule.content, "utf-8");
+      const filePath = (0, import_path19.join)(rulesDir, fileName);
+      (0, import_fs20.writeFileSync)(filePath, rule.content, "utf-8");
     }
   }
 }
@@ -34403,6 +34465,7 @@ async function pullApprovedConfig(configRepo, authRepo, orgName, directory, plat
       hooks: approvedConfig.hooks,
       settings: approvedConfig.settings,
       cursorRules: approvedConfig.cursorRules,
+      mcp: approvedConfig.mcp ? { content: approvedConfig.mcp.content, hash: approvedConfig.mcp.hash } : void 0,
       copilotInstructions: approvedConfig.copilotInstructions,
       copilotPathInstructions: approvedConfig.copilotPathInstructions?.map((item) => ({
         name: item.name,
@@ -34513,20 +34576,20 @@ async function pullApprovedConfig(configRepo, authRepo, orgName, directory, plat
       } else {
         if (configData.configContent) {
           const platformDir = getPlatformDirectory(platform5);
-          const configPath = (0, import_path18.join)(directory, platformDir);
-          if (!(0, import_fs19.existsSync)(configPath)) {
-            (0, import_fs19.mkdirSync)(configPath, { recursive: true });
+          const configPath = (0, import_path19.join)(directory, platformDir);
+          if (!(0, import_fs20.existsSync)(configPath)) {
+            (0, import_fs20.mkdirSync)(configPath, { recursive: true });
           }
           try {
             const parsedContent = JSON.parse(configData.configContent);
             for (const [filePath, content] of Object.entries(parsedContent)) {
-              const fullPath = (0, import_path18.join)(configPath, filePath);
-              const dir = (0, import_path18.dirname)(fullPath);
-              if (!(0, import_fs19.existsSync)(dir)) {
-                (0, import_fs19.mkdirSync)(dir, { recursive: true });
+              const fullPath = (0, import_path19.join)(configPath, filePath);
+              const dir = (0, import_path19.dirname)(fullPath);
+              if (!(0, import_fs20.existsSync)(dir)) {
+                (0, import_fs20.mkdirSync)(dir, { recursive: true });
               }
-              (0, import_fs19.writeFileSync)(fullPath, content);
-              platformFiles.push((0, import_path18.join)(platformDir, filePath));
+              (0, import_fs20.writeFileSync)(fullPath, content);
+              platformFiles.push((0, import_path19.join)(platformDir, filePath));
               platformItems.push({
                 path: filePath,
                 type: getItemType(filePath),
@@ -34535,9 +34598,9 @@ async function pullApprovedConfig(configRepo, authRepo, orgName, directory, plat
               });
             }
           } catch {
-            const singlePath = (0, import_path18.join)(configPath, "approved-config.json");
-            (0, import_fs19.writeFileSync)(singlePath, configData.configContent);
-            platformFiles.push((0, import_path18.join)(platformDir, "approved-config.json"));
+            const singlePath = (0, import_path19.join)(configPath, "approved-config.json");
+            (0, import_fs20.writeFileSync)(singlePath, configData.configContent);
+            platformFiles.push((0, import_path19.join)(platformDir, "approved-config.json"));
           }
         }
       }
@@ -34557,6 +34620,34 @@ async function pullApprovedConfig(configRepo, authRepo, orgName, directory, plat
       platformSpinner?.fail(source_default.red(`  ${platform5}: Failed - ${error2 instanceof Error ? error2.message : String(error2)}`));
     }
   }
+  {
+    const mcpSource = configsToSync.find((c) => c.platform === "claude") || configsToSync[0];
+    const mcpContent = mcpSource?.mcp?.content;
+    const mcpSpinner = isFullOutput ? ora("  mcp: Syncing MCP server configs...").start() : null;
+    try {
+      const mcpResult = syncMcpConfig(directory, mcpContent || void 0, orgName);
+      allSyncedFiles.push(".mcp.json");
+      allSyncedItems.push({
+        path: ".mcp.json",
+        type: "mcp",
+        name: ".mcp.json",
+        platform: "claude"
+        // Track as claude for backward compat
+      });
+      totalFilesWritten++;
+      const parts = [];
+      if (mcpResult.orgServersApplied > 0) {
+        parts.push(`${mcpResult.orgServersApplied} org server(s)`);
+      }
+      if (mcpResult.preservedUserServers.length > 0) {
+        parts.push(`${mcpResult.preservedUserServers.length} user server(s) preserved`);
+      }
+      parts.push("GAL hosted server included");
+      mcpSpinner?.succeed(source_default.green(`  mcp: ${parts.join(", ")}`));
+    } catch (error2) {
+      mcpSpinner?.fail(source_default.red(`  mcp: Failed - ${error2 instanceof Error ? error2.message : String(error2)}`));
+    }
+  }
   const claudeApprovedConfig = configsToSync.find((c) => c.platform === "claude");
   const platformsToSyncList = configsToSync.map((c) => c.platform);
   let claudeConfigData;
@@ -34634,16 +34725,16 @@ async function pullApprovedConfig(configRepo, authRepo, orgName, directory, plat
     }
   } catch {
   }
-  const existingAgentsMdPath = (0, import_path18.join)(directory, "AGENTS.md");
+  const existingAgentsMdPath = (0, import_path19.join)(directory, "AGENTS.md");
   let existingDocsIndex;
-  if ((0, import_fs19.existsSync)(existingAgentsMdPath)) {
-    const existingContent = (0, import_fs19.readFileSync)(existingAgentsMdPath, "utf-8");
+  if ((0, import_fs20.existsSync)(existingAgentsMdPath)) {
+    const existingContent = (0, import_fs20.readFileSync)(existingAgentsMdPath, "utf-8");
     const dispatchMarker = "|@section:background-dispatch";
     const markerIndex = existingContent.indexOf(dispatchMarker);
     existingDocsIndex = markerIndex >= 0 ? existingContent.substring(0, markerIndex).trim() : existingContent.trim();
   }
   const agentsMdContent = generateAgentsMd(existingDocsIndex, dispatchRules);
-  (0, import_fs19.writeFileSync)(existingAgentsMdPath, agentsMdContent, "utf-8");
+  (0, import_fs20.writeFileSync)(existingAgentsMdPath, agentsMdContent, "utf-8");
   allSyncedFiles.push("AGENTS.md");
   allSyncedItems.push({
     path: "AGENTS.md",
@@ -34657,11 +34748,11 @@ async function pullApprovedConfig(configRepo, authRepo, orgName, directory, plat
     console.log(source_default.dim(`  Written: AGENTS.md (universal cross-platform)`));
   }
   if (dispatchRules) {
-    const galDir = (0, import_path18.join)(directory, ".gal");
-    if (!(0, import_fs19.existsSync)(galDir)) {
-      (0, import_fs19.mkdirSync)(galDir, { recursive: true });
+    const galDir = (0, import_path19.join)(directory, ".gal");
+    if (!(0, import_fs20.existsSync)(galDir)) {
+      (0, import_fs20.mkdirSync)(galDir, { recursive: true });
     }
-    (0, import_fs19.writeFileSync)((0, import_path18.join)(galDir, "dispatch-rules.json"), JSON.stringify(dispatchRules), "utf-8");
+    (0, import_fs20.writeFileSync)((0, import_path19.join)(galDir, "dispatch-rules.json"), JSON.stringify(dispatchRules), "utf-8");
     if (isFullOutput) {
       console.log(source_default.dim(`  Written: .gal/dispatch-rules.json (hook cache)`));
     }
@@ -34864,12 +34955,12 @@ async function pullPersonalRepoConfig(authRepo, repoName, directory) {
     const syncedItems = [];
     for (const config of configs) {
       const relativePath = config.path.replace(/^\/+/, "");
-      const fullPath = (0, import_path18.join)(directory, relativePath);
-      const dir = (0, import_path18.dirname)(fullPath);
-      if (!(0, import_fs19.existsSync)(dir)) {
-        (0, import_fs19.mkdirSync)(dir, { recursive: true });
+      const fullPath = (0, import_path19.join)(directory, relativePath);
+      const dir = (0, import_path19.dirname)(fullPath);
+      if (!(0, import_fs20.existsSync)(dir)) {
+        (0, import_fs20.mkdirSync)(dir, { recursive: true });
       }
-      (0, import_fs19.writeFileSync)(fullPath, config.content);
+      (0, import_fs20.writeFileSync)(fullPath, config.content);
       syncedFiles.push(relativePath);
       const itemType = getItemType(relativePath);
       const itemName = getItemName(relativePath);
@@ -34919,20 +35010,20 @@ async function pullPersonalApprovedConfig(authRepo, approvedConfig, directory) {
     }
     const configData = JSON.parse(approvedConfig.configContent);
     const platformDir = ".claude";
-    const configPath = (0, import_path18.join)(directory, platformDir);
-    if (!(0, import_fs19.existsSync)(configPath)) {
-      (0, import_fs19.mkdirSync)(configPath, { recursive: true });
+    const configPath = (0, import_path19.join)(directory, platformDir);
+    if (!(0, import_fs20.existsSync)(configPath)) {
+      (0, import_fs20.mkdirSync)(configPath, { recursive: true });
     }
     const syncedFiles = [];
     const syncedItems = [];
     for (const [filePath, content] of Object.entries(configData)) {
-      const fullPath = (0, import_path18.join)(configPath, filePath);
-      const dir = (0, import_path18.dirname)(fullPath);
-      if (!(0, import_fs19.existsSync)(dir)) {
-        (0, import_fs19.mkdirSync)(dir, { recursive: true });
+      const fullPath = (0, import_path19.join)(configPath, filePath);
+      const dir = (0, import_path19.dirname)(fullPath);
+      if (!(0, import_fs20.existsSync)(dir)) {
+        (0, import_fs20.mkdirSync)(dir, { recursive: true });
       }
-      (0, import_fs19.writeFileSync)(fullPath, content);
-      const relativePath = (0, import_path18.join)(platformDir, filePath);
+      (0, import_fs20.writeFileSync)(fullPath, content);
+      const relativePath = (0, import_path19.join)(platformDir, filePath);
       syncedFiles.push(relativePath);
       const itemType = getItemType(filePath);
       const itemName = getItemName(filePath);
@@ -34992,18 +35083,18 @@ async function checkApprovedConfig(configRepo, orgName, directory, platformFilte
       const platformDir = getPlatformDirectory(platform5);
       if (approvedConfig.instructions?.content) {
         const relativePath = "CLAUDE.md";
-        const fullPath = (0, import_path18.join)(directory, relativePath);
+        const fullPath = (0, import_path19.join)(directory, relativePath);
         result.expectedFiles.push(relativePath);
-        if (!(0, import_fs19.existsSync)(fullPath)) {
+        if (!(0, import_fs20.existsSync)(fullPath)) {
           result.missingFiles.push(relativePath);
           result.inSync = false;
         }
       }
       if (approvedConfig.settings?.content) {
-        const relativePath = (0, import_path18.join)(platformDir, "settings.json");
-        const fullPath = (0, import_path18.join)(directory, relativePath);
+        const relativePath = (0, import_path19.join)(platformDir, "settings.json");
+        const fullPath = (0, import_path19.join)(directory, relativePath);
         result.expectedFiles.push(relativePath);
-        if (!(0, import_fs19.existsSync)(fullPath)) {
+        if (!(0, import_fs20.existsSync)(fullPath)) {
           result.missingFiles.push(relativePath);
           result.inSync = false;
         }
@@ -35012,10 +35103,10 @@ async function checkApprovedConfig(configRepo, orgName, directory, platformFilte
         for (const cmd of approvedConfig.commands) {
           const pathFromName = cmd.name.replace(/:/g, "/");
           const fileName = pathFromName.endsWith(".md") ? pathFromName : `${pathFromName}.md`;
-          const relativePath = (0, import_path18.join)(platformDir, "commands", fileName);
-          const fullPath = (0, import_path18.join)(directory, relativePath);
+          const relativePath = (0, import_path19.join)(platformDir, "commands", fileName);
+          const fullPath = (0, import_path19.join)(directory, relativePath);
           result.expectedFiles.push(relativePath);
-          if (!(0, import_fs19.existsSync)(fullPath)) {
+          if (!(0, import_fs20.existsSync)(fullPath)) {
             result.missingFiles.push(relativePath);
             result.inSync = false;
           }
@@ -35024,10 +35115,10 @@ async function checkApprovedConfig(configRepo, orgName, directory, platformFilte
       if (approvedConfig.rules && approvedConfig.rules.length > 0) {
         for (const rule of approvedConfig.rules) {
           const fileName = rule.name.endsWith(".md") ? rule.name : `${rule.name}.md`;
-          const relativePath = (0, import_path18.join)(platformDir, "rules", fileName);
-          const fullPath = (0, import_path18.join)(directory, relativePath);
+          const relativePath = (0, import_path19.join)(platformDir, "rules", fileName);
+          const fullPath = (0, import_path19.join)(directory, relativePath);
           result.expectedFiles.push(relativePath);
-          if (!(0, import_fs19.existsSync)(fullPath)) {
+          if (!(0, import_fs20.existsSync)(fullPath)) {
             result.missingFiles.push(relativePath);
             result.inSync = false;
           }
@@ -35038,7 +35129,7 @@ async function checkApprovedConfig(configRepo, orgName, directory, platformFilte
   }
   console.log(JSON.stringify(result));
 }
-var import_fs19, import_path18, import_os16, import_crypto6, cliVersion4, defaultApiUrl4, GAL_CLI_CURSOR_RULES_VERSION, GAL_CLI_CURSOR_RULES, CODEX_PROMPT_PREFIX, GEMINI_COMMANDS_DIR, GEMINI_SKILLS_DIR;
+var import_fs20, import_path19, import_os17, import_crypto6, cliVersion4, defaultApiUrl4, GAL_CLI_CURSOR_RULES_VERSION, GAL_CLI_CURSOR_RULES, CODEX_PROMPT_PREFIX, GEMINI_COMMANDS_DIR, GEMINI_SKILLS_DIR;
 var init_sync = __esm({
   "src/commands/sync.ts"() {
     "use strict";
@@ -35048,9 +35139,9 @@ var init_sync = __esm({
     init_constants();
     init_config_manager();
     init_telemetry();
-    import_fs19 = require("fs");
-    import_path18 = require("path");
-    import_os16 = require("os");
+    import_fs20 = require("fs");
+    import_path19 = require("path");
+    import_os17 = require("os");
     init_project_detection();
     import_crypto6 = require("crypto");
     init_dist2();
@@ -35060,6 +35151,7 @@ var init_sync = __esm({
     init_CoreServiceProvider();
     init_agents_md_generator();
     init_dispatch_categories();
+    init_mcp_config_writer();
     cliVersion4 = constants_default[0];
     defaultApiUrl4 = constants_default[1];
     GAL_CLI_CURSOR_RULES_VERSION = "1.0.0";
@@ -35624,7 +35716,7 @@ Review status: ${source_default.cyan("gal auth status")}
       let accessToken;
       let refreshToken;
       let expiresAt;
-      const claudeDir = (0, import_path19.join)((0, import_os17.homedir)(), ".claude");
+      const claudeDir = (0, import_path20.join)((0, import_os18.homedir)(), ".claude");
       let credentialSource2 = "";
       const isSetupTokenMode2 = !!options.setupToken;
       if (options.setupToken) {
@@ -35705,13 +35797,13 @@ Review status: ${source_default.cyan("gal auth status")}
         }
       }
       if (!isSetupTokenMode2 && (!accessToken || !refreshToken)) {
-        const legacyCredentialsPath = (0, import_path19.join)(claudeDir, ".credentials.json");
+        const legacyCredentialsPath = (0, import_path20.join)(claudeDir, ".credentials.json");
         if (verbose) {
           spinner.info(source_default.dim(`  Trying ${legacyCredentialsPath}...`));
         }
-        if ((0, import_fs20.existsSync)(legacyCredentialsPath)) {
+        if ((0, import_fs21.existsSync)(legacyCredentialsPath)) {
           try {
-            const content = (0, import_fs20.readFileSync)(legacyCredentialsPath, "utf-8");
+            const content = (0, import_fs21.readFileSync)(legacyCredentialsPath, "utf-8");
             const credentials = JSON.parse(content);
             accessToken = credentials.claudeAiOauth?.accessToken;
             refreshToken = credentials.claudeAiOauth?.refreshToken;
@@ -35735,13 +35827,13 @@ Review status: ${source_default.cyan("gal auth status")}
         }
       }
       if (!isSetupTokenMode2 && (!accessToken || !refreshToken)) {
-        const configPath = (0, import_path19.join)(claudeDir, ".claude.json");
+        const configPath = (0, import_path20.join)(claudeDir, ".claude.json");
         if (verbose) {
           spinner.info(source_default.dim(`  Trying ${configPath} (oauthCredentials field)...`));
         }
-        if ((0, import_fs20.existsSync)(configPath)) {
+        if ((0, import_fs21.existsSync)(configPath)) {
           try {
-            const content = (0, import_fs20.readFileSync)(configPath, "utf-8");
+            const content = (0, import_fs21.readFileSync)(configPath, "utf-8");
             const claudeConfig = JSON.parse(content);
             accessToken = claudeConfig.oauthCredentials?.claudeAiOauth?.accessToken;
             refreshToken = claudeConfig.oauthCredentials?.claudeAiOauth?.refreshToken;
@@ -35864,13 +35956,13 @@ Review status: ${source_default.cyan("gal auth status")}
           spinner.info(source_default.dim("  Using API key from command line"));
         }
       } else {
-        const codexAuthPath = (0, import_path19.join)((0, import_os17.homedir)(), ".codex", "auth.json");
+        const codexAuthPath = (0, import_path20.join)((0, import_os18.homedir)(), ".codex", "auth.json");
         if (verbose) {
           spinner.info(source_default.dim(`  Trying ${codexAuthPath}...`));
         }
-        if ((0, import_fs20.existsSync)(codexAuthPath)) {
+        if ((0, import_fs21.existsSync)(codexAuthPath)) {
           try {
-            const content = (0, import_fs20.readFileSync)(codexAuthPath, "utf-8");
+            const content = (0, import_fs21.readFileSync)(codexAuthPath, "utf-8");
             const authData = JSON.parse(content);
             if (verbose) {
               spinner.info(source_default.dim(`  Found auth.json, checking tokens...`));
@@ -35982,13 +36074,13 @@ Source: ${credentialSource2}`));
           spinner.info(source_default.dim("  Using API key from command line"));
         }
       } else {
-        const geminiAuthPath = (0, import_path19.join)((0, import_os17.homedir)(), ".gemini", "oauth_creds.json");
+        const geminiAuthPath = (0, import_path20.join)((0, import_os18.homedir)(), ".gemini", "oauth_creds.json");
         if (verbose) {
           spinner.info(source_default.dim(`  Trying ${geminiAuthPath}...`));
         }
-        if ((0, import_fs20.existsSync)(geminiAuthPath)) {
+        if ((0, import_fs21.existsSync)(geminiAuthPath)) {
           try {
-            const content = (0, import_fs20.readFileSync)(geminiAuthPath, "utf-8");
+            const content = (0, import_fs21.readFileSync)(geminiAuthPath, "utf-8");
             const authData = JSON.parse(content);
             if (verbose) {
               spinner.info(source_default.dim(`  Found oauth_creds.json, checking tokens...`));
@@ -36309,7 +36401,7 @@ Source: ${credentialSource2}`));
   });
   return auth;
 }
-var import_http, import_child_process6, import_os17, import_fs20, import_path19, import_readline2, CLI_CALLBACK_PORT, CLI_CALLBACK_PATH, cliVersion5, defaultApiUrl5;
+var import_http, import_child_process6, import_os18, import_fs21, import_path20, import_readline2, CLI_CALLBACK_PORT, CLI_CALLBACK_PATH, cliVersion5, defaultApiUrl5;
 var init_auth2 = __esm({
   "src/commands/auth.ts"() {
     "use strict";
@@ -36322,9 +36414,9 @@ var init_auth2 = __esm({
     init_constants();
     init_CoreServiceProvider();
     init_telemetry();
-    import_os17 = require("os");
-    import_fs20 = require("fs");
-    import_path19 = require("path");
+    import_os18 = require("os");
+    import_fs21 = require("fs");
+    import_path20 = require("path");
     init_hooks();
     init_sync();
     import_readline2 = require("readline");
@@ -36339,13 +36431,13 @@ var init_auth2 = __esm({
 // src/commands/check.ts
 function createCheckCommand() {
   const command = new Command("check").description("Pre-enforcement check - see what issues will block your commit").option("--fix", "Auto-fix issues where possible").option("--interactive", "Interactive mode to review issues").option("--report", "Generate detailed JSON report").option("--path <path>", "Project path to check", process.cwd()).action(async (options) => {
-    if (!(0, import_fs21.existsSync)(options.path)) {
+    if (!(0, import_fs22.existsSync)(options.path)) {
       console.error(source_default.red(`
 Error: Path does not exist: ${options.path}
 `));
       process.exit(1);
     }
-    if (!(0, import_fs21.statSync)(options.path).isDirectory()) {
+    if (!(0, import_fs22.statSync)(options.path).isDirectory()) {
       console.error(source_default.red(`
 Error: Path is not a directory: ${options.path}
 `));
@@ -36357,8 +36449,8 @@ Error: Path is not a directory: ${options.path}
     });
     const report = await checker.runAllChecks();
     if (options.report) {
-      const reportPath = (0, import_path20.join)(options.path, "gal-check-report.json");
-      (0, import_fs21.writeFileSync)(reportPath, JSON.stringify(report, null, 2));
+      const reportPath = (0, import_path21.join)(options.path, "gal-check-report.json");
+      (0, import_fs22.writeFileSync)(reportPath, JSON.stringify(report, null, 2));
       console.log(source_default.blue(`Report saved to: ${reportPath}`));
     }
     if (report.summary.blocked) {
@@ -36367,14 +36459,14 @@ Error: Path is not a directory: ${options.path}
   });
   return command;
 }
-var import_fs21, import_path20, import_child_process7, SECRET_PATTERNS, DANGEROUS_PATTERNS, FORBIDDEN_FILES, PreEnforcementChecker;
+var import_fs22, import_path21, import_child_process7, SECRET_PATTERNS, DANGEROUS_PATTERNS, FORBIDDEN_FILES, PreEnforcementChecker;
 var init_check = __esm({
   "src/commands/check.ts"() {
     "use strict";
     init_esm();
     init_source();
-    import_fs21 = require("fs");
-    import_path20 = require("path");
+    import_fs22 = require("fs");
+    import_path21 = require("path");
     import_child_process7 = require("child_process");
     SECRET_PATTERNS = [
       {
@@ -36526,10 +36618,10 @@ var init_check = __esm({
         const scan = (currentDir, depth) => {
           if (depth > maxDepth) return;
           try {
-            const entries = (0, import_fs21.readdirSync)(currentDir, { withFileTypes: true });
+            const entries = (0, import_fs22.readdirSync)(currentDir, { withFileTypes: true });
             for (const entry of entries) {
-              const fullPath = (0, import_path20.join)(currentDir, entry.name);
-              const relativePath = (0, import_path20.relative)(this.projectPath, fullPath);
+              const fullPath = (0, import_path21.join)(currentDir, entry.name);
+              const relativePath = (0, import_path21.relative)(this.projectPath, fullPath);
               if (entry.isDirectory()) {
                 if (!ignoreDirs.includes(entry.name)) {
                   scan(fullPath, depth + 1);
@@ -36549,10 +36641,10 @@ var init_check = __esm({
        */
       async checkForSecrets(files) {
         for (const file of files) {
-          const fullPath = (0, import_path20.join)(this.projectPath, file);
-          if (!(0, import_fs21.existsSync)(fullPath) || !this.isTextFile(fullPath)) continue;
+          const fullPath = (0, import_path21.join)(this.projectPath, file);
+          if (!(0, import_fs22.existsSync)(fullPath) || !this.isTextFile(fullPath)) continue;
           try {
-            const content = (0, import_fs21.readFileSync)(fullPath, "utf-8");
+            const content = (0, import_fs22.readFileSync)(fullPath, "utf-8");
             const lines = content.split("\n");
             for (const { name, pattern, severity, suggestion } of SECRET_PATTERNS) {
               pattern.lastIndex = 0;
@@ -36584,13 +36676,13 @@ var init_check = __esm({
       async checkForDangerousCommands(files) {
         const scriptExtensions = [".sh", ".bash", ".zsh", ".ps1", ".bat", ".cmd"];
         for (const file of files) {
-          const fullPath = (0, import_path20.join)(this.projectPath, file);
-          if (!(0, import_fs21.existsSync)(fullPath)) continue;
+          const fullPath = (0, import_path21.join)(this.projectPath, file);
+          if (!(0, import_fs22.existsSync)(fullPath)) continue;
           const isScript = scriptExtensions.some((ext) => file.endsWith(ext));
           const isConfig = file.includes("hook") || file.includes("command");
           if (!isScript && !isConfig) continue;
           try {
-            const content = (0, import_fs21.readFileSync)(fullPath, "utf-8");
+            const content = (0, import_fs22.readFileSync)(fullPath, "utf-8");
             for (const { name, pattern, severity, suggestion } of DANGEROUS_PATTERNS) {
               pattern.lastIndex = 0;
               let match;
@@ -36643,14 +36735,14 @@ var init_check = __esm({
       async checkAgentConfigs() {
         const configDirs = [".claude", ".cursor", ".gemini", ".codex", ".windsurf"];
         for (const dir of configDirs) {
-          const dirPath = (0, import_path20.join)(this.projectPath, dir);
-          if (!(0, import_fs21.existsSync)(dirPath)) continue;
+          const dirPath = (0, import_path21.join)(this.projectPath, dir);
+          if (!(0, import_fs22.existsSync)(dirPath)) continue;
           const files = this.scanDirectory(dirPath, 2);
           for (const file of files) {
-            const fullPath = (0, import_path20.join)(this.projectPath, file);
-            if (!(0, import_fs21.existsSync)(fullPath)) continue;
+            const fullPath = (0, import_path21.join)(this.projectPath, file);
+            if (!(0, import_fs22.existsSync)(fullPath)) continue;
             try {
-              const content = (0, import_fs21.readFileSync)(fullPath, "utf-8");
+              const content = (0, import_fs22.readFileSync)(fullPath, "utf-8");
               if (content.includes('"allowAll": true') || content.includes("allowAll: true")) {
                 this.issues.push({
                   severity: "high",
@@ -36690,7 +36782,7 @@ var init_check = __esm({
             file.replace("src/", "src/__tests__/").replace(/\.(ts|tsx|js|jsx)$/, ".test.$1")
           ];
           const hasTest = testVariants.some(
-            (testFile) => (0, import_fs21.existsSync)((0, import_path20.join)(this.projectPath, testFile))
+            (testFile) => (0, import_fs22.existsSync)((0, import_path21.join)(this.projectPath, testFile))
           );
           if (!hasTest) {
             this.issues.push({
@@ -42397,18 +42489,18 @@ Writing configs to ${outputDir}:
         if (!fileName.includes(".")) {
           fileName = `${fileName}${extension}`;
         }
-        const relativePath = categoryDir ? (0, import_path21.join)(platformDir, categoryDir, fileName) : (0, import_path21.join)(platformDir, fileName);
-        const fullPath = (0, import_path21.join)(outputDir, relativePath);
+        const relativePath = categoryDir ? (0, import_path22.join)(platformDir, categoryDir, fileName) : (0, import_path22.join)(platformDir, fileName);
+        const fullPath = (0, import_path22.join)(outputDir, relativePath);
         if (options.dryRun) {
           console.log(source_default.cyan("  [dry-run]"), relativePath);
           writtenFiles.push(relativePath);
           continue;
         }
-        const dir = (0, import_path21.dirname)(fullPath);
-        if (!(0, import_fs22.existsSync)(dir)) {
-          (0, import_fs22.mkdirSync)(dir, { recursive: true });
+        const dir = (0, import_path22.dirname)(fullPath);
+        if (!(0, import_fs23.existsSync)(dir)) {
+          (0, import_fs23.mkdirSync)(dir, { recursive: true });
         }
-        (0, import_fs22.writeFileSync)(fullPath, file.content, "utf-8");
+        (0, import_fs23.writeFileSync)(fullPath, file.content, "utf-8");
         writtenFiles.push(relativePath);
         console.log(source_default.green("  \u2713"), relativePath);
       }
@@ -42469,7 +42561,7 @@ Files written to ${outputDir}`));
   });
   return command;
 }
-var import_fs22, import_path21, PLATFORM_DIRS4, CATEGORY_DIRS, FILE_EXTENSIONS;
+var import_fs23, import_path22, PLATFORM_DIRS4, CATEGORY_DIRS, FILE_EXTENSIONS;
 var init_fetch = __esm({
   "src/commands/fetch.ts"() {
     "use strict";
@@ -42478,8 +42570,8 @@ var init_fetch = __esm({
     init_ora();
     init_config_manager();
     init_CoreServiceProvider();
-    import_fs22 = require("fs");
-    import_path21 = require("path");
+    import_fs23 = require("fs");
+    import_path22 = require("path");
     init_capability_checker();
     init_dist2();
     PLATFORM_DIRS4 = { ...PLATFORM_DIRECTORY_MAP };
@@ -42741,13 +42833,13 @@ function getGitEmail() {
 }
 async function getLocalEnforcementStatus() {
   const { stat: stat5, readFile: readFile4 } = await import("node:fs/promises");
-  const { join: join46 } = await import("node:path");
+  const { join: join47 } = await import("node:path");
   const platforms = [];
   let version = "0.0.0";
   let policyVersion = "0.0.0";
   const platformDirs = [".claude", ".cursor", ".gemini", ".codex", ".windsurf"];
   for (const dir of platformDirs) {
-    const hookPath = join46(process.cwd(), dir, "hooks", "gal-safety-hook.py");
+    const hookPath = join47(process.cwd(), dir, "hooks", "gal-safety-hook.py");
     try {
       await stat5(hookPath);
       platforms.push(dir.replace(".", ""));
@@ -42760,7 +42852,7 @@ async function getLocalEnforcementStatus() {
     }
   }
   try {
-    const pkgPath = join46(import_meta2.url.replace("file://", ""), "..", "..", "..", "package.json");
+    const pkgPath = join47(import_meta2.url.replace("file://", ""), "..", "..", "..", "package.json");
     const pkg = JSON.parse(await readFile4(pkgPath, "utf-8"));
     version = pkg.version || "0.1.0";
   } catch {
@@ -43220,15 +43312,15 @@ Task not running: ${taskId}
   });
   return command;
 }
-var import_child_process8, import_fs23, import_path22, DEFAULT_CONFIG, TASK_TEMPLATES, HeadlessRunner;
+var import_child_process8, import_fs24, import_path23, DEFAULT_CONFIG, TASK_TEMPLATES, HeadlessRunner;
 var init_headless = __esm({
   "src/commands/headless.ts"() {
     "use strict";
     init_esm();
     init_source();
     import_child_process8 = require("child_process");
-    import_fs23 = require("fs");
-    import_path22 = require("path");
+    import_fs24 = require("fs");
+    import_path23 = require("path");
     DEFAULT_CONFIG = {
       dataDir: ".gal/headless",
       logDir: ".gal/headless/logs",
@@ -43282,23 +43374,23 @@ var init_headless = __esm({
        * Ensure required directories exist
        */
       ensureDirectories() {
-        const dataDir = (0, import_path22.join)(this.projectPath, this.config.dataDir);
-        const logDir = (0, import_path22.join)(this.projectPath, this.config.logDir);
-        if (!(0, import_fs23.existsSync)(dataDir)) {
-          (0, import_fs23.mkdirSync)(dataDir, { recursive: true });
+        const dataDir = (0, import_path23.join)(this.projectPath, this.config.dataDir);
+        const logDir = (0, import_path23.join)(this.projectPath, this.config.logDir);
+        if (!(0, import_fs24.existsSync)(dataDir)) {
+          (0, import_fs24.mkdirSync)(dataDir, { recursive: true });
         }
-        if (!(0, import_fs23.existsSync)(logDir)) {
-          (0, import_fs23.mkdirSync)(logDir, { recursive: true });
+        if (!(0, import_fs24.existsSync)(logDir)) {
+          (0, import_fs24.mkdirSync)(logDir, { recursive: true });
         }
       }
       /**
        * Load tasks from disk
        */
       loadTasks() {
-        const tasksFile = (0, import_path22.join)(this.projectPath, this.config.dataDir, "tasks.json");
-        if ((0, import_fs23.existsSync)(tasksFile)) {
+        const tasksFile = (0, import_path23.join)(this.projectPath, this.config.dataDir, "tasks.json");
+        if ((0, import_fs24.existsSync)(tasksFile)) {
           try {
-            const data = JSON.parse((0, import_fs23.readFileSync)(tasksFile, "utf-8"));
+            const data = JSON.parse((0, import_fs24.readFileSync)(tasksFile, "utf-8"));
             for (const task of data.tasks || []) {
               this.tasks.set(task.id, {
                 ...task,
@@ -43315,12 +43407,12 @@ var init_headless = __esm({
        * Save tasks to disk
        */
       saveTasks() {
-        const tasksFile = (0, import_path22.join)(this.projectPath, this.config.dataDir, "tasks.json");
+        const tasksFile = (0, import_path23.join)(this.projectPath, this.config.dataDir, "tasks.json");
         const data = {
           tasks: Array.from(this.tasks.values()),
           updatedAt: (/* @__PURE__ */ new Date()).toISOString()
         };
-        (0, import_fs23.writeFileSync)(tasksFile, JSON.stringify(data, null, 2));
+        (0, import_fs24.writeFileSync)(tasksFile, JSON.stringify(data, null, 2));
       }
       /**
        * Create a new task
@@ -43371,7 +43463,7 @@ var init_headless = __esm({
         task.status = "running";
         task.startedAt = /* @__PURE__ */ new Date();
         this.saveTasks();
-        const logFile = (0, import_path22.join)(
+        const logFile = (0, import_path23.join)(
           this.projectPath,
           this.config.logDir,
           `${task.id}_${Date.now()}.log`
@@ -43397,7 +43489,7 @@ var init_headless = __esm({
           const logStream = (data, isError = false) => {
             const text = data.toString();
             const prefix = isError ? "[ERROR] " : "";
-            (0, import_fs23.appendFileSync)(logFile, `${(/* @__PURE__ */ new Date()).toISOString()} ${prefix}${text}`);
+            (0, import_fs24.appendFileSync)(logFile, `${(/* @__PURE__ */ new Date()).toISOString()} ${prefix}${text}`);
             if (!task.output) task.output = "";
             task.output += text;
           };
@@ -43841,7 +43933,7 @@ if __name__ == '__main__':
 `;
 }
 function createJoinCommand() {
-  const join46 = new Command("join").description("Join an organization using an invite code (GAL-100)").option("-c, --code <code>", "Invite code (e.g., GAL-XXXX-XXXX)").option("-e, --email <email>", "Developer email (defaults to git config)").option("--skip-hooks", "Skip enforcement hook installation").option("--dry-run", "Validate invite without joining").action(async (options) => {
+  const join47 = new Command("join").description("Join an organization using an invite code (GAL-100)").option("-c, --code <code>", "Invite code (e.g., GAL-XXXX-XXXX)").option("-e, --email <email>", "Developer email (defaults to git config)").option("--skip-hooks", "Skip enforcement hook installation").option("--dry-run", "Validate invite without joining").action(async (options) => {
     const spinner = ora();
     if (!options.code) {
       console.log(source_default.bold("\nGAL Developer Onboarding\n"));
@@ -43957,7 +44049,7 @@ Error: ${useResult.error || "Unknown error"}`));
       process.exit(1);
     }
   });
-  return join46;
+  return join47;
 }
 var import_node_os5, import_node_child_process2, import_node_crypto3, import_promises6, import_node_path4, defaultApiUrl9;
 var init_join = __esm({
@@ -44284,10 +44376,10 @@ function parseMcpJsonRpcBody(body) {
   return null;
 }
 function readMcpConfig(mcpPath) {
-  if (!(0, import_fs24.existsSync)(mcpPath)) {
+  if (!(0, import_fs25.existsSync)(mcpPath)) {
     return { mcpServers: {} };
   }
-  const raw = (0, import_fs24.readFileSync)(mcpPath, "utf-8");
+  const raw = (0, import_fs25.readFileSync)(mcpPath, "utf-8");
   const parsed = JSON.parse(raw);
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
     throw new Error(`${mcpPath} must be a JSON object`);
@@ -44343,11 +44435,11 @@ async function postMcpJsonRpc(endpoint, authToken, method, params, timeoutMs) {
 }
 async function runMcpDoctor(options = {}) {
   const config = ConfigManager.load();
-  const directory = (0, import_path23.resolve)(options.directory || process.cwd());
+  const directory = (0, import_path24.resolve)(options.directory || process.cwd());
   const serverName = options.serverName || DEFAULT_SERVER_NAME;
   const fallbackApiUrl = resolveApiUrl(options.apiUrl || config.apiUrl || defaultApiUrl10);
   let endpoint = buildMcpUrl(fallbackApiUrl);
-  const mcpPath = (0, import_path23.join)(directory, ".mcp.json");
+  const mcpPath = (0, import_path24.join)(directory, ".mcp.json");
   const authToken = options.authToken ?? config.authToken;
   const timeoutMs = options.timeoutMs ?? 1e4;
   const result = {
@@ -44498,11 +44590,11 @@ MCP is healthy. ${result.toolsCount} GAL tools are available.
 }
 function createSetupCommand() {
   return new Command("setup").description("Create or update .mcp.json with hosted GAL MCP server").option("--dir <path>", "Target directory (default: current directory)").option("--api-url <url>", "GAL API URL (default: config/default)").option("--server-name <name>", `MCP server key (default: ${DEFAULT_SERVER_NAME})`).option("--skip-doctor", "Skip running MCP diagnostics after setup").action(async (options) => {
-    const directory = (0, import_path23.resolve)(options.dir || process.cwd());
+    const directory = (0, import_path24.resolve)(options.dir || process.cwd());
     const serverName = options.serverName || DEFAULT_SERVER_NAME;
     const config = ConfigManager.load();
     const apiUrl = resolveApiUrl(options.apiUrl || config.apiUrl || defaultApiUrl10);
-    const mcpPath = (0, import_path23.join)(directory, ".mcp.json");
+    const mcpPath = (0, import_path24.join)(directory, ".mcp.json");
     let existing = { mcpServers: {} };
     try {
       existing = readMcpConfig(mcpPath);
@@ -44511,8 +44603,8 @@ function createSetupCommand() {
       process.exit(1);
     }
     const next = upsertHostedGalServer(existing, serverName, apiUrl);
-    (0, import_fs24.mkdirSync)(directory, { recursive: true });
-    (0, import_fs24.writeFileSync)(mcpPath, JSON.stringify(next, null, 2) + "\n", "utf-8");
+    (0, import_fs25.mkdirSync)(directory, { recursive: true });
+    (0, import_fs25.writeFileSync)(mcpPath, JSON.stringify(next, null, 2) + "\n", "utf-8");
     console.log(source_default.green(`\u2713 Updated ${mcpPath}`));
     console.log(source_default.dim(`  mcpServers.${serverName}.url = ${buildMcpUrl(apiUrl)}
 `));
@@ -44561,15 +44653,15 @@ function createDoctorCommand() {
 function createMcpCommand() {
   return new Command("mcp").description("Set up and validate GAL hosted MCP connectivity").addCommand(createSetupCommand()).addCommand(createDoctorCommand());
 }
-var import_fs24, import_path23, DEFAULT_SERVER_NAME, defaultApiUrl10;
+var import_fs25, import_path24, DEFAULT_SERVER_NAME, defaultApiUrl10;
 var init_mcp = __esm({
   "src/commands/mcp.ts"() {
     "use strict";
     init_esm();
     init_source();
     init_ora();
-    import_fs24 = require("fs");
-    import_path23 = require("path");
+    import_fs25 = require("fs");
+    import_path24 = require("path");
     init_config_manager();
     init_constants();
     DEFAULT_SERVER_NAME = "gal";
@@ -44580,12 +44672,12 @@ var init_mcp = __esm({
 // src/commands/memory.ts
 function parseClaudeMemoryFile(filePath) {
   try {
-    const raw = (0, import_fs25.readFileSync)(filePath, "utf-8");
+    const raw = (0, import_fs26.readFileSync)(filePath, "utf-8");
     const frontmatterMatch = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
     if (!frontmatterMatch) {
       return {
-        name: (0, import_path24.basename)(filePath, ".md"),
-        description: (0, import_path24.basename)(filePath, ".md").replace(/[-_]/g, " "),
+        name: (0, import_path25.basename)(filePath, ".md"),
+        description: (0, import_path25.basename)(filePath, ".md").replace(/[-_]/g, " "),
         type: "project",
         content: raw.trim(),
         source: "claude"
@@ -44599,8 +44691,8 @@ function parseClaudeMemoryFile(filePath) {
     const memType = getType?.[1]?.trim();
     const validTypes = ["user", "feedback", "project", "reference"];
     return {
-      name: getName?.[1]?.trim() || (0, import_path24.basename)(filePath, ".md"),
-      description: getDesc?.[1]?.trim() || (0, import_path24.basename)(filePath, ".md").replace(/[-_]/g, " "),
+      name: getName?.[1]?.trim() || (0, import_path25.basename)(filePath, ".md"),
+      description: getDesc?.[1]?.trim() || (0, import_path25.basename)(filePath, ".md").replace(/[-_]/g, " "),
       type: validTypes.includes(memType) ? memType : "project",
       content: body,
       source: "claude",
@@ -44614,22 +44706,22 @@ function discoverMemoryFiles(projectRoot, platform5, includeGlobal) {
   const files = [];
   const pattern = PLATFORM_PATTERNS[platform5];
   if (pattern.memoryDir) {
-    const memDir = (0, import_path24.join)(projectRoot, pattern.directory, pattern.memoryDir);
-    if ((0, import_fs25.existsSync)(memDir) && (0, import_fs25.statSync)(memDir).isDirectory()) {
+    const memDir = (0, import_path25.join)(projectRoot, pattern.directory, pattern.memoryDir);
+    if ((0, import_fs26.existsSync)(memDir) && (0, import_fs26.statSync)(memDir).isDirectory()) {
       scanMemoryDir(memDir, projectRoot, files, false);
     }
   }
   if (includeGlobal) {
-    const home = (0, import_os18.homedir)();
+    const home = (0, import_os19.homedir)();
     if (platform5 === "claude") {
-      const projectsDir = (0, import_path24.join)(home, ".claude", "projects");
-      if ((0, import_fs25.existsSync)(projectsDir)) {
+      const projectsDir = (0, import_path25.join)(home, ".claude", "projects");
+      if ((0, import_fs26.existsSync)(projectsDir)) {
         try {
-          const projectDirs = (0, import_fs25.readdirSync)(projectsDir, { withFileTypes: true });
+          const projectDirs = (0, import_fs26.readdirSync)(projectsDir, { withFileTypes: true });
           for (const projDir of projectDirs) {
             if (!projDir.isDirectory()) continue;
-            const memDir = (0, import_path24.join)(projectsDir, projDir.name, "memory");
-            if ((0, import_fs25.existsSync)(memDir) && (0, import_fs25.statSync)(memDir).isDirectory()) {
+            const memDir = (0, import_path25.join)(projectsDir, projDir.name, "memory");
+            if ((0, import_fs26.existsSync)(memDir) && (0, import_fs26.statSync)(memDir).isDirectory()) {
               scanMemoryDir(memDir, home, files, true);
             }
           }
@@ -44637,8 +44729,8 @@ function discoverMemoryFiles(projectRoot, platform5, includeGlobal) {
         }
       }
     } else if (platform5 === "windsurf") {
-      const memoriesDir = (0, import_path24.join)(home, ".codeium", "windsurf", "memories");
-      if ((0, import_fs25.existsSync)(memoriesDir)) {
+      const memoriesDir = (0, import_path25.join)(home, ".codeium", "windsurf", "memories");
+      if ((0, import_fs26.existsSync)(memoriesDir)) {
         scanMemoryDir(memoriesDir, home, files, true);
       }
     }
@@ -44647,16 +44739,16 @@ function discoverMemoryFiles(projectRoot, platform5, includeGlobal) {
 }
 function scanMemoryDir(dir, rootDir, files, isGlobal) {
   try {
-    const entries = (0, import_fs25.readdirSync)(dir, { withFileTypes: true });
+    const entries = (0, import_fs26.readdirSync)(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = (0, import_path24.join)(dir, entry.name);
+      const fullPath = (0, import_path25.join)(dir, entry.name);
       if (entry.isDirectory()) {
         scanMemoryDir(fullPath, rootDir, files, isGlobal);
       } else if (entry.isFile() && (entry.name.endsWith(".md") || entry.name.endsWith(".json"))) {
         if (entry.name === "MEMORY.md") continue;
         files.push({
           path: fullPath,
-          relativePath: (0, import_path24.relative)(rootDir, fullPath),
+          relativePath: (0, import_path25.relative)(rootDir, fullPath),
           isGlobal
         });
       }
@@ -44737,9 +44829,9 @@ Examples:
         mem = parseClaudeMemoryFile(file.path);
       } else {
         try {
-          const content = (0, import_fs25.readFileSync)(file.path, "utf-8");
+          const content = (0, import_fs26.readFileSync)(file.path, "utf-8");
           mem = {
-            name: (0, import_path24.basename)(file.path, ".md").replace(/[-_]/g, "-"),
+            name: (0, import_path25.basename)(file.path, ".md").replace(/[-_]/g, "-"),
             description: `Imported from ${source}: ${file.relativePath}`,
             type: "project",
             content: content.trim(),
@@ -44856,15 +44948,15 @@ Examples:
   });
   return command;
 }
-var import_fs25, import_path24, import_os18;
+var import_fs26, import_path25, import_os19;
 var init_memory2 = __esm({
   "src/commands/memory.ts"() {
     "use strict";
     init_esm();
     init_source();
-    import_fs25 = require("fs");
-    import_path24 = require("path");
-    import_os18 = require("os");
+    import_fs26 = require("fs");
+    import_path25 = require("path");
+    import_os19 = require("os");
     init_dist2();
     init_project_detection();
     init_gal_config_service();
@@ -45390,21 +45482,21 @@ var init_policy = __esm({
 async function readLocalConfig() {
   const projectRoot = findProjectRoot();
   const canonicalSources = [
-    { path: (0, import_path25.join)(projectRoot, ".gal", "config.yaml"), label: ".gal/config.yaml" },
-    { path: (0, import_path25.join)((0, import_os19.homedir)(), ".gal", "config.yaml"), label: "~/.gal/config.yaml" }
+    { path: (0, import_path26.join)(projectRoot, ".gal", "config.yaml"), label: ".gal/config.yaml" },
+    { path: (0, import_path26.join)((0, import_os20.homedir)(), ".gal", "config.yaml"), label: "~/.gal/config.yaml" }
   ];
   for (const source of canonicalSources) {
-    if (!(0, import_fs26.existsSync)(source.path)) continue;
+    if (!(0, import_fs27.existsSync)(source.path)) continue;
     try {
-      const content = (0, import_fs26.readFileSync)(source.path, "utf-8");
+      const content = (0, import_fs27.readFileSync)(source.path, "utf-8");
       const config = (0, import_yaml2.parse)(content);
       return config;
     } catch (error2) {
       console.warn(`Failed to parse ${source.label}:`, error2);
     }
   }
-  const claudeDir = (0, import_path25.join)(projectRoot, ".claude");
-  if (!(0, import_fs26.existsSync)(claudeDir)) {
+  const claudeDir = (0, import_path26.join)(projectRoot, ".claude");
+  if (!(0, import_fs27.existsSync)(claudeDir)) {
     return null;
   }
   return constructConfigFromClaudeDir(claudeDir);
@@ -45417,10 +45509,10 @@ function constructConfigFromClaudeDir(claudeDir) {
     hash: "",
     syncedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  const settingsPath = (0, import_path25.join)(claudeDir, "settings.json");
-  if ((0, import_fs26.existsSync)(settingsPath)) {
+  const settingsPath = (0, import_path26.join)(claudeDir, "settings.json");
+  if ((0, import_fs27.existsSync)(settingsPath)) {
     try {
-      const settingsContent = (0, import_fs26.readFileSync)(settingsPath, "utf-8");
+      const settingsContent = (0, import_fs27.readFileSync)(settingsPath, "utf-8");
       let claudeSettings;
       try {
         claudeSettings = JSON.parse(settingsContent);
@@ -45436,24 +45528,24 @@ function constructConfigFromClaudeDir(claudeDir) {
       console.warn("Failed to read .claude/settings.json:", error2);
     }
   }
-  const claudeMdPath = (0, import_path25.join)(claudeDir, "..", "CLAUDE.md");
-  if ((0, import_fs26.existsSync)(claudeMdPath)) {
+  const claudeMdPath = (0, import_path26.join)(claudeDir, "..", "CLAUDE.md");
+  if ((0, import_fs27.existsSync)(claudeMdPath)) {
     try {
-      const claudeMdContent = (0, import_fs26.readFileSync)(claudeMdPath, "utf-8");
+      const claudeMdContent = (0, import_fs27.readFileSync)(claudeMdPath, "utf-8");
       config.instructions = { content: claudeMdContent };
     } catch (error2) {
       console.warn("Failed to read CLAUDE.md:", error2);
     }
   }
-  const commandsDir = (0, import_path25.join)(claudeDir, "commands");
-  if ((0, import_fs26.existsSync)(commandsDir)) {
+  const commandsDir = (0, import_path26.join)(claudeDir, "commands");
+  if ((0, import_fs27.existsSync)(commandsDir)) {
     config.commands = [];
     try {
       const commandFiles = readDirRecursive(commandsDir, ".md");
       for (const file of commandFiles) {
         const relativePath = file.replace(commandsDir + "/", "");
         const commandName = relativePath.replace(/\.md$/, "").replace(/\//g, ":");
-        const content = (0, import_fs26.readFileSync)(file, "utf-8");
+        const content = (0, import_fs27.readFileSync)(file, "utf-8");
         config.commands.push({
           name: commandName,
           content
@@ -45463,14 +45555,14 @@ function constructConfigFromClaudeDir(claudeDir) {
       console.warn("Failed to read .claude/commands/:", error2);
     }
   }
-  const rulesDir = (0, import_path25.join)(claudeDir, "rules");
-  if ((0, import_fs26.existsSync)(rulesDir)) {
+  const rulesDir = (0, import_path26.join)(claudeDir, "rules");
+  if ((0, import_fs27.existsSync)(rulesDir)) {
     config.rules = [];
     try {
-      const ruleFiles = (0, import_fs26.readdirSync)(rulesDir).filter((f) => f.endsWith(".md"));
+      const ruleFiles = (0, import_fs27.readdirSync)(rulesDir).filter((f) => f.endsWith(".md"));
       for (const file of ruleFiles) {
         const ruleName = file.replace(/\.md$/, "");
-        const content = (0, import_fs26.readFileSync)((0, import_path25.join)(rulesDir, file), "utf-8");
+        const content = (0, import_fs27.readFileSync)((0, import_path26.join)(rulesDir, file), "utf-8");
         config.rules.push({
           name: ruleName,
           content
@@ -45480,13 +45572,13 @@ function constructConfigFromClaudeDir(claudeDir) {
       console.warn("Failed to read .claude/rules/:", error2);
     }
   }
-  const hooksDir = (0, import_path25.join)(claudeDir, "hooks");
-  if ((0, import_fs26.existsSync)(hooksDir)) {
+  const hooksDir = (0, import_path26.join)(claudeDir, "hooks");
+  if ((0, import_fs27.existsSync)(hooksDir)) {
     config.hooks = [];
     try {
-      const hookFiles = (0, import_fs26.readdirSync)(hooksDir).filter((f) => f.endsWith(".js") || f.endsWith(".py") || f.endsWith(".sh"));
+      const hookFiles = (0, import_fs27.readdirSync)(hooksDir).filter((f) => f.endsWith(".js") || f.endsWith(".py") || f.endsWith(".sh"));
       for (const file of hookFiles) {
-        const content = (0, import_fs26.readFileSync)((0, import_path25.join)(hooksDir, file), "utf-8");
+        const content = (0, import_fs27.readFileSync)((0, import_path26.join)(hooksDir, file), "utf-8");
         config.hooks.push({
           name: file,
           event: "PreToolUse",
@@ -45498,15 +45590,15 @@ function constructConfigFromClaudeDir(claudeDir) {
       console.warn("Failed to read .claude/hooks/:", error2);
     }
   }
-  const agentsDir = (0, import_path25.join)(claudeDir, "agents");
-  if ((0, import_fs26.existsSync)(agentsDir)) {
+  const agentsDir = (0, import_path26.join)(claudeDir, "agents");
+  if ((0, import_fs27.existsSync)(agentsDir)) {
     config.agents = [];
     try {
       const agentFiles = readDirRecursive(agentsDir, ".md");
       for (const file of agentFiles) {
         const relativePath = file.replace(agentsDir + "/", "");
         const agentName = relativePath.replace(/\.md$/, "").replace(/\//g, ":");
-        const content = (0, import_fs26.readFileSync)(file, "utf-8");
+        const content = (0, import_fs27.readFileSync)(file, "utf-8");
         config.agents.push({
           name: agentName,
           content
@@ -45525,10 +45617,10 @@ function constructConfigFromClaudeDir(claudeDir) {
 function readDirRecursive(dir, extension) {
   const results = [];
   try {
-    const files = (0, import_fs26.readdirSync)(dir);
+    const files = (0, import_fs27.readdirSync)(dir);
     for (const file of files) {
-      const filePath = (0, import_path25.join)(dir, file);
-      const stat5 = (0, import_fs26.statSync)(filePath);
+      const filePath = (0, import_path26.join)(dir, file);
+      const stat5 = (0, import_fs27.statSync)(filePath);
       if (stat5.isDirectory()) {
         results.push(...readDirRecursive(filePath, extension));
       } else if (file.endsWith(extension)) {
@@ -45539,13 +45631,13 @@ function readDirRecursive(dir, extension) {
   }
   return results;
 }
-var import_fs26, import_path25, import_os19, import_yaml2;
+var import_fs27, import_path26, import_os20, import_yaml2;
 var init_config_reader = __esm({
   "src/utils/config-reader.ts"() {
     "use strict";
-    import_fs26 = require("fs");
-    import_path25 = require("path");
-    import_os19 = require("os");
+    import_fs27 = require("fs");
+    import_path26 = require("path");
+    import_os20 = require("os");
     init_project_detection();
     import_yaml2 = __toESM(require_dist(), 1);
   }
@@ -45555,8 +45647,8 @@ var init_config_reader = __esm({
 function getGitRepoInfo() {
   try {
     const projectRoot = findProjectRoot();
-    const gitDir = (0, import_path26.join)(projectRoot, ".git");
-    if (!(0, import_fs27.existsSync)(gitDir)) {
+    const gitDir = (0, import_path27.join)(projectRoot, ".git");
+    if (!(0, import_fs28.existsSync)(gitDir)) {
       return { isRepo: false };
     }
     const remoteUrl = (0, import_child_process9.execSync)("git remote get-url origin", {
@@ -45689,7 +45781,7 @@ function createProposeCommand() {
   });
   return command;
 }
-var import_fs27, import_path26, import_child_process9;
+var import_fs28, import_path27, import_child_process9;
 var init_propose = __esm({
   "src/commands/propose.ts"() {
     "use strict";
@@ -45700,8 +45792,8 @@ var init_propose = __esm({
     init_CoreServiceProvider();
     init_config_reader();
     init_project_detection();
-    import_fs27 = require("fs");
-    import_path26 = require("path");
+    import_fs28 = require("fs");
+    import_path27 = require("path");
     import_child_process9 = require("child_process");
   }
 });
@@ -46386,7 +46478,7 @@ function createAddCommand() {
     let prompt2 = promptArg;
     if (options.promptFile) {
       try {
-        prompt2 = (0, import_fs28.readFileSync)(options.promptFile, "utf-8").trim();
+        prompt2 = (0, import_fs29.readFileSync)(options.promptFile, "utf-8").trim();
       } catch (err) {
         console.error(source_default.red(`Error reading prompt file: ${err instanceof Error ? err.message : String(err)}`));
         process.exit(1);
@@ -46633,14 +46725,14 @@ function createCancelCommand() {
     }
   });
 }
-var import_fs28, defaultApiUrl12, PRIORITY_LABELS, PRIORITY_COLORS, STATUS_COLORS;
+var import_fs29, defaultApiUrl12, PRIORITY_LABELS, PRIORITY_COLORS, STATUS_COLORS;
 var init_queue_mgmt = __esm({
   "src/commands/queue-mgmt.ts"() {
     "use strict";
     init_esm();
     init_source();
     init_ora();
-    import_fs28 = require("fs");
+    import_fs29 = require("fs");
     init_constants();
     init_config_manager();
     init_client();
@@ -46884,11 +46976,11 @@ function createSeedCommand() {
     }
     let template = options.template;
     if (options.templateFile) {
-      if (!(0, import_fs29.existsSync)(options.templateFile)) {
+      if (!(0, import_fs30.existsSync)(options.templateFile)) {
         console.error(source_default.red(`Error: Template file not found: ${options.templateFile}`));
         process.exit(1);
       }
-      template = (0, import_fs29.readFileSync)(options.templateFile, "utf-8").trim();
+      template = (0, import_fs30.readFileSync)(options.templateFile, "utf-8").trim();
     }
     const config = ConfigManager.load();
     const apiUrl = config.apiUrl ?? process.env.GAL_API_URL ?? defaultApiUrl13;
@@ -46904,13 +46996,13 @@ function createSeedCommand() {
     });
     if (options.file) {
       const filePath = options.file;
-      if (!(0, import_fs29.existsSync)(filePath)) {
+      if (!(0, import_fs30.existsSync)(filePath)) {
         console.error(source_default.red(`Error: File not found: ${filePath}`));
         process.exit(1);
       }
       let items = [];
       try {
-        const raw = (0, import_fs29.readFileSync)(filePath, "utf-8");
+        const raw = (0, import_fs30.readFileSync)(filePath, "utf-8");
         const parsed = JSON.parse(raw);
         if (!Array.isArray(parsed)) {
           console.error(source_default.red("Error: JSON file must contain an array of work items."));
@@ -47075,14 +47167,14 @@ function createQueueCommand() {
   cmd.addCommand(createSeedCommand());
   return cmd;
 }
-var import_fs29, defaultApiUrl13, GH_API_BASE, DEFAULT_TEMPLATE_BY_LABEL, DEFAULT_TEMPLATE;
+var import_fs30, defaultApiUrl13, GH_API_BASE, DEFAULT_TEMPLATE_BY_LABEL, DEFAULT_TEMPLATE;
 var init_queue_seed = __esm({
   "src/commands/queue-seed.ts"() {
     "use strict";
     init_esm();
     init_source();
     init_ora();
-    import_fs29 = require("fs");
+    import_fs30 = require("fs");
     init_config_manager();
     init_constants();
     init_client();
@@ -47138,10 +47230,10 @@ function parseFrontmatter(content) {
   };
 }
 function parseCommandFile(filePath) {
-  const content = (0, import_fs30.readFileSync)(filePath, "utf-8");
+  const content = (0, import_fs31.readFileSync)(filePath, "utf-8");
   const { metadata, body } = parseFrontmatter(content);
-  const fileName = (0, import_path27.basename)(filePath);
-  const name = (0, import_path27.basename)(filePath, (0, import_path27.extname)(filePath));
+  const fileName = (0, import_path28.basename)(filePath);
+  const name = (0, import_path28.basename)(filePath, (0, import_path28.extname)(filePath));
   return {
     name,
     fileName,
@@ -47154,10 +47246,10 @@ function parseCommandFile(filePath) {
 function findCommandFiles(dir, recursive = true) {
   const files = [];
   try {
-    const entries = (0, import_fs30.readdirSync)(dir);
+    const entries = (0, import_fs31.readdirSync)(dir);
     for (const entry of entries) {
-      const fullPath = (0, import_path27.join)(dir, entry);
-      const stats = (0, import_fs30.statSync)(fullPath);
+      const fullPath = (0, import_path28.join)(dir, entry);
+      const stats = (0, import_fs31.statSync)(fullPath);
       if (stats.isDirectory()) {
         if (entry.startsWith(".") || entry === "node_modules" || entry === ".templates") {
           continue;
@@ -47232,12 +47324,12 @@ function substituteArguments(commandBody, args2) {
   }
   return result;
 }
-var import_fs30, import_path27;
+var import_fs31, import_path28;
 var init_command_parser = __esm({
   "src/parser/command-parser.ts"() {
     "use strict";
-    import_fs30 = require("fs");
-    import_path27 = require("path");
+    import_fs31 = require("fs");
+    import_path28 = require("path");
   }
 });
 
@@ -47478,12 +47570,12 @@ var init_headless_executor = __esm({
 
 // src/commands/run.ts
 function findCommandsDirectory() {
-  const localCommandsDir = (0, import_path28.join)(process.cwd(), ".claude", "commands");
-  if ((0, import_fs31.existsSync)(localCommandsDir)) {
+  const localCommandsDir = (0, import_path29.join)(process.cwd(), ".claude", "commands");
+  if ((0, import_fs32.existsSync)(localCommandsDir)) {
     return localCommandsDir;
   }
-  const homeCommandsDir = (0, import_path28.join)((0, import_os20.homedir)(), ".claude", "commands");
-  if ((0, import_fs31.existsSync)(homeCommandsDir)) {
+  const homeCommandsDir = (0, import_path29.join)((0, import_os21.homedir)(), ".claude", "commands");
+  if ((0, import_fs32.existsSync)(homeCommandsDir)) {
     return homeCommandsDir;
   }
   return null;
@@ -47571,7 +47663,7 @@ async function handleRunCommand(commandName, args2, options) {
     let commandsDir = options.dir || findCommandsDirectory();
     let command;
     if (options.file) {
-      if (!(0, import_fs31.existsSync)(options.file)) {
+      if (!(0, import_fs32.existsSync)(options.file)) {
         console.error(source_default.red(`Error: Command file not found: ${options.file}`));
         process.exit(1);
       }
@@ -47653,16 +47745,16 @@ Executing command: ${command.name}`));
     throw error2;
   }
 }
-var import_os20, import_path28, import_fs31;
+var import_os21, import_path29, import_fs32;
 var init_run = __esm({
   "src/commands/run.ts"() {
     "use strict";
     init_esm();
     init_source();
     init_ora();
-    import_os20 = require("os");
-    import_path28 = require("path");
-    import_fs31 = require("fs");
+    import_os21 = require("os");
+    import_path29 = require("path");
+    import_fs32 = require("fs");
     init_command_parser();
     init_headless_executor();
   }
@@ -47670,30 +47762,30 @@ var init_run = __esm({
 
 // src/commands/run-design.ts
 function ensureDir() {
-  if (!(0, import_fs32.existsSync)(DESIGN_PROJECTS_DIR)) {
-    (0, import_fs32.mkdirSync)(DESIGN_PROJECTS_DIR, { recursive: true });
+  if (!(0, import_fs33.existsSync)(DESIGN_PROJECTS_DIR)) {
+    (0, import_fs33.mkdirSync)(DESIGN_PROJECTS_DIR, { recursive: true });
   }
 }
 function projectPath(id) {
-  return (0, import_path29.join)(DESIGN_PROJECTS_DIR, `${id}.json`);
+  return (0, import_path30.join)(DESIGN_PROJECTS_DIR, `${id}.json`);
 }
 function saveProject(project) {
   ensureDir();
-  (0, import_fs32.writeFileSync)(projectPath(project.id), JSON.stringify(project, null, 2));
+  (0, import_fs33.writeFileSync)(projectPath(project.id), JSON.stringify(project, null, 2));
 }
 function loadProject(id) {
   const p = projectPath(id);
-  if (!(0, import_fs32.existsSync)(p)) return null;
+  if (!(0, import_fs33.existsSync)(p)) return null;
   try {
-    return JSON.parse((0, import_fs32.readFileSync)(p, "utf-8"));
+    return JSON.parse((0, import_fs33.readFileSync)(p, "utf-8"));
   } catch {
     return null;
   }
 }
 function getActiveId() {
-  if (!(0, import_fs32.existsSync)(ACTIVE_FILE)) return null;
+  if (!(0, import_fs33.existsSync)(ACTIVE_FILE)) return null;
   try {
-    const data = JSON.parse((0, import_fs32.readFileSync)(ACTIVE_FILE, "utf-8"));
+    const data = JSON.parse((0, import_fs33.readFileSync)(ACTIVE_FILE, "utf-8"));
     return data.id ?? null;
   } catch {
     return null;
@@ -47701,7 +47793,7 @@ function getActiveId() {
 }
 function setActiveId(id) {
   ensureDir();
-  (0, import_fs32.writeFileSync)(ACTIVE_FILE, JSON.stringify({ id }, null, 2));
+  (0, import_fs33.writeFileSync)(ACTIVE_FILE, JSON.stringify({ id }, null, 2));
 }
 function getActiveProject() {
   const id = getActiveId();
@@ -47822,7 +47914,7 @@ function handleStatus(options) {
     project = getActiveProject();
     if (!project) {
       ensureDir();
-      const files = (0, import_fs32.readdirSync)(DESIGN_PROJECTS_DIR).filter(
+      const files = (0, import_fs33.readdirSync)(DESIGN_PROJECTS_DIR).filter(
         (f) => f.endsWith(".json") && f !== "active.json"
       );
       if (files.length === 0) {
@@ -47937,8 +48029,8 @@ function handleSync() {
   const project = getActiveProject();
   if (!project) {
     ensureDir();
-    (0, import_fs32.writeFileSync)(
-      (0, import_path29.join)(DESIGN_PROJECTS_DIR, "extension-sync.json"),
+    (0, import_fs33.writeFileSync)(
+      (0, import_path30.join)(DESIGN_PROJECTS_DIR, "extension-sync.json"),
       JSON.stringify(null, null, 2)
     );
     console.log(source_default.yellow("No active project. Extension card cleared."));
@@ -47955,8 +48047,8 @@ function handleSync() {
     completedScenes: done
   };
   ensureDir();
-  (0, import_fs32.writeFileSync)(
-    (0, import_path29.join)(DESIGN_PROJECTS_DIR, "extension-sync.json"),
+  (0, import_fs33.writeFileSync)(
+    (0, import_path30.join)(DESIGN_PROJECTS_DIR, "extension-sync.json"),
     JSON.stringify(summary, null, 2)
   );
   console.log(source_default.green("\nSynced active project to extension:\n"));
@@ -48000,17 +48092,17 @@ function createRunDesignCommand() {
   runDesign.addCommand(syncCmd);
   return runDesign;
 }
-var import_os21, import_path29, import_fs32, DESIGN_PROJECTS_DIR, ACTIVE_FILE, IMAGE_STATUS_ICON, VIDEO_STATUS_ICON;
+var import_os22, import_path30, import_fs33, DESIGN_PROJECTS_DIR, ACTIVE_FILE, IMAGE_STATUS_ICON, VIDEO_STATUS_ICON;
 var init_run_design = __esm({
   "src/commands/run-design.ts"() {
     "use strict";
     init_esm();
     init_source();
-    import_os21 = require("os");
-    import_path29 = require("path");
-    import_fs32 = require("fs");
-    DESIGN_PROJECTS_DIR = (0, import_path29.join)((0, import_os21.homedir)(), ".gal", "design-projects");
-    ACTIVE_FILE = (0, import_path29.join)(DESIGN_PROJECTS_DIR, "active.json");
+    import_os22 = require("os");
+    import_path30 = require("path");
+    import_fs33 = require("fs");
+    DESIGN_PROJECTS_DIR = (0, import_path30.join)((0, import_os22.homedir)(), ".gal", "design-projects");
+    ACTIVE_FILE = (0, import_path30.join)(DESIGN_PROJECTS_DIR, "active.json");
     IMAGE_STATUS_ICON = {
       pending: "  ",
       generating: "  ",
@@ -48031,104 +48123,104 @@ var init_run_design = __esm({
 function scanPlatform(rootDir, pattern) {
   const configs = [];
   const platform5 = pattern.platform;
-  const platformDir = (0, import_path30.join)(rootDir, pattern.directory);
+  const platformDir = (0, import_path31.join)(rootDir, pattern.directory);
   if (pattern.settingsFile) {
-    const settingsPath = (0, import_path30.join)(platformDir, pattern.settingsFile);
-    if ((0, import_fs33.existsSync)(settingsPath)) {
+    const settingsPath = (0, import_path31.join)(platformDir, pattern.settingsFile);
+    if ((0, import_fs34.existsSync)(settingsPath)) {
       configs.push({
         platform: platform5,
         type: "settings",
         name: pattern.settingsFile,
         path: settingsPath,
-        relativePath: (0, import_path30.relative)(rootDir, settingsPath),
-        sizeBytes: (0, import_fs33.statSync)(settingsPath).size
+        relativePath: (0, import_path31.relative)(rootDir, settingsPath),
+        sizeBytes: (0, import_fs34.statSync)(settingsPath).size
       });
     }
   }
   if (pattern.configFile) {
-    const configPath = (0, import_path30.join)(platformDir, pattern.configFile);
-    if ((0, import_fs33.existsSync)(configPath)) {
+    const configPath = (0, import_path31.join)(platformDir, pattern.configFile);
+    if ((0, import_fs34.existsSync)(configPath)) {
       configs.push({
         platform: platform5,
         type: "settings",
         name: pattern.configFile,
         path: configPath,
-        relativePath: (0, import_path30.relative)(rootDir, configPath),
-        sizeBytes: (0, import_fs33.statSync)(configPath).size
+        relativePath: (0, import_path31.relative)(rootDir, configPath),
+        sizeBytes: (0, import_fs34.statSync)(configPath).size
       });
     }
   }
   if (pattern.rulesDir) {
-    const rulesDir = (0, import_path30.join)(platformDir, pattern.rulesDir);
-    if ((0, import_fs33.existsSync)(rulesDir) && (0, import_fs33.statSync)(rulesDir).isDirectory()) {
+    const rulesDir = (0, import_path31.join)(platformDir, pattern.rulesDir);
+    if ((0, import_fs34.existsSync)(rulesDir) && (0, import_fs34.statSync)(rulesDir).isDirectory()) {
       scanDir(rulesDir, rootDir, platform5, "rules", pattern.ruleExtensions, configs);
     }
   }
   if (pattern.rulesFile) {
-    const rulesPath = (0, import_path30.join)(platformDir, pattern.rulesFile);
-    if ((0, import_fs33.existsSync)(rulesPath)) {
+    const rulesPath = (0, import_path31.join)(platformDir, pattern.rulesFile);
+    if ((0, import_fs34.existsSync)(rulesPath)) {
       configs.push({
         platform: platform5,
         type: "rules",
         name: pattern.rulesFile,
         path: rulesPath,
-        relativePath: (0, import_path30.relative)(rootDir, rulesPath),
-        sizeBytes: (0, import_fs33.statSync)(rulesPath).size
+        relativePath: (0, import_path31.relative)(rootDir, rulesPath),
+        sizeBytes: (0, import_fs34.statSync)(rulesPath).size
       });
     }
   }
   if (pattern.commandsDir) {
-    const commandsDir = (0, import_path30.join)(platformDir, pattern.commandsDir);
-    if ((0, import_fs33.existsSync)(commandsDir) && (0, import_fs33.statSync)(commandsDir).isDirectory()) {
+    const commandsDir = (0, import_path31.join)(platformDir, pattern.commandsDir);
+    if ((0, import_fs34.existsSync)(commandsDir) && (0, import_fs34.statSync)(commandsDir).isDirectory()) {
       scanDir(commandsDir, rootDir, platform5, "commands", [".md", ".toml"], configs);
     }
   }
   if (pattern.hooksDir) {
-    const hooksDir = (0, import_path30.join)(platformDir, pattern.hooksDir);
-    if ((0, import_fs33.existsSync)(hooksDir) && (0, import_fs33.statSync)(hooksDir).isDirectory()) {
+    const hooksDir = (0, import_path31.join)(platformDir, pattern.hooksDir);
+    if ((0, import_fs34.existsSync)(hooksDir) && (0, import_fs34.statSync)(hooksDir).isDirectory()) {
       scanDir(hooksDir, rootDir, platform5, "hooks", [".md", ".json", ".sh", ".ts", ".js"], configs);
     }
   }
   if (pattern.hooksConfigFile) {
-    const hooksConfigPath = (0, import_path30.join)(platformDir, pattern.hooksConfigFile);
-    if ((0, import_fs33.existsSync)(hooksConfigPath)) {
+    const hooksConfigPath = (0, import_path31.join)(platformDir, pattern.hooksConfigFile);
+    if ((0, import_fs34.existsSync)(hooksConfigPath)) {
       configs.push({
         platform: platform5,
         type: "hooks",
         name: pattern.hooksConfigFile,
         path: hooksConfigPath,
-        relativePath: (0, import_path30.relative)(rootDir, hooksConfigPath),
-        sizeBytes: (0, import_fs33.statSync)(hooksConfigPath).size
+        relativePath: (0, import_path31.relative)(rootDir, hooksConfigPath),
+        sizeBytes: (0, import_fs34.statSync)(hooksConfigPath).size
       });
     }
   }
   if (pattern.agentsDir) {
-    const agentsDir = (0, import_path30.join)(platformDir, pattern.agentsDir);
-    if ((0, import_fs33.existsSync)(agentsDir) && (0, import_fs33.statSync)(agentsDir).isDirectory()) {
+    const agentsDir = (0, import_path31.join)(platformDir, pattern.agentsDir);
+    if ((0, import_fs34.existsSync)(agentsDir) && (0, import_fs34.statSync)(agentsDir).isDirectory()) {
       scanDir(agentsDir, rootDir, platform5, "agents", [".md", ".toml", ".agent.md"], configs);
     }
   }
   if (pattern.skillsDir) {
-    const skillsDir = (0, import_path30.join)(platformDir, pattern.skillsDir);
-    if ((0, import_fs33.existsSync)(skillsDir) && (0, import_fs33.statSync)(skillsDir).isDirectory()) {
+    const skillsDir = (0, import_path31.join)(platformDir, pattern.skillsDir);
+    if ((0, import_fs34.existsSync)(skillsDir) && (0, import_fs34.statSync)(skillsDir).isDirectory()) {
       scanDir(skillsDir, rootDir, platform5, "skills", [".md"], configs);
     }
   }
   if (pattern.policiesDir) {
-    const policiesDir = (0, import_path30.join)(platformDir, pattern.policiesDir);
-    if ((0, import_fs33.existsSync)(policiesDir) && (0, import_fs33.statSync)(policiesDir).isDirectory()) {
+    const policiesDir = (0, import_path31.join)(platformDir, pattern.policiesDir);
+    if ((0, import_fs34.existsSync)(policiesDir) && (0, import_fs34.statSync)(policiesDir).isDirectory()) {
       scanDir(policiesDir, rootDir, platform5, "policies", [".toml", ".md"], configs);
     }
   }
   if (pattern.workflowsDir) {
-    const workflowsDir = (0, import_path30.join)(platformDir, pattern.workflowsDir);
-    if ((0, import_fs33.existsSync)(workflowsDir) && (0, import_fs33.statSync)(workflowsDir).isDirectory()) {
+    const workflowsDir = (0, import_path31.join)(platformDir, pattern.workflowsDir);
+    if ((0, import_fs34.existsSync)(workflowsDir) && (0, import_fs34.statSync)(workflowsDir).isDirectory()) {
       scanDir(workflowsDir, rootDir, platform5, "workflows", [".md"], configs);
     }
   }
   if (pattern.promptsDir) {
-    const promptsDir = (0, import_path30.join)(platformDir, pattern.promptsDir);
-    if ((0, import_fs33.existsSync)(promptsDir) && (0, import_fs33.statSync)(promptsDir).isDirectory()) {
+    const promptsDir = (0, import_path31.join)(platformDir, pattern.promptsDir);
+    if ((0, import_fs34.existsSync)(promptsDir) && (0, import_fs34.statSync)(promptsDir).isDirectory()) {
       scanDir(promptsDir, rootDir, platform5, "prompts", [".prompt.md", ".md"], configs);
     }
   }
@@ -48147,59 +48239,59 @@ function scanPlatform(rootDir, pattern) {
   for (const { key, type } of rootInstructionFiles) {
     const fileName = pattern[key];
     if (fileName) {
-      const rootPath = (0, import_path30.join)(rootDir, fileName);
-      const platformPath = (0, import_path30.join)(platformDir, fileName);
-      if ((0, import_fs33.existsSync)(rootPath)) {
+      const rootPath = (0, import_path31.join)(rootDir, fileName);
+      const platformPath = (0, import_path31.join)(platformDir, fileName);
+      if ((0, import_fs34.existsSync)(rootPath)) {
         configs.push({
           platform: platform5,
           type,
           name: fileName,
           path: rootPath,
-          relativePath: (0, import_path30.relative)(rootDir, rootPath),
-          sizeBytes: (0, import_fs33.statSync)(rootPath).size
+          relativePath: (0, import_path31.relative)(rootDir, rootPath),
+          sizeBytes: (0, import_fs34.statSync)(rootPath).size
         });
-      } else if ((0, import_fs33.existsSync)(platformPath) && platformPath !== rootPath) {
+      } else if ((0, import_fs34.existsSync)(platformPath) && platformPath !== rootPath) {
         configs.push({
           platform: platform5,
           type,
           name: fileName,
           path: platformPath,
-          relativePath: (0, import_path30.relative)(rootDir, platformPath),
-          sizeBytes: (0, import_fs33.statSync)(platformPath).size
+          relativePath: (0, import_path31.relative)(rootDir, platformPath),
+          sizeBytes: (0, import_fs34.statSync)(platformPath).size
         });
       }
     }
   }
   if (pattern.mcpFile) {
-    const mcpPath = (0, import_path30.join)(rootDir, pattern.mcpFile);
-    if ((0, import_fs33.existsSync)(mcpPath)) {
+    const mcpPath = (0, import_path31.join)(rootDir, pattern.mcpFile);
+    if ((0, import_fs34.existsSync)(mcpPath)) {
       configs.push({
         platform: platform5,
         type: "mcp",
         name: pattern.mcpFile,
         path: mcpPath,
-        relativePath: (0, import_path30.relative)(rootDir, mcpPath),
-        sizeBytes: (0, import_fs33.statSync)(mcpPath).size
+        relativePath: (0, import_path31.relative)(rootDir, mcpPath),
+        sizeBytes: (0, import_fs34.statSync)(mcpPath).size
       });
     }
   }
   if (pattern.memoryDir) {
-    const memDir = (0, import_path30.join)(platformDir, pattern.memoryDir);
-    if ((0, import_fs33.existsSync)(memDir) && (0, import_fs33.statSync)(memDir).isDirectory()) {
+    const memDir = (0, import_path31.join)(platformDir, pattern.memoryDir);
+    if ((0, import_fs34.existsSync)(memDir) && (0, import_fs34.statSync)(memDir).isDirectory()) {
       const exts = pattern.memoryExtensions || [".md"];
       scanDir(memDir, rootDir, platform5, "memory", exts, configs);
     }
   }
   if (pattern.cliConfigFile) {
-    const cliPath = (0, import_path30.join)(platformDir, pattern.cliConfigFile);
-    if ((0, import_fs33.existsSync)(cliPath)) {
+    const cliPath = (0, import_path31.join)(platformDir, pattern.cliConfigFile);
+    if ((0, import_fs34.existsSync)(cliPath)) {
       configs.push({
         platform: platform5,
         type: "settings",
         name: pattern.cliConfigFile,
         path: cliPath,
-        relativePath: (0, import_path30.relative)(rootDir, cliPath),
-        sizeBytes: (0, import_fs33.statSync)(cliPath).size
+        relativePath: (0, import_path31.relative)(rootDir, cliPath),
+        sizeBytes: (0, import_fs34.statSync)(cliPath).size
       });
     }
   }
@@ -48207,9 +48299,9 @@ function scanPlatform(rootDir, pattern) {
 }
 function scanDir(dir, rootDir, platform5, type, extensions, configs) {
   try {
-    const entries = (0, import_fs33.readdirSync)(dir, { withFileTypes: true });
+    const entries = (0, import_fs34.readdirSync)(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = (0, import_path30.join)(dir, entry.name);
+      const fullPath = (0, import_path31.join)(dir, entry.name);
       if (entry.isDirectory()) {
         scanDir(fullPath, rootDir, platform5, type, extensions, configs);
       } else if (entry.isFile()) {
@@ -48220,8 +48312,8 @@ function scanDir(dir, rootDir, platform5, type, extensions, configs) {
             type,
             name: entry.name,
             path: fullPath,
-            relativePath: (0, import_path30.relative)(rootDir, fullPath),
-            sizeBytes: (0, import_fs33.statSync)(fullPath).size
+            relativePath: (0, import_path31.relative)(rootDir, fullPath),
+            sizeBytes: (0, import_fs34.statSync)(fullPath).size
           });
         }
       }
@@ -48238,7 +48330,7 @@ function createScanCommand() {
   const command = new Command("scan");
   command.description("Scan local directory for AI agent configurations (no auth required)").option("--path <path>", "Directory to scan (default: current directory or project root)").option("-p, --platform <platform>", `Filter by platform (${ALL_PLATFORM_IDS.join(", ")})`).option("--format <format>", "Output format: table (default) or json", "table").option("-r, --recursive", "Scan subdirectories for additional projects").option("--include-global", "Include global/home-directory memory locations").action(async (options) => {
     const targetDir = options.path ? options.path : findProjectRoot(process.cwd());
-    if (!(0, import_fs33.existsSync)(targetDir)) {
+    if (!(0, import_fs34.existsSync)(targetDir)) {
       console.error(source_default.red(`Directory not found: ${targetDir}`));
       process.exit(1);
     }
@@ -48269,12 +48361,12 @@ function createScanCommand() {
       }
     }
     if (options.includeGlobal) {
-      const home = (0, import_os22.homedir)();
+      const home = (0, import_os23.homedir)();
       for (const loc of GLOBAL_MEMORY_LOCATIONS) {
         if (platformFilter && loc.platform !== platformFilter) continue;
         for (const relPath of loc.paths) {
-          const globalDir = (0, import_path30.join)(home, relPath);
-          if (!(0, import_fs33.existsSync)(globalDir) || !(0, import_fs33.statSync)(globalDir).isDirectory()) continue;
+          const globalDir = (0, import_path31.join)(home, relPath);
+          if (!(0, import_fs34.existsSync)(globalDir) || !(0, import_fs34.statSync)(globalDir).isDirectory()) continue;
           const globalConfigs = [];
           scanDir(globalDir, home, loc.platform, "memory", loc.extensions, globalConfigs);
           if (globalConfigs.length > 0) {
@@ -48350,15 +48442,15 @@ function createScanCommand() {
   });
   return command;
 }
-var import_fs33, import_path30, import_os22, GLOBAL_MEMORY_LOCATIONS, PLATFORM_LABELS, PLATFORM_COLORS;
+var import_fs34, import_path31, import_os23, GLOBAL_MEMORY_LOCATIONS, PLATFORM_LABELS, PLATFORM_COLORS;
 var init_scan = __esm({
   "src/commands/scan.ts"() {
     "use strict";
     init_esm();
     init_source();
-    import_fs33 = require("fs");
-    import_path30 = require("path");
-    import_os22 = require("os");
+    import_fs34 = require("fs");
+    import_path31 = require("path");
+    import_os23 = require("os");
     init_dist2();
     init_project_detection();
     GLOBAL_MEMORY_LOCATIONS = [
@@ -49030,8 +49122,8 @@ function createSandboxCommand() {
   return sandboxCmd;
 }
 async function validateConfigFile(sandbox, options) {
-  const configPath = import_path31.default.resolve(options.config);
-  const fileName = import_path31.default.basename(configPath);
+  const configPath = import_path32.default.resolve(options.config);
+  const fileName = import_path32.default.basename(configPath);
   const spinner = ora(`Loading configuration: ${fileName}`).start();
   try {
     const configContent = await import_promises8.default.readFile(configPath, "utf-8");
@@ -49146,7 +49238,7 @@ async function startInteractiveSession(sandbox) {
     rl.on("close", resolve8);
   });
 }
-var import_promises8, import_path31;
+var import_promises8, import_path32;
 var init_sandbox = __esm({
   "src/commands/sandbox.ts"() {
     "use strict";
@@ -49155,7 +49247,7 @@ var init_sandbox = __esm({
     init_ora();
     init_e2b_sandbox();
     import_promises8 = __toESM(require("fs/promises"), 1);
-    import_path31 = __toESM(require("path"), 1);
+    import_path32 = __toESM(require("path"), 1);
   }
 });
 
@@ -49164,7 +49256,7 @@ function isTestFile(filename) {
   return /\.(test|spec)\.(ts|tsx|js|jsx)$/.test(filename);
 }
 function isImplFile(filename) {
-  const ext = (0, import_path32.extname)(filename);
+  const ext = (0, import_path33.extname)(filename);
   if (!IMPL_EXTENSIONS.has(ext)) return false;
   if (isTestFile(filename)) return false;
   if (IGNORE_FILES.has(filename)) return false;
@@ -49179,16 +49271,16 @@ function scanDirectory(dir, maxDepth = 6) {
     if (depth > maxDepth) return;
     let entries;
     try {
-      entries = (0, import_fs34.readdirSync)(currentDir);
+      entries = (0, import_fs35.readdirSync)(currentDir);
     } catch {
       return;
     }
     for (const entry of entries) {
       if (IGNORE_DIRS.has(entry)) continue;
-      const fullPath = (0, import_path32.join)(currentDir, entry);
+      const fullPath = (0, import_path33.join)(currentDir, entry);
       let stat5;
       try {
-        stat5 = (0, import_fs34.statSync)(fullPath);
+        stat5 = (0, import_fs35.statSync)(fullPath);
       } catch {
         continue;
       }
@@ -49198,7 +49290,7 @@ function scanDirectory(dir, maxDepth = 6) {
         }
         walk(fullPath, depth + 1);
       } else if (stat5.isFile()) {
-        const relPath = (0, import_path32.relative)(dir, fullPath);
+        const relPath = (0, import_path33.relative)(dir, fullPath);
         if (isTestFile(entry)) {
           testFiles.push(relPath);
         } else if (isImplFile(entry)) {
@@ -49218,15 +49310,15 @@ function findSpecFiles(dir) {
     if (depth > 4) return;
     let entries;
     try {
-      entries = (0, import_fs34.readdirSync)(currentDir);
+      entries = (0, import_fs35.readdirSync)(currentDir);
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = (0, import_path32.join)(currentDir, entry);
+      const fullPath = (0, import_path33.join)(currentDir, entry);
       let stat5;
       try {
-        stat5 = (0, import_fs34.statSync)(fullPath);
+        stat5 = (0, import_fs35.statSync)(fullPath);
       } catch {
         continue;
       }
@@ -49242,10 +49334,10 @@ function findSpecFiles(dir) {
 }
 function findImplFilesWithoutTests(implFiles, testFiles) {
   const testBasenames = new Set(
-    testFiles.map((f) => (0, import_path32.basename)(f).replace(/\.(test|spec)\.(ts|tsx|js|jsx)$/, ""))
+    testFiles.map((f) => (0, import_path33.basename)(f).replace(/\.(test|spec)\.(ts|tsx|js|jsx)$/, ""))
   );
   return implFiles.filter((f) => {
-    const base = (0, import_path32.basename)(f).replace(/\.(ts|tsx|js|jsx)$/, "");
+    const base = (0, import_path33.basename)(f).replace(/\.(ts|tsx|js|jsx)$/, "");
     return !testBasenames.has(base);
   });
 }
@@ -49275,8 +49367,8 @@ function runChecks(basePath) {
   const weight2 = 25;
   maxScore += weight2;
   const hasSpecs = specFiles.length > 0;
-  const hasClaudeDir = (0, import_fs34.existsSync)((0, import_path32.join)(basePath, ".claude"));
-  const hasSpecsDir = (0, import_fs34.existsSync)((0, import_path32.join)(basePath, "specs"));
+  const hasClaudeDir = (0, import_fs35.existsSync)((0, import_path33.join)(basePath, ".claude"));
+  const hasSpecsDir = (0, import_fs35.existsSync)((0, import_path33.join)(basePath, "specs"));
   let specScore = 0;
   if (hasSpecs) specScore += 15;
   if (hasClaudeDir) specScore += 5;
@@ -49295,8 +49387,8 @@ function runChecks(basePath) {
   }
   const weight3 = 15;
   maxScore += weight3;
-  const hasClaudeMd = (0, import_fs34.existsSync)((0, import_path32.join)(basePath, "CLAUDE.md"));
-  const hasClaudeSettings = (0, import_fs34.existsSync)((0, import_path32.join)(basePath, ".claude", "settings.json"));
+  const hasClaudeMd = (0, import_fs35.existsSync)((0, import_path33.join)(basePath, "CLAUDE.md"));
+  const hasClaudeSettings = (0, import_fs35.existsSync)((0, import_path33.join)(basePath, ".claude", "settings.json"));
   let claudeScore = 0;
   if (hasClaudeMd) claudeScore += 10;
   if (hasClaudeSettings) claudeScore += 5;
@@ -49314,9 +49406,9 @@ function runChecks(basePath) {
   }
   const weight4 = 15;
   maxScore += weight4;
-  const hasPackageJson = (0, import_fs34.existsSync)((0, import_path32.join)(basePath, "package.json"));
-  const hasReadme = (0, import_fs34.existsSync)((0, import_path32.join)(basePath, "README.md"));
-  const hasTsConfig = (0, import_fs34.existsSync)((0, import_path32.join)(basePath, "tsconfig.json"));
+  const hasPackageJson = (0, import_fs35.existsSync)((0, import_path33.join)(basePath, "package.json"));
+  const hasReadme = (0, import_fs35.existsSync)((0, import_path33.join)(basePath, "README.md"));
+  const hasTsConfig = (0, import_fs35.existsSync)((0, import_path33.join)(basePath, "tsconfig.json"));
   let structureScore = 0;
   if (hasPackageJson) structureScore += 5;
   if (hasReadme) structureScore += 5;
@@ -49336,9 +49428,9 @@ function runChecks(basePath) {
   });
   const weight5 = 15;
   maxScore += weight5;
-  const hasGitDir = (0, import_fs34.existsSync)((0, import_path32.join)(basePath, ".git"));
-  const hasGithubDir = (0, import_fs34.existsSync)((0, import_path32.join)(basePath, ".github"));
-  const hasWorkflows = (0, import_fs34.existsSync)((0, import_path32.join)(basePath, ".github", "workflows"));
+  const hasGitDir = (0, import_fs35.existsSync)((0, import_path33.join)(basePath, ".git"));
+  const hasGithubDir = (0, import_fs35.existsSync)((0, import_path33.join)(basePath, ".github"));
+  const hasWorkflows = (0, import_fs35.existsSync)((0, import_path33.join)(basePath, ".github", "workflows"));
   let gitScore = 0;
   if (hasGitDir) gitScore += 5;
   if (hasGithubDir) gitScore += 5;
@@ -49677,8 +49769,8 @@ function createSdlcCommand() {
       spinner.start("Scanning git history and local artifacts...");
       const basePath = process.cwd();
       const SDLC_PHASES_ORDERED = ["specify", "design", "test", "implement", "deploy-verify", "review", "merge"];
-      const hasSpec = (0, import_fs34.existsSync)((0, import_path32.join)(basePath, "spec.md")) || (0, import_fs34.existsSync)((0, import_path32.join)(basePath, "specs")) || (0, import_fs34.existsSync)((0, import_path32.join)(basePath, ".claude", "spec.md"));
-      const hasPlan = (0, import_fs34.existsSync)((0, import_path32.join)(basePath, "plan.md")) || (0, import_fs34.existsSync)((0, import_path32.join)(basePath, ".claude", "plan.md")) || (0, import_fs34.existsSync)((0, import_path32.join)(basePath, "tasks.md"));
+      const hasSpec = (0, import_fs35.existsSync)((0, import_path33.join)(basePath, "spec.md")) || (0, import_fs35.existsSync)((0, import_path33.join)(basePath, "specs")) || (0, import_fs35.existsSync)((0, import_path33.join)(basePath, ".claude", "spec.md"));
+      const hasPlan = (0, import_fs35.existsSync)((0, import_path33.join)(basePath, "plan.md")) || (0, import_fs35.existsSync)((0, import_path33.join)(basePath, ".claude", "plan.md")) || (0, import_fs35.existsSync)((0, import_path33.join)(basePath, "tasks.md"));
       const scanResult = scanDirectory(basePath);
       const hasTests = scanResult.testFiles.length > 0;
       const hasImpl = scanResult.implFiles.length > 0;
@@ -49821,15 +49913,15 @@ function createSdlcCommand() {
   });
   return cmd;
 }
-var import_fs34, import_path32, import_child_process10, IMPL_EXTENSIONS, IGNORE_DIRS, IGNORE_FILES;
+var import_fs35, import_path33, import_child_process10, IMPL_EXTENSIONS, IGNORE_DIRS, IGNORE_FILES;
 var init_sdlc = __esm({
   "src/commands/sdlc.ts"() {
     "use strict";
     init_esm();
     init_source();
     init_ora();
-    import_fs34 = require("fs");
-    import_path32 = require("path");
+    import_fs35 = require("fs");
+    import_path33 = require("path");
     import_child_process10 = require("child_process");
     init_config_manager();
     IMPL_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx"]);
@@ -49948,10 +50040,10 @@ var init_security = __esm({
 
 // src/commands/status.ts
 function readTermsAcceptance() {
-  const configFile = (0, import_path33.join)((0, import_os23.homedir)(), ".gal", "config.json");
+  const configFile = (0, import_path34.join)((0, import_os24.homedir)(), ".gal", "config.json");
   try {
-    if ((0, import_fs35.existsSync)(configFile)) {
-      const raw = JSON.parse((0, import_fs35.readFileSync)(configFile, "utf-8"));
+    if ((0, import_fs36.existsSync)(configFile)) {
+      const raw = JSON.parse((0, import_fs36.readFileSync)(configFile, "utf-8"));
       if (typeof raw.termsAcceptedAt === "string" && raw.termsAcceptedAt.length > 0) {
         return { accepted: true, acceptedAt: raw.termsAcceptedAt };
       }
@@ -50123,7 +50215,7 @@ function displayStatusJson(result, health) {
 }
 function isRateLimited(projectId) {
   try {
-    const raw = (0, import_fs35.readFileSync)(DRIFT_REPORT_CACHE_PATH, "utf-8");
+    const raw = (0, import_fs36.readFileSync)(DRIFT_REPORT_CACHE_PATH, "utf-8");
     const cache = JSON.parse(raw);
     const lastReport = cache[projectId];
     if (lastReport && Date.now() - lastReport < RATE_LIMIT_MS) {
@@ -50137,13 +50229,13 @@ function recordReport(projectId) {
   try {
     let cache = {};
     try {
-      const raw = (0, import_fs35.readFileSync)(DRIFT_REPORT_CACHE_PATH, "utf-8");
+      const raw = (0, import_fs36.readFileSync)(DRIFT_REPORT_CACHE_PATH, "utf-8");
       cache = JSON.parse(raw);
     } catch {
     }
     cache[projectId] = Date.now();
-    (0, import_fs35.mkdirSync)((0, import_path33.join)((0, import_os23.homedir)(), ".gal"), { recursive: true });
-    (0, import_fs35.writeFileSync)(DRIFT_REPORT_CACHE_PATH, JSON.stringify(cache));
+    (0, import_fs36.mkdirSync)((0, import_path34.join)((0, import_os24.homedir)(), ".gal"), { recursive: true });
+    (0, import_fs36.writeFileSync)(DRIFT_REPORT_CACHE_PATH, JSON.stringify(cache));
   } catch {
   }
 }
@@ -50248,16 +50340,16 @@ function createStatusCommand2() {
   });
   return command;
 }
-var import_path33, import_os23, import_fs35, cliVersion6, defaultApiUrl15, PLATFORM_LABELS2, RATE_LIMIT_MS, DRIFT_REPORT_CACHE_PATH;
+var import_path34, import_os24, import_fs36, cliVersion6, defaultApiUrl15, PLATFORM_LABELS2, RATE_LIMIT_MS, DRIFT_REPORT_CACHE_PATH;
 var init_status = __esm({
   "src/commands/status.ts"() {
     "use strict";
     init_esm();
     init_source();
     init_ora();
-    import_path33 = require("path");
-    import_os23 = require("os");
-    import_fs35 = require("fs");
+    import_path34 = require("path");
+    import_os24 = require("os");
+    import_fs36 = require("fs");
     init_gal_config_service();
     init_config_manager();
     init_CoreServiceProvider();
@@ -50273,7 +50365,7 @@ var init_status = __esm({
       ])
     );
     RATE_LIMIT_MS = 5 * 60 * 1e3;
-    DRIFT_REPORT_CACHE_PATH = (0, import_path33.join)((0, import_os23.homedir)(), ".gal", "drift-report-cache.json");
+    DRIFT_REPORT_CACHE_PATH = (0, import_path34.join)((0, import_os24.homedir)(), ".gal", "drift-report-cache.json");
   }
 });
 
@@ -51601,13 +51693,13 @@ function getGitHookManager() {
   }
   return defaultManager;
 }
-var import_child_process11, import_fs36, import_path34, DEFAULT_GIT_HOOK_CONFIG, GitHookManager, defaultManager;
+var import_child_process11, import_fs37, import_path35, DEFAULT_GIT_HOOK_CONFIG, GitHookManager, defaultManager;
 var init_git_hooks = __esm({
   "src/triggers/git-hooks.ts"() {
     "use strict";
     import_child_process11 = require("child_process");
-    import_fs36 = require("fs");
-    import_path34 = require("path");
+    import_fs37 = require("fs");
+    import_path35 = require("path");
     init_source();
     init_triggers();
     DEFAULT_GIT_HOOK_CONFIG = {
@@ -51650,12 +51742,12 @@ var init_git_hooks = __esm({
         if (this.gitDir) return this.gitDir;
         let currentPath = startPath;
         while (currentPath !== "/") {
-          const gitPath = (0, import_path34.join)(currentPath, ".git");
-          if ((0, import_fs36.existsSync)(gitPath)) {
+          const gitPath = (0, import_path35.join)(currentPath, ".git");
+          if ((0, import_fs37.existsSync)(gitPath)) {
             this.gitDir = gitPath;
             return gitPath;
           }
-          currentPath = (0, import_path34.dirname)(currentPath);
+          currentPath = (0, import_path35.dirname)(currentPath);
         }
         return null;
       }
@@ -51677,29 +51769,29 @@ var init_git_hooks = __esm({
             ]
           };
         }
-        const hooksDir = (0, import_path34.join)(gitDir, "hooks");
-        if (!(0, import_fs36.existsSync)(hooksDir)) {
-          (0, import_fs36.mkdirSync)(hooksDir, { recursive: true });
+        const hooksDir = (0, import_path35.join)(gitDir, "hooks");
+        if (!(0, import_fs37.existsSync)(hooksDir)) {
+          (0, import_fs37.mkdirSync)(hooksDir, { recursive: true });
         }
         const installed = [];
         const skipped = [];
         const warnings = [];
         for (const hookType of this.config.hooks) {
-          const hookPath = (0, import_path34.join)(hooksDir, hookType);
+          const hookPath = (0, import_path35.join)(hooksDir, hookType);
           const hookScript = this.generateHookScript(hookType);
-          if ((0, import_fs36.existsSync)(hookPath)) {
-            const existing = (0, import_fs36.readFileSync)(hookPath, "utf-8");
+          if ((0, import_fs37.existsSync)(hookPath)) {
+            const existing = (0, import_fs37.readFileSync)(hookPath, "utf-8");
             if (existing.includes("GAL_HOOK_MARKER")) {
-              (0, import_fs36.writeFileSync)(hookPath, hookScript);
-              (0, import_fs36.chmodSync)(hookPath, "755");
+              (0, import_fs37.writeFileSync)(hookPath, hookScript);
+              (0, import_fs37.chmodSync)(hookPath, "755");
               installed.push(hookType);
             } else {
               console.log(source_default.yellow(`Skipping ${hookType}: existing hook found`));
               skipped.push(hookType);
             }
           } else {
-            (0, import_fs36.writeFileSync)(hookPath, hookScript);
-            (0, import_fs36.chmodSync)(hookPath, "755");
+            (0, import_fs37.writeFileSync)(hookPath, hookScript);
+            (0, import_fs37.chmodSync)(hookPath, "755");
             installed.push(hookType);
           }
         }
@@ -51716,12 +51808,12 @@ var init_git_hooks = __esm({
         if (!gitDir) {
           return [];
         }
-        const hooksDir = (0, import_path34.join)(gitDir, "hooks");
+        const hooksDir = (0, import_path35.join)(gitDir, "hooks");
         const removed = [];
         for (const hookType of this.config.hooks) {
-          const hookPath = (0, import_path34.join)(hooksDir, hookType);
-          if ((0, import_fs36.existsSync)(hookPath)) {
-            const content = (0, import_fs36.readFileSync)(hookPath, "utf-8");
+          const hookPath = (0, import_path35.join)(hooksDir, hookType);
+          if ((0, import_fs37.existsSync)(hookPath)) {
+            const content = (0, import_fs37.readFileSync)(hookPath, "utf-8");
             if (content.includes("GAL_HOOK_MARKER")) {
               const { unlinkSync: unlinkSync6 } = require("fs");
               unlinkSync6(hookPath);
@@ -51944,13 +52036,13 @@ exit 0
         if (!gitDir) {
           return { installed: [], missing: this.config.hooks };
         }
-        const hooksDir = (0, import_path34.join)(gitDir, "hooks");
+        const hooksDir = (0, import_path35.join)(gitDir, "hooks");
         const installed = [];
         const missing = [];
         for (const hookType of this.config.hooks) {
-          const hookPath = (0, import_path34.join)(hooksDir, hookType);
-          if ((0, import_fs36.existsSync)(hookPath)) {
-            const content = (0, import_fs36.readFileSync)(hookPath, "utf-8");
+          const hookPath = (0, import_path35.join)(hooksDir, hookType);
+          if ((0, import_fs37.existsSync)(hookPath)) {
+            const content = (0, import_fs37.readFileSync)(hookPath, "utf-8");
             if (content.includes("GAL_HOOK_MARKER")) {
               installed.push(hookType);
             } else {
@@ -51974,12 +52066,12 @@ function getFileWatcher() {
   }
   return defaultWatcher;
 }
-var import_fs37, import_path35, DEFAULT_FILE_WATCHER_CONFIG, AGENT_CONFIG_PATTERNS, FileWatcher, defaultWatcher;
+var import_fs38, import_path36, DEFAULT_FILE_WATCHER_CONFIG, AGENT_CONFIG_PATTERNS, FileWatcher, defaultWatcher;
 var init_file_watcher = __esm({
   "src/triggers/file-watcher.ts"() {
     "use strict";
-    import_fs37 = require("fs");
-    import_path35 = require("path");
+    import_fs38 = require("fs");
+    import_path36 = require("path");
     init_source();
     init_triggers();
     DEFAULT_FILE_WATCHER_CONFIG = {
@@ -52035,13 +52127,13 @@ var init_file_watcher = __esm({
         const watching = [];
         const notFound = [];
         for (const watchPath of this.config.watchPaths) {
-          const fullPath = (0, import_path35.join)(basePath, watchPath);
-          if (!(0, import_fs37.existsSync)(fullPath)) {
+          const fullPath = (0, import_path36.join)(basePath, watchPath);
+          if (!(0, import_fs38.existsSync)(fullPath)) {
             notFound.push(watchPath);
             continue;
           }
           try {
-            const watcher = (0, import_fs37.watch)(
+            const watcher = (0, import_fs38.watch)(
               fullPath,
               { recursive: this.config.recursive },
               (eventType, filename) => {
@@ -52088,7 +52180,7 @@ var init_file_watcher = __esm({
        * @returns True if the file matches any ignore pattern and should be skipped
        */
       shouldIgnore(filename) {
-        const name = (0, import_path35.basename)(filename);
+        const name = (0, import_path36.basename)(filename);
         for (const pattern of this.config.ignorePatterns) {
           if (pattern.startsWith("*")) {
             if (name.endsWith(pattern.slice(1))) {
@@ -52114,7 +52206,7 @@ var init_file_watcher = __esm({
        * @param filename - The name of the file that changed
        */
       handleFileEvent(eventType, watchPath, filename) {
-        const fullPath = (0, import_path35.join)(watchPath, filename);
+        const fullPath = (0, import_path36.join)(watchPath, filename);
         const debounceKey = `${eventType}:${fullPath}`;
         const existingTimer = this.debounceTimers.get(debounceKey);
         if (existingTimer) {
@@ -52134,13 +52226,13 @@ var init_file_watcher = __esm({
        * @param filename - The name of the file that changed
        */
       async processFileEvent(eventType, watchPath, filename) {
-        const fullPath = (0, import_path35.join)(watchPath, filename);
+        const fullPath = (0, import_path36.join)(watchPath, filename);
         let fsEventType;
         let isDirectory = false;
         let size;
         try {
-          if ((0, import_fs37.existsSync)(fullPath)) {
-            const stats = (0, import_fs37.statSync)(fullPath);
+          if ((0, import_fs38.existsSync)(fullPath)) {
+            const stats = (0, import_fs38.statSync)(fullPath);
             isDirectory = stats.isDirectory();
             size = stats.size;
             fsEventType = eventType === "rename" ? "create" : "modify";
@@ -52285,12 +52377,12 @@ var init_file_watcher = __esm({
           this.config.watchPaths.push(path8);
           return true;
         }
-        const fullPath = (0, import_path35.join)(basePath, path8);
-        if (!(0, import_fs37.existsSync)(fullPath)) {
+        const fullPath = (0, import_path36.join)(basePath, path8);
+        if (!(0, import_fs38.existsSync)(fullPath)) {
           return false;
         }
         try {
-          const watcher = (0, import_fs37.watch)(
+          const watcher = (0, import_fs38.watch)(
             fullPath,
             { recursive: this.config.recursive },
             (eventType, filename) => {
@@ -52603,9 +52695,9 @@ async function confirm(message) {
   });
 }
 function isGalCreatedFile(filePath) {
-  if (!(0, import_fs38.existsSync)(filePath)) return false;
+  if (!(0, import_fs39.existsSync)(filePath)) return false;
   try {
-    const content = (0, import_fs38.readFileSync)(filePath, "utf-8");
+    const content = (0, import_fs39.readFileSync)(filePath, "utf-8");
     const galMarkers = [
       "GAL Config",
       "GAL CLI",
@@ -52625,9 +52717,9 @@ function isGalCreatedFile(filePath) {
   }
 }
 function isNpmInstalledFile(filePath) {
-  if (!(0, import_fs38.existsSync)(filePath)) return false;
+  if (!(0, import_fs39.existsSync)(filePath)) return false;
   try {
-    const content = (0, import_fs38.readFileSync)(filePath, "utf-8");
+    const content = (0, import_fs39.readFileSync)(filePath, "utf-8");
     return content.includes("CURRENT_VERSION =") || content.includes("const CURRENT_VERSION");
   } catch {
     return false;
@@ -52644,15 +52736,15 @@ function detectFileSource(filePath) {
 }
 function detectUserLevelItems(options) {
   const items = [];
-  const claudeDir = (0, import_path36.join)((0, import_os24.homedir)(), ".claude");
-  const claudeHooksDir = (0, import_path36.join)(claudeDir, "hooks");
-  const statusLinesDir = (0, import_path36.join)(claudeDir, "status_lines");
+  const claudeDir = (0, import_path37.join)((0, import_os25.homedir)(), ".claude");
+  const claudeHooksDir = (0, import_path37.join)(claudeDir, "hooks");
+  const statusLinesDir = (0, import_path37.join)(claudeDir, "status_lines");
   const includeNpm = options?.includeNpmInstalled ?? true;
-  if ((0, import_fs38.existsSync)(claudeHooksDir)) {
-    const files = (0, import_fs38.readdirSync)(claudeHooksDir);
+  if ((0, import_fs39.existsSync)(claudeHooksDir)) {
+    const files = (0, import_fs39.readdirSync)(claudeHooksDir);
     for (const file of files) {
       if (file.startsWith("gal-")) {
-        const filePath = (0, import_path36.join)(claudeHooksDir, file);
+        const filePath = (0, import_path37.join)(claudeHooksDir, file);
         const source = detectFileSource(filePath);
         if (!includeNpm && source === "npm") {
           continue;
@@ -52667,11 +52759,11 @@ function detectUserLevelItems(options) {
       }
     }
   }
-  if ((0, import_fs38.existsSync)(statusLinesDir)) {
-    const files = (0, import_fs38.readdirSync)(statusLinesDir);
+  if ((0, import_fs39.existsSync)(statusLinesDir)) {
+    const files = (0, import_fs39.readdirSync)(statusLinesDir);
     for (const file of files) {
       if (file.startsWith("gal-")) {
-        const filePath = (0, import_path36.join)(statusLinesDir, file);
+        const filePath = (0, import_path37.join)(statusLinesDir, file);
         const source = detectFileSource(filePath);
         if (!includeNpm && source === "npm") {
           continue;
@@ -52686,10 +52778,10 @@ function detectUserLevelItems(options) {
       }
     }
   }
-  const claudeSettingsPath = (0, import_path36.join)(claudeDir, "settings.json");
-  if ((0, import_fs38.existsSync)(claudeSettingsPath)) {
+  const claudeSettingsPath = (0, import_path37.join)(claudeDir, "settings.json");
+  if ((0, import_fs39.existsSync)(claudeSettingsPath)) {
     try {
-      const settings = JSON.parse((0, import_fs38.readFileSync)(claudeSettingsPath, "utf-8"));
+      const settings = JSON.parse((0, import_fs39.readFileSync)(claudeSettingsPath, "utf-8"));
       if (settings.hooks?.SessionStart) {
         const hasGalHooks = settings.hooks.SessionStart.some(
           (entry) => entry.hooks?.some(
@@ -52736,14 +52828,14 @@ function detectUserLevelItems(options) {
     } catch {
     }
   }
-  const cursorDir = (0, import_path36.join)((0, import_os24.homedir)(), ".cursor");
-  const cursorHooksDir = (0, import_path36.join)(cursorDir, "hooks");
-  if ((0, import_fs38.existsSync)(cursorHooksDir)) {
-    const files = (0, import_fs38.readdirSync)(cursorHooksDir);
+  const cursorDir = (0, import_path37.join)((0, import_os25.homedir)(), ".cursor");
+  const cursorHooksDir = (0, import_path37.join)(cursorDir, "hooks");
+  if ((0, import_fs39.existsSync)(cursorHooksDir)) {
+    const files = (0, import_fs39.readdirSync)(cursorHooksDir);
     for (const file of files) {
       if (file.startsWith("gal-")) {
         items.push({
-          path: (0, import_path36.join)(cursorHooksDir, file),
+          path: (0, import_path37.join)(cursorHooksDir, file),
           type: "file",
           reason: "GAL hook file for Cursor IDE",
           isGalOwned: true
@@ -52751,10 +52843,10 @@ function detectUserLevelItems(options) {
       }
     }
   }
-  const cursorHooksJsonPath = (0, import_path36.join)(cursorDir, "hooks.json");
-  if ((0, import_fs38.existsSync)(cursorHooksJsonPath)) {
+  const cursorHooksJsonPath = (0, import_path37.join)(cursorDir, "hooks.json");
+  if ((0, import_fs39.existsSync)(cursorHooksJsonPath)) {
     try {
-      const hooksConfig = JSON.parse((0, import_fs38.readFileSync)(cursorHooksJsonPath, "utf-8"));
+      const hooksConfig = JSON.parse((0, import_fs39.readFileSync)(cursorHooksJsonPath, "utf-8"));
       const hookTypes = ["beforeShellExecution", "beforeSubmitPrompt"];
       for (const hookType of hookTypes) {
         if (hooksConfig.hooks?.[hookType]) {
@@ -52780,8 +52872,8 @@ function detectUserLevelItems(options) {
 }
 function detectProjectLevelItems(directory) {
   const items = [];
-  const galDir = (0, import_path36.join)(directory, ".gal");
-  if ((0, import_fs38.existsSync)(galDir)) {
+  const galDir = (0, import_path37.join)(directory, ".gal");
+  if ((0, import_fs39.existsSync)(galDir)) {
     items.push({
       path: galDir,
       type: "directory",
@@ -52789,8 +52881,8 @@ function detectProjectLevelItems(directory) {
       isGalOwned: true
     });
   }
-  const galConfig = (0, import_path36.join)(directory, "gal.config.json");
-  if ((0, import_fs38.existsSync)(galConfig)) {
+  const galConfig = (0, import_path37.join)(directory, "gal.config.json");
+  if ((0, import_fs39.existsSync)(galConfig)) {
     items.push({
       path: galConfig,
       type: "file",
@@ -52799,11 +52891,11 @@ function detectProjectLevelItems(directory) {
     });
   }
   const gitHookPaths = [
-    (0, import_path36.join)(directory, ".git", "hooks", "pre-commit"),
-    (0, import_path36.join)(directory, ".husky", "pre-commit")
+    (0, import_path37.join)(directory, ".git", "hooks", "pre-commit"),
+    (0, import_path37.join)(directory, ".husky", "pre-commit")
   ];
   for (const hookPath of gitHookPaths) {
-    if ((0, import_fs38.existsSync)(hookPath) && isGalCreatedFile(hookPath)) {
+    if ((0, import_fs39.existsSync)(hookPath) && isGalCreatedFile(hookPath)) {
       items.push({
         path: hookPath,
         type: "file",
@@ -52813,18 +52905,18 @@ function detectProjectLevelItems(directory) {
     }
   }
   const setupFiles = [
-    { path: (0, import_path36.join)(directory, "CLAUDE.md"), reason: "GAL-generated CLAUDE.md" },
-    { path: (0, import_path36.join)(directory, ".claude", "settings.json"), reason: "GAL-generated settings" },
-    { path: (0, import_path36.join)(directory, ".claude", "commands", "review.md"), reason: "GAL-generated command" },
-    { path: (0, import_path36.join)(directory, ".claude", "commands", "check.md"), reason: "GAL-generated command" },
-    { path: (0, import_path36.join)(directory, ".github", "workflows", "ci.yml"), reason: "GAL-generated workflow" },
-    { path: (0, import_path36.join)(directory, ".github", "workflows", "pr-governance.yml"), reason: "GAL-generated workflow" },
-    { path: (0, import_path36.join)(directory, ".gitleaks.toml"), reason: "GAL-generated security config" },
-    { path: (0, import_path36.join)(directory, "SECURITY.md"), reason: "GAL-generated security docs" },
-    { path: (0, import_path36.join)(directory, ".env.example"), reason: "GAL-generated env template" }
+    { path: (0, import_path37.join)(directory, "CLAUDE.md"), reason: "GAL-generated CLAUDE.md" },
+    { path: (0, import_path37.join)(directory, ".claude", "settings.json"), reason: "GAL-generated settings" },
+    { path: (0, import_path37.join)(directory, ".claude", "commands", "review.md"), reason: "GAL-generated command" },
+    { path: (0, import_path37.join)(directory, ".claude", "commands", "check.md"), reason: "GAL-generated command" },
+    { path: (0, import_path37.join)(directory, ".github", "workflows", "ci.yml"), reason: "GAL-generated workflow" },
+    { path: (0, import_path37.join)(directory, ".github", "workflows", "pr-governance.yml"), reason: "GAL-generated workflow" },
+    { path: (0, import_path37.join)(directory, ".gitleaks.toml"), reason: "GAL-generated security config" },
+    { path: (0, import_path37.join)(directory, "SECURITY.md"), reason: "GAL-generated security docs" },
+    { path: (0, import_path37.join)(directory, ".env.example"), reason: "GAL-generated env template" }
   ];
   for (const { path: path8, reason } of setupFiles) {
-    if ((0, import_fs38.existsSync)(path8) && isGalCreatedFile(path8)) {
+    if ((0, import_fs39.existsSync)(path8) && isGalCreatedFile(path8)) {
       items.push({
         path: path8,
         type: "file",
@@ -52837,12 +52929,12 @@ function detectProjectLevelItems(directory) {
 }
 function removeGalStatusLineEntry(settingsPath) {
   try {
-    const settings = JSON.parse((0, import_fs38.readFileSync)(settingsPath, "utf-8"));
+    const settings = JSON.parse((0, import_fs39.readFileSync)(settingsPath, "utf-8"));
     if (!settings.statusLine?.command?.includes("gal-")) {
       return false;
     }
     delete settings.statusLine;
-    (0, import_fs38.writeFileSync)(settingsPath, JSON.stringify(settings, null, 2));
+    (0, import_fs39.writeFileSync)(settingsPath, JSON.stringify(settings, null, 2));
     return true;
   } catch {
     return false;
@@ -52850,7 +52942,7 @@ function removeGalStatusLineEntry(settingsPath) {
 }
 function removeGalHookEntries(settingsPath) {
   try {
-    const settings = JSON.parse((0, import_fs38.readFileSync)(settingsPath, "utf-8"));
+    const settings = JSON.parse((0, import_fs39.readFileSync)(settingsPath, "utf-8"));
     let modified = false;
     for (const hookEvent of ["SessionStart", "UserPromptSubmit"]) {
       if (!settings.hooks?.[hookEvent]) continue;
@@ -52873,7 +52965,7 @@ function removeGalHookEntries(settingsPath) {
       delete settings.hooks;
     }
     if (modified) {
-      (0, import_fs38.writeFileSync)(settingsPath, JSON.stringify(settings, null, 2));
+      (0, import_fs39.writeFileSync)(settingsPath, JSON.stringify(settings, null, 2));
       return true;
     }
     return false;
@@ -52883,7 +52975,7 @@ function removeGalHookEntries(settingsPath) {
 }
 function removeGalCursorHookEntries(hooksJsonPath) {
   try {
-    const hooksConfig = JSON.parse((0, import_fs38.readFileSync)(hooksJsonPath, "utf-8"));
+    const hooksConfig = JSON.parse((0, import_fs39.readFileSync)(hooksJsonPath, "utf-8"));
     if (!hooksConfig.hooks) {
       return false;
     }
@@ -52907,7 +52999,7 @@ function removeGalCursorHookEntries(hooksJsonPath) {
       delete hooksConfig.hooks;
     }
     if (modified) {
-      (0, import_fs38.writeFileSync)(hooksJsonPath, JSON.stringify(hooksConfig, null, 2));
+      (0, import_fs39.writeFileSync)(hooksJsonPath, JSON.stringify(hooksConfig, null, 2));
       return true;
     }
     return false;
@@ -52942,10 +53034,10 @@ function performUninstall(items, dryRun) {
           result.skipped.push(`${item.path} (no GAL statusLine found)`);
         }
       } else if (item.type === "directory") {
-        (0, import_fs38.rmSync)(item.path, { recursive: true, force: true });
+        (0, import_fs39.rmSync)(item.path, { recursive: true, force: true });
         result.removed.push(item.path);
       } else {
-        (0, import_fs38.unlinkSync)(item.path);
+        (0, import_fs39.unlinkSync)(item.path);
         result.removed.push(item.path);
       }
     } catch (error2) {
@@ -53041,15 +53133,15 @@ function createUninstallCommand() {
   });
   return command;
 }
-var import_fs38, import_path36, import_os24, import_readline4;
+var import_fs39, import_path37, import_os25, import_readline4;
 var init_uninstall = __esm({
   "src/commands/uninstall.ts"() {
     "use strict";
     init_esm();
     init_source();
-    import_fs38 = require("fs");
-    import_path36 = require("path");
-    import_os24 = require("os");
+    import_fs39 = require("fs");
+    import_path37 = require("path");
+    import_os25 = require("os");
     import_readline4 = require("readline");
   }
 });
@@ -53467,27 +53559,27 @@ function compareVersions2(v1, v2) {
 }
 function acquireLock() {
   try {
-    const galDir = (0, import_path37.join)((0, import_os25.homedir)(), ".gal");
-    if (!(0, import_fs39.existsSync)(galDir)) {
-      (0, import_fs39.mkdirSync)(galDir, { recursive: true });
+    const galDir = (0, import_path38.join)((0, import_os26.homedir)(), ".gal");
+    if (!(0, import_fs40.existsSync)(galDir)) {
+      (0, import_fs40.mkdirSync)(galDir, { recursive: true });
     }
-    if ((0, import_fs39.existsSync)(UPDATE_LOCK_FILE)) {
+    if ((0, import_fs40.existsSync)(UPDATE_LOCK_FILE)) {
       try {
-        const lockContent = (0, import_fs39.readFileSync)(UPDATE_LOCK_FILE, "utf-8");
+        const lockContent = (0, import_fs40.readFileSync)(UPDATE_LOCK_FILE, "utf-8");
         const lockTime = parseInt(lockContent, 10);
         if (Number.isNaN(lockTime) || Date.now() - lockTime > 5 * 60 * 1e3) {
-          (0, import_fs39.unlinkSync)(UPDATE_LOCK_FILE);
+          (0, import_fs40.unlinkSync)(UPDATE_LOCK_FILE);
         } else {
           return false;
         }
       } catch {
         try {
-          (0, import_fs39.unlinkSync)(UPDATE_LOCK_FILE);
+          (0, import_fs40.unlinkSync)(UPDATE_LOCK_FILE);
         } catch {
         }
       }
     }
-    (0, import_fs39.writeFileSync)(UPDATE_LOCK_FILE, String(Date.now()), { flag: "wx" });
+    (0, import_fs40.writeFileSync)(UPDATE_LOCK_FILE, String(Date.now()), { flag: "wx" });
     return true;
   } catch {
     return false;
@@ -53495,8 +53587,8 @@ function acquireLock() {
 }
 function releaseLock() {
   try {
-    if ((0, import_fs39.existsSync)(UPDATE_LOCK_FILE)) {
-      (0, import_fs39.unlinkSync)(UPDATE_LOCK_FILE);
+    if ((0, import_fs40.existsSync)(UPDATE_LOCK_FILE)) {
+      (0, import_fs40.unlinkSync)(UPDATE_LOCK_FILE);
     }
   } catch {
   }
@@ -53607,7 +53699,7 @@ Retry manually with: ${source_default.cyan(installCommand)}`);
   });
   return command;
 }
-var import_https, import_child_process12, import_fs39, import_path37, import_os25, UPDATE_LOCK_FILE, cliVersion7, REGISTRY_URL;
+var import_https, import_child_process12, import_fs40, import_path38, import_os26, UPDATE_LOCK_FILE, cliVersion7, REGISTRY_URL;
 var init_update = __esm({
   "src/commands/update.ts"() {
     "use strict";
@@ -53616,14 +53708,14 @@ var init_update = __esm({
     init_ora();
     import_https = __toESM(require("https"), 1);
     import_child_process12 = require("child_process");
-    import_fs39 = require("fs");
-    import_path37 = require("path");
-    import_os25 = require("os");
+    import_fs40 = require("fs");
+    import_path38 = require("path");
+    import_os26 = require("os");
     init_constants();
     init_path_conflict();
     init_install();
     init_telemetry();
-    UPDATE_LOCK_FILE = (0, import_path37.join)((0, import_os25.homedir)(), ".gal", "update.lock");
+    UPDATE_LOCK_FILE = (0, import_path38.join)((0, import_os26.homedir)(), ".gal", "update.lock");
     cliVersion7 = constants_default[0];
     REGISTRY_URL = getRegistryUrl();
   }
@@ -54131,9 +54223,9 @@ function createWorkflowCommand() {
     const apiUrl = process.env.GAL_API_URL || defaultApiUrl17;
     try {
       const spinner = ora(`Reading ${filePath}...`).start();
-      const absolutePath = import_path38.default.resolve(filePath);
+      const absolutePath = import_path39.default.resolve(filePath);
       const content = await import_promises9.default.readFile(absolutePath, "utf-8");
-      const fileName = import_path38.default.basename(filePath);
+      const fileName = import_path39.default.basename(filePath);
       let type = options.type;
       if (!type) {
         if (fileName.endsWith(".md")) {
@@ -54189,7 +54281,7 @@ function createWorkflowCommand() {
         spinner.fail(source_default.red("No organization found. Please connect GitHub via dashboard or use --org flag"));
         process.exit(1);
       }
-      const dirPath = import_path38.default.resolve(directory);
+      const dirPath = import_path39.default.resolve(directory);
       const files = await import_promises9.default.readdir(dirPath);
       const workflowFiles = files.filter(
         (f) => f.endsWith(".md") || f.includes("hook") && (f.endsWith(".json") || f.endsWith(".py") || f.endsWith(".js"))
@@ -54201,7 +54293,7 @@ function createWorkflowCommand() {
       spinner.text = `Found ${workflowFiles.length} workflow files. Preparing batch test...`;
       const requests = [];
       for (const file of workflowFiles) {
-        const filePath = import_path38.default.join(dirPath, file);
+        const filePath = import_path39.default.join(dirPath, file);
         const content = await import_promises9.default.readFile(filePath, "utf-8");
         const type = file.endsWith(".md") ? "command" : "hook";
         requests.push({
@@ -54299,7 +54391,7 @@ function displayTestResult(result) {
   }
   console.log();
 }
-var import_promises9, import_path38, defaultApiUrl17;
+var import_promises9, import_path39, defaultApiUrl17;
 var init_workflow2 = __esm({
   "src/commands/workflow.ts"() {
     "use strict";
@@ -54307,7 +54399,7 @@ var init_workflow2 = __esm({
     init_source();
     init_ora();
     import_promises9 = __toESM(require("fs/promises"), 1);
-    import_path38 = __toESM(require("path"), 1);
+    import_path39 = __toESM(require("path"), 1);
     init_constants();
     init_client();
     defaultApiUrl17 = constants_default[1];
@@ -54635,11 +54727,11 @@ function getRegistryAuthToken2() {
     return void 0;
   }
   try {
-    const npmrcPath = (0, import_path39.join)((0, import_os26.homedir)(), ".npmrc");
-    if (!(0, import_fs40.existsSync)(npmrcPath)) {
+    const npmrcPath = (0, import_path40.join)((0, import_os27.homedir)(), ".npmrc");
+    if (!(0, import_fs41.existsSync)(npmrcPath)) {
       return void 0;
     }
-    const npmrc = (0, import_fs40.readFileSync)(npmrcPath, "utf-8");
+    const npmrc = (0, import_fs41.readFileSync)(npmrcPath, "utf-8");
     const escapedHost = REGISTRY_HOST.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const match = npmrc.match(
       new RegExp(`^//${escapedHost}/:_authToken=(.+)$`, "m")
@@ -54659,8 +54751,8 @@ function getRegistryAuthToken2() {
 }
 function readUpdateCache() {
   try {
-    if ((0, import_fs40.existsSync)(UPDATE_CACHE_FILE)) {
-      return JSON.parse((0, import_fs40.readFileSync)(UPDATE_CACHE_FILE, "utf-8"));
+    if ((0, import_fs41.existsSync)(UPDATE_CACHE_FILE)) {
+      return JSON.parse((0, import_fs41.readFileSync)(UPDATE_CACHE_FILE, "utf-8"));
     }
   } catch {
   }
@@ -54668,10 +54760,10 @@ function readUpdateCache() {
 }
 function writeUpdateCache(cache) {
   try {
-    if (!(0, import_fs40.existsSync)(UPDATE_CACHE_DIR)) {
-      (0, import_fs40.mkdirSync)(UPDATE_CACHE_DIR, { recursive: true });
+    if (!(0, import_fs41.existsSync)(UPDATE_CACHE_DIR)) {
+      (0, import_fs41.mkdirSync)(UPDATE_CACHE_DIR, { recursive: true });
     }
-    (0, import_fs40.writeFileSync)(UPDATE_CACHE_FILE, JSON.stringify(cache));
+    (0, import_fs41.writeFileSync)(UPDATE_CACHE_FILE, JSON.stringify(cache));
   } catch {
   }
 }
@@ -54809,8 +54901,8 @@ async function checkForUpdates() {
     });
     if (!isUpdateCommand && !isCI && !isAutoUpdateDisabled) {
       try {
-        const lockFile = (0, import_path39.join)((0, import_os26.homedir)(), ".gal", "update.lock");
-        if (!(0, import_fs40.existsSync)(lockFile)) {
+        const lockFile = (0, import_path40.join)((0, import_os27.homedir)(), ".gal", "update.lock");
+        if (!(0, import_fs41.existsSync)(lockFile)) {
           const child = (0, import_child_process13.spawn)("gal", ["update"], {
             detached: true,
             stdio: "ignore",
@@ -54859,9 +54951,9 @@ async function checkForUpdates() {
 function checkPathConflicts() {
   try {
     if (process.env.CI === "true" || process.argv.includes("--json")) return;
-    const CONFLICT_CACHE = (0, import_path39.join)(UPDATE_CACHE_DIR, "path-conflict-cache.json");
-    if ((0, import_fs40.existsSync)(CONFLICT_CACHE)) {
-      const cached = JSON.parse((0, import_fs40.readFileSync)(CONFLICT_CACHE, "utf-8"));
+    const CONFLICT_CACHE = (0, import_path40.join)(UPDATE_CACHE_DIR, "path-conflict-cache.json");
+    if ((0, import_fs41.existsSync)(CONFLICT_CACHE)) {
+      const cached = JSON.parse((0, import_fs41.readFileSync)(CONFLICT_CACHE, "utf-8"));
       if (Date.now() - (cached.lastCheck || 0) < ONE_DAY) {
         if (cached.hasConflict) {
           process.on("exit", () => {
@@ -54875,10 +54967,10 @@ function checkPathConflicts() {
     const conflict = detectPathConflict(cliVersion9);
     const cacheData = { lastCheck: Date.now(), hasConflict: !!conflict };
     try {
-      if (!(0, import_fs40.existsSync)(UPDATE_CACHE_DIR)) {
-        (0, import_fs40.mkdirSync)(UPDATE_CACHE_DIR, { recursive: true });
+      if (!(0, import_fs41.existsSync)(UPDATE_CACHE_DIR)) {
+        (0, import_fs41.mkdirSync)(UPDATE_CACHE_DIR, { recursive: true });
       }
-      (0, import_fs40.writeFileSync)(CONFLICT_CACHE, JSON.stringify(cacheData));
+      (0, import_fs41.writeFileSync)(CONFLICT_CACHE, JSON.stringify(cacheData));
     } catch {
     }
     if (conflict) {
@@ -54891,9 +54983,9 @@ function checkPathConflicts() {
 }
 function refreshOrgMemberships() {
   try {
-    const configPath = (0, import_path39.join)((0, import_os26.homedir)(), ".gal", "config.json");
-    if (!(0, import_fs40.existsSync)(configPath)) return;
-    const config = JSON.parse((0, import_fs40.readFileSync)(configPath, "utf-8"));
+    const configPath = (0, import_path40.join)((0, import_os27.homedir)(), ".gal", "config.json");
+    if (!(0, import_fs41.existsSync)(configPath)) return;
+    const config = JSON.parse((0, import_fs41.readFileSync)(configPath, "utf-8"));
     if (!config.authToken) return;
     const checkedAt = config.orgMembershipsCheckedAt || 0;
     if (Date.now() - checkedAt < ONE_DAY) return;
@@ -54925,10 +55017,10 @@ function refreshOrgMemberships() {
                 config.capabilities = user.capabilities;
                 config.capabilitiesCachedAt = Date.now();
               }
-              if (!(0, import_fs40.existsSync)(UPDATE_CACHE_DIR)) {
-                (0, import_fs40.mkdirSync)(UPDATE_CACHE_DIR, { recursive: true });
+              if (!(0, import_fs41.existsSync)(UPDATE_CACHE_DIR)) {
+                (0, import_fs41.mkdirSync)(UPDATE_CACHE_DIR, { recursive: true });
               }
-              (0, import_fs40.writeFileSync)(configPath, JSON.stringify(config, null, 2));
+              (0, import_fs41.writeFileSync)(configPath, JSON.stringify(config, null, 2));
             }
           } catch {
           }
@@ -54955,11 +55047,11 @@ function refreshOrgMemberships() {
             if (res.statusCode !== 200) return;
             const flags = JSON.parse(data);
             if (flags.orgAudienceTierMap) {
-              const freshConfig = JSON.parse((0, import_fs40.readFileSync)(configPath, "utf-8"));
+              const freshConfig = JSON.parse((0, import_fs41.readFileSync)(configPath, "utf-8"));
               freshConfig.orgAudienceTierMap = flags.orgAudienceTierMap;
               freshConfig.orgPlanMap = flags.orgPlanMap || freshConfig.orgPlanMap || {};
               freshConfig.flagsCachedAt = Date.now();
-              (0, import_fs40.writeFileSync)(configPath, JSON.stringify(freshConfig, null, 2));
+              (0, import_fs41.writeFileSync)(configPath, JSON.stringify(freshConfig, null, 2));
             }
           } catch {
           }
@@ -54978,7 +55070,7 @@ function refreshOrgMemberships() {
   } catch {
   }
 }
-var import_dotenv, import_https2, import_readline5, import_child_process13, import_fs40, import_path39, import_os26, originalEmit, GLOBAL_TIMEOUT_MS, globalTimeout, cliVersion9, UPDATE_CACHE_DIR, UPDATE_CACHE_FILE, ONE_DAY, REGISTRY_URL2, REGISTRY_HOST, sessionStartTime, isReadOnlyStatusCommand, isMachineMode, exitHooksRan, featureFlags, knownCommands, isKnownCommand, program2, allInternalFlags;
+var import_dotenv, import_https2, import_readline5, import_child_process13, import_fs41, import_path40, import_os27, originalEmit, GLOBAL_TIMEOUT_MS, globalTimeout, cliVersion9, UPDATE_CACHE_DIR, UPDATE_CACHE_FILE, ONE_DAY, REGISTRY_URL2, REGISTRY_HOST, sessionStartTime, isReadOnlyStatusCommand, isMachineMode, exitHooksRan, featureFlags, knownCommands, isKnownCommand, program2, allInternalFlags;
 var init_index = __esm({
   "src/index.ts"() {
     "use strict";
@@ -54987,9 +55079,9 @@ var init_index = __esm({
     import_https2 = __toESM(require("https"), 1);
     import_readline5 = __toESM(require("readline"), 1);
     import_child_process13 = require("child_process");
-    import_fs40 = require("fs");
-    import_path39 = require("path");
-    import_os26 = require("os");
+    import_fs41 = require("fs");
+    import_path40 = require("path");
+    import_os27 = require("os");
     init_source();
     init_constants();
     init_sentry2();
@@ -55019,8 +55111,8 @@ var init_index = __esm({
     }, GLOBAL_TIMEOUT_MS);
     globalTimeout.unref();
     cliVersion9 = constants_default[0];
-    UPDATE_CACHE_DIR = (0, import_path39.join)((0, import_os26.homedir)(), ".gal");
-    UPDATE_CACHE_FILE = (0, import_path39.join)(UPDATE_CACHE_DIR, "update-cache.json");
+    UPDATE_CACHE_DIR = (0, import_path40.join)((0, import_os27.homedir)(), ".gal");
+    UPDATE_CACHE_FILE = (0, import_path40.join)(UPDATE_CACHE_DIR, "update-cache.json");
     ONE_DAY = 24 * 60 * 60 * 1e3;
     REGISTRY_URL2 = (() => {
       const raw = process.env.GAL_REGISTRY_URL || "https://registry.npmjs.org";
@@ -55167,7 +55259,7 @@ var init_index = __esm({
 });
 
 // src/bootstrap.ts
-var cliVersion10 = true ? "0.0.337" : "0.0.0-dev";
+var cliVersion10 = true ? "0.0.338" : "0.0.0-dev";
 var args = process.argv.slice(2);
 var requestedGlobalHelp = args.length === 1 && (args[0] === "--help" || args[0] === "-h");
 var requestedVersion = args.length === 1 && (args[0] === "--version" || args[0] === "-V");