feat(settings): leave environments that can't store a setting out of its row

apps/server/src/environment/ServerEnvironment.test.ts

@@ -215,6 +215,7 @@ it.layer(NodeServices.layer)("ServerEnvironmentLive", (it) => {
       expect(second.capabilities.attachmentUploads).toBe(true);
       expect(second.capabilities.fileAttachments).toEqual({ maxUploadBytes: 50 * 1024 * 1024 });
       expect(second.capabilities.pullRequests).toBe(true);
+      expect(second.capabilities.settingsKeys).toContain("reviewGuidesEnabled");
       expect(second.capabilities.requiredWorktreeBootstrap).toBe(true);
       expect(second.capabilities.usagePriceOverrides).toBe(true);
       expect(second.capabilities.threadActiveReorder).toBe(true);

apps/server/src/environment/ServerEnvironment.ts

@@ -2,6 +2,7 @@ import {
   EnvironmentId,
   ORCHESTRATION_PROTOCOL_VERSION,
   PROVIDER_SEND_TURN_MAX_FILE_BYTES,
+  ServerSettings,
   type ExecutionEnvironmentDescriptor,
 } from "@t3tools/contracts";
 import * as HostProcess from "@t3tools/shared/HostProcess";
@@ -253,6 +254,7 @@ export const make = Effect.gen(function* () {
       serverResolvedCommandContext: true,
       environmentIcon: true,
       projectCloneTracking: true,
+      settingsKeys: Object.keys(ServerSettings.fields),
       ...(serverSelfUpdate === null ? {} : { serverSelfUpdate }),
       ...(serverInstallation === null ? {} : { serverInstallation }),
       // V2 restart recovery uses the environment-owned opt-in. The old

apps/web/src/components/settings/SettingInheritance.tsx

@@ -195,6 +195,7 @@ export function SettingInheritance({
         target,
         environment: { ...environment, serverConfig: environment.serverConfig },
         machine: resolveEnvironmentMachineKind(environment.serverConfig),
+        unsupported: target.unsupportedSettingKeys?.has(key) === true,
         layers: settingInheritanceLayers(target, environment.serverConfig.settings, key),
       },
     ];
@@ -227,7 +228,7 @@ export function SettingInheritance({
       </Tooltip>
       <PopoverPopup align="start" width="md" padding="none">
         <div className="divide-y divide-border/60">
-          {chains.map(({ target, environment, machine, layers }) => (
+          {chains.map(({ target, environment, machine, unsupported, layers }) => (
             <section
               key={`${target.environmentId}:${target.projectId ?? ""}`}
               className="px-3 py-2.5"
@@ -236,43 +237,49 @@ export function SettingInheritance({
                 <EnvironmentMachineIcon aria-hidden kind={machine} className="size-3.5 shrink-0" />
                 <span className="min-w-0 truncate">{target.label}</span>
               </h4>
-              <ol role="list" className="text-sm">
-                {layers.map((layer) => (
-                  <li
-                    key={layer.key}
-                    className={cn(
-                      "grid grid-cols-[minmax(0,1fr)_auto] items-center gap-x-3 rounded-md px-2 py-1",
-                      layer.effective && "bg-foreground/[0.06]",
-                    )}
-                  >
-                    <span
+              {unsupported ? (
+                <p className="px-2 py-1 text-sm text-muted-foreground">
+                  Not supported. Update T3 Code on this environment to use this setting.
+                </p>
+              ) : (
+                <ol role="list" className="text-sm">
+                  {layers.map((layer) => (
+                    <li
+                      key={layer.key}
                       className={cn(
-                        "min-w-0 truncate",
-                        layer.effective ? "font-medium text-foreground" : "text-muted-foreground",
+                        "grid grid-cols-[minmax(0,1fr)_auto] items-center gap-x-3 rounded-md px-2 py-1",
+                        layer.effective && "bg-foreground/[0.06]",
                       )}
                     >
-                      {layer.key === "environment" ? "Environment" : layer.label}
-                    </span>
-                    <span
-                      className={cn(
-                        "flex items-center gap-1.5 tabular-nums",
-                        layer.effective
-                          ? "text-foreground"
-                          : layer.set
-                            ? "text-muted-foreground"
-                            : "text-muted-foreground/60",
-                      )}
-                    >
-                      <span className="max-w-32 truncate">{layer.value}</span>
-                      {layer.effective ? (
-                        <CheckIcon aria-hidden className="size-3.5 shrink-0 text-primary" />
-                      ) : (
-                        <span aria-hidden className="size-3.5 shrink-0" />
-                      )}
-                    </span>
-                  </li>
-                ))}
-              </ol>
+                      <span
+                        className={cn(
+                          "min-w-0 truncate",
+                          layer.effective ? "font-medium text-foreground" : "text-muted-foreground",
+                        )}
+                      >
+                        {layer.key === "environment" ? "Environment" : layer.label}
+                      </span>
+                      <span
+                        className={cn(
+                          "flex items-center gap-1.5 tabular-nums",
+                          layer.effective
+                            ? "text-foreground"
+                            : layer.set
+                              ? "text-muted-foreground"
+                              : "text-muted-foreground/60",
+                        )}
+                      >
+                        <span className="max-w-32 truncate">{layer.value}</span>
+                        {layer.effective ? (
+                          <CheckIcon aria-hidden className="size-3.5 shrink-0 text-primary" />
+                        ) : (
+                          <span aria-hidden className="size-3.5 shrink-0" />
+                        )}
+                      </span>
+                    </li>
+                  ))}
+                </ol>
+              )}
               {(() => {
                 const overriding = overridingProjects.filter(
                   (project) => project.environmentId === target.environmentId,

apps/web/src/components/settings/SettingsScopeContext.tsx

@@ -8,7 +8,12 @@ import { createContext, type ReactNode, useContext, useMemo } from "react";
 import { useEnvironments, usePrimaryEnvironmentId } from "../../state/environments";
 import { getProjectFileQueryAtom, optimisticFileAtom } from "../files/projectFilesQueryState";
 import { useSettingsProjectGroups } from "./useSettingsProjectGroups";
-import { resolveScopedSettingsTargets, selectScopedSettingsEnvironments } from "./scopedSettings";
+import { droppedSettingKeysAtom, droppedSettingKeysFor } from "./droppedSettingKeys";
+import {
+  resolveScopedSettingsTargets,
+  resolveUnsupportedSettingKeys,
+  selectScopedSettingsEnvironments,
+} from "./scopedSettings";
 import { resolveSettingsScope, type SettingsScopeSearch } from "./settingsScope";
 import { selectSingleEnvironmentScope } from "./settingsScopeAxis";
 
@@ -56,7 +61,22 @@ function useMemberProjectFiles(scope: ReturnType<typeof resolveSettingsScope>) {
 
 function useResolvedSettingsScope(rawSearch: SettingsScopeSearch, singleEnvironment: boolean) {
   const groups = useSettingsProjectGroups();
-  const { environments: availableEnvironments } = useEnvironments();
+  const { environments } = useEnvironments();
+  const dropped = useAtomValue(droppedSettingKeysAtom);
+  const availableEnvironments = useMemo(
+    () =>
+      environments.map((environment) => {
+        const descriptor = environment.serverConfig?.environment;
+        const unsupportedSettingKeys = resolveUnsupportedSettingKeys(
+          descriptor?.capabilities.settingsKeys,
+          droppedSettingKeysFor(dropped, environment.environmentId, descriptor?.serverVersion),
+        );
+        return unsupportedSettingKeys.size === 0
+          ? environment
+          : { ...environment, unsupportedSettingKeys };
+      }),
+    [dropped, environments],
+  );
   const primaryEnvironmentId = usePrimaryEnvironmentId();
   const search = useMemo(
     () =>

apps/web/src/components/settings/droppedSettingKeys.ts

@@ -0,0 +1,45 @@
+import type { EnvironmentId } from "@t3tools/contracts";
+import { Atom } from "effect/reactivity";
+
+import { appAtomRegistry } from "../../rpc/atomRegistry";
+
+interface DroppedSettingKeys {
+  readonly serverVersion: string;
+  readonly keys: ReadonlySet<string>;
+}
+
+/**
+ * Setting keys each environment dropped on a save this session, for servers
+ * too old to list the keys they store. Tagged with the server version, so an
+ * update clears them.
+ */
+export const droppedSettingKeysAtom = Atom.make<ReadonlyMap<EnvironmentId, DroppedSettingKeys>>(
+  new Map(),
+).pipe(Atom.keepAlive, Atom.withLabel("settings:dropped-setting-keys"));
+
+export function recordDroppedSettingKeys(
+  environmentId: EnvironmentId,
+  serverVersion: string,
+  keys: readonly string[],
+) {
+  if (keys.length === 0) return;
+  appAtomRegistry.update(droppedSettingKeysAtom, (current) => {
+    const existing = current.get(environmentId);
+    const next = new Map(current);
+    next.set(environmentId, {
+      serverVersion,
+      keys: new Set([...(existing?.serverVersion === serverVersion ? existing.keys : []), ...keys]),
+    });
+    return next;
+  });
+}
+
+/** The keys an environment dropped, if it still runs the version that dropped them. */
+export function droppedSettingKeysFor(
+  dropped: ReadonlyMap<EnvironmentId, DroppedSettingKeys>,
+  environmentId: EnvironmentId,
+  serverVersion: string | undefined,
+): ReadonlySet<string> | undefined {
+  const entry = dropped.get(environmentId);
+  return entry && entry.serverVersion === serverVersion ? entry.keys : undefined;
+}