Make server settings authoritative for runtime behavior

apps/server/integration/OrchestrationEngineHarness.integration.ts

@@ -67,6 +67,7 @@
   type TestProviderAdapterHarness,
 } from "./TestProviderAdapter.integration.ts";
 import { deriveServerPaths, ServerConfig } from "../src/config.ts";
+import { ServerSettingsService } from "../src/serverSettings.ts";
 
 function runGit(cwd: string, args: ReadonlyArray<string>) {
   return execFileSync("git", args, {
@@ -138,7 +139,7 @@
       while: (error) => error === RETRY_SIGNAL,
     }),
     Effect.mapError((error) =>
       error === RETRY_SIGNAL ? new WaitForTimeoutError({ description }) : error,
     ),
     Effect.orDie,
   );
@@ -295,8 +296,10 @@
       providerLayer,
       RuntimeReceiptBusLive,
     );
+    const serverSettingsLayer = ServerSettingsService.layerTest();
     const runtimeIngestionLayer = ProviderRuntimeIngestionLive.pipe(
       Layer.provideMerge(runtimeServicesLayer),
+      Layer.provideMerge(serverSettingsLayer),
     );
     const gitCoreLayer = Layer.succeed(GitCore, {
       renameBranch: (input: Parameters<GitCoreShape["renameBranch"]>[0]) =>
@@ -309,6 +312,7 @@
       Layer.provideMerge(runtimeServicesLayer),
       Layer.provideMerge(gitCoreLayer),
       Layer.provideMerge(textGenerationLayer),
+      Layer.provideMerge(serverSettingsLayer),
     );
     const checkpointReactorLayer = CheckpointReactorLive.pipe(
       Layer.provideMerge(runtimeServicesLayer),

apps/server/src/codexAppServerManager.ts

@@ -542,7 +542,7 @@ export class CodexAppServerManager extends EventEmitter<CodexAppServerManagerEve
       };
 
       const codexOptions = readCodexProviderOptions(input);
-      const codexBinaryPath = codexOptions.binaryPath ?? "codex";
+      const codexBinaryPath = codexOptions.binaryPath || "codex";
       const codexHomePath = codexOptions.homePath;
       this.assertSupportedCodexCliVersion({
         binaryPath: codexBinaryPath,

apps/server/src/config.ts

@@ -19,6 +19,7 @@ export interface ServerDerivedPaths {
   readonly stateDir: string;
   readonly dbPath: string;
   readonly keybindingsConfigPath: string;
+  readonly settingsPath: string;
   readonly worktreesDir: string;
   readonly attachmentsDir: string;
   readonly logsDir: string;
@@ -60,6 +61,7 @@ export const deriveServerPaths = Effect.fn(function* (
     stateDir,
     dbPath,
     keybindingsConfigPath: join(stateDir, "keybindings.json"),
+    settingsPath: join(stateDir, "settings.json"),
     worktreesDir: join(baseDir, "worktrees"),
     attachmentsDir,
     logsDir,

apps/server/src/git/Layers/ClaudeTextGeneration.test.ts

@@ -6,8 +6,10 @@ import { expect } from "vitest";
 import { ServerConfig } from "../../config.ts";
 import { TextGeneration } from "../Services/TextGeneration.ts";
 import { ClaudeTextGenerationLive } from "./ClaudeTextGeneration.ts";
+import { ServerSettingsService } from "../../serverSettings.ts";
 
 const ClaudeTextGenerationTestLayer = ClaudeTextGenerationLive.pipe(
+  Layer.provideMerge(ServerSettingsService.layerTest()),
   Layer.provideMerge(
     ServerConfig.layerTest(process.cwd(), {
       prefix: "t3code-claude-text-generation-test-",

apps/server/src/git/Layers/ClaudeTextGeneration.ts

@@ -27,6 +27,7 @@ import {
   sanitizePrTitle,
   toJsonSchemaObject,
 } from "../Utils.ts";
+import { ServerSettingsService } from "../../serverSettings.ts";
 
 const CLAUDE_TIMEOUT_MS = 180_000;
 
@@ -40,6 +41,7 @@ const ClaudeOutputEnvelope = Schema.Struct({
 
 const makeClaudeTextGeneration = Effect.gen(function* () {
   const commandSpawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+  const serverSettingsService = yield* Effect.service(ServerSettingsService);
 
   const readStreamAsString = <E>(
     operation: string,
@@ -86,9 +88,14 @@ const makeClaudeTextGeneration = Effect.gen(function* () {
         ...(normalizedOptions?.fastMode ? { fastMode: true } : {}),
       };
 
+      const claudeSettings = yield* Effect.map(
+        serverSettingsService.getSettings,
+        (settings) => settings.providers.claudeAgent,
+      ).pipe(Effect.catch(() => Effect.undefined));
+
       const runClaudeCommand = Effect.gen(function* () {
         const command = ChildProcess.make(
-          "claude",
+          claudeSettings?.binaryPath || "claude",
           [
             "-p",
             "--output-format",

apps/server/src/git/Layers/CodexTextGeneration.test.ts

@@ -7,13 +7,15 @@ import { ServerConfig } from "../../config.ts";
 import { CodexTextGenerationLive } from "./CodexTextGeneration.ts";
 import { TextGenerationError } from "../Errors.ts";
 import { TextGeneration } from "../Services/TextGeneration.ts";
+import { ServerSettingsService } from "../../serverSettings.ts";
 
 const DEFAULT_TEST_MODEL_SELECTION = {
   provider: "codex" as const,
   model: "gpt-5.4-mini",
 };
 
 const CodexTextGenerationTestLayer = CodexTextGenerationLive.pipe(
+  Layer.provideMerge(ServerSettingsService.layerTest()),
   Layer.provideMerge(
     ServerConfig.layerTest(process.cwd(), {
       prefix: "t3code-codex-text-generation-test-",

apps/server/src/git/Layers/CodexTextGeneration.ts

@@ -26,6 +26,7 @@ import {
   sanitizePrTitle,
   toJsonSchemaObject,
 } from "../Utils.ts";
+import { ServerSettingsService } from "../../serverSettings.ts";
 
 const CODEX_GIT_TEXT_GENERATION_REASONING_EFFORT = "low";
 const CODEX_TIMEOUT_MS = 180_000;
@@ -35,6 +36,7 @@ const makeCodexTextGeneration = Effect.gen(function* () {
   const path = yield* Path.Path;
   const commandSpawner = yield* ChildProcessSpawner.ChildProcessSpawner;
   const serverConfig = yield* Effect.service(ServerConfig);
+  const serverSettingsService = yield* Effect.service(ServerSettingsService);
 
   type MaterializedImageAttachments = {
     readonly imagePaths: ReadonlyArray<string>;
@@ -138,6 +140,11 @@ const makeCodexTextGeneration = Effect.gen(function* () {
       );
       const outputPath = yield* writeTempFile(operation, "codex-output", "");
 
+      const codexSettings = yield* Effect.map(
+        serverSettingsService.getSettings,
+        (settings) => settings.providers.codex,
+      ).pipe(Effect.catch(() => Effect.undefined));
+
       const runCodexCommand = Effect.gen(function* () {
         const normalizedOptions = normalizeCodexModelOptions(
           modelSelection.model,
@@ -146,7 +153,7 @@ const makeCodexTextGeneration = Effect.gen(function* () {
         const reasoningEffort =
           modelSelection.options?.reasoningEffort ?? CODEX_GIT_TEXT_GENERATION_REASONING_EFFORT;
         const command = ChildProcess.make(
-          "codex",
+          codexSettings?.binaryPath || "codex",
           [
             "exec",
             "--ephemeral",
@@ -165,6 +172,7 @@ const makeCodexTextGeneration = Effect.gen(function* () {
             "-",
           ],
           {
+            env: codexSettings?.homePath ? { CODEX_HOME: codexSettings.homePath } : {},
             cwd,
             shell: process.platform === "win32",
             stdin: {

apps/server/src/git/Layers/GitManager.test.ts

@@ -20,11 +20,7 @@ import { GitCoreLive } from "./GitCore.ts";
 import { GitCore } from "../Services/GitCore.ts";
 import { makeGitManager } from "./GitManager.ts";
 import { ServerConfig } from "../../config.ts";
-
-const DEFAULT_TEST_MODEL_SELECTION = {
-  provider: "codex",
-  model: "gpt-5.4-mini",
-} as const;
+import { ServerSettingsService } from "../../serverSettings.ts";
 
 interface FakeGhScenario {
   prListSequence?: string[];
@@ -466,7 +462,6 @@ function runStackedAction(
     {
       ...input,
       actionId: input.actionId ?? "test-action-id",
-      modelSelection: DEFAULT_TEST_MODEL_SELECTION,
     },
     options,
   );
@@ -493,6 +488,8 @@ function makeManager(input?: {
     prefix: "t3-git-manager-test-",
   });
 
+  const serverSettingsLayer = ServerSettingsService.layerTest();
+
   const gitCoreLayer = GitCoreLive.pipe(
     Layer.provideMerge(NodeServices.layer),
     Layer.provideMerge(ServerConfigLayer),
@@ -502,6 +499,7 @@ function makeManager(input?: {
     Layer.succeed(GitHubCli, gitHubCli),
     Layer.succeed(TextGeneration, textGeneration),
     gitCoreLayer,
+    serverSettingsLayer,
   ).pipe(Layer.provideMerge(NodeServices.layer));
 
   return makeGitManager.pipe(

apps/server/src/git/Layers/GitManager.ts

@@ -19,6 +19,7 @@ import {
 import { GitCore } from "../Services/GitCore.ts";
 import { GitHubCli } from "../Services/GitHubCli.ts";
 import { TextGeneration } from "../Services/TextGeneration.ts";
+import { ServerSettingsService } from "../../serverSettings.ts";
 
 const COMMIT_TIMEOUT_MS = 10 * 60_000;
 const MAX_PROGRESS_TEXT_LENGTH = 500;
@@ -358,6 +359,7 @@ export const makeGitManager = Effect.gen(function* () {
   const gitCore = yield* GitCore;
   const gitHubCli = yield* GitHubCli;
   const textGeneration = yield* TextGeneration;
+  const serverSettingsService = yield* ServerSettingsService;
 
   const createProgressEmitter = (
     input: { cwd: string; action: "commit" | "commit_push" | "commit_push_pr" },
@@ -1173,6 +1175,13 @@ export const makeGitManager = Effect.gen(function* () {
         let commitMessageForStep = input.commitMessage;
         let preResolvedCommitSuggestion: CommitAndBranchSuggestion | undefined = undefined;
 
+        const modelSelection = yield* serverSettingsService.getSettings.pipe(
+          Effect.map((settings) => settings.textGenerationModelSelection),
+          Effect.mapError((cause) =>
+            gitManagerError("runStackedAction", "Failed to get server settings.", cause),
+          ),
+        );
+
         if (input.featureBranch) {
           currentPhase = "branch";
           yield* progress.emit({
@@ -1181,7 +1190,7 @@ export const makeGitManager = Effect.gen(function* () {
             label: "Preparing feature branch...",
           });
           const result = yield* runFeatureBranchStep(
-            input.modelSelection,
+            modelSelection,
             input.cwd,
             initialStatus.branch,
             input.commitMessage,
@@ -1198,7 +1207,7 @@ export const makeGitManager = Effect.gen(function* () {
 
         currentPhase = "commit";
         const commit = yield* runCommitStep(
-          input.modelSelection,
+          modelSelection,
           input.cwd,
           input.action,
           currentBranch,
@@ -1237,7 +1246,7 @@ export const makeGitManager = Effect.gen(function* () {
                 Effect.flatMap(() =>
                   Effect.gen(function* () {
                     currentPhase = "pr";
-                    return yield* runPrStep(input.modelSelection, input.cwd, currentBranch);
+                    return yield* runPrStep(modelSelection, input.cwd, currentBranch);
                   }),
                 ),
               )

apps/server/src/keybindings.ts

@@ -23,6 +23,7 @@ import {
   Cache,
   Cause,
   Deferred,
+  Duration,
   Effect,
   Exit,
   FileSystem,
@@ -42,6 +43,7 @@ import {
 } from "effect";
 import * as Semaphore from "effect/Semaphore";
 import { ServerConfig } from "./config";
+import { fromLenientJson } from "@t3tools/shared/schemaJson";
 
 export class KeybindingsConfigError extends Schema.TaggedErrorClass<KeybindingsConfigError>()(
   "KeybindingsConfigParseError",
@@ -408,7 +410,7 @@ function encodeWhenAst(node: KeybindingWhenNode): string {
 
 const DEFAULT_RESOLVED_KEYBINDINGS = compileResolvedKeybindingsConfig(DEFAULT_KEYBINDINGS);
 
-const RawKeybindingsEntries = Schema.fromJsonString(Schema.Array(Schema.Unknown));
+const RawKeybindingsEntries = fromLenientJson(Schema.Array(Schema.Unknown));
 const KeybindingsConfigJson = Schema.fromJsonString(KeybindingsConfig);
 const PrettyJsonString = SchemaGetter.parseJson<string>().compose(
   SchemaGetter.stringifyJson({ space: 2 }),
@@ -817,16 +819,25 @@ const makeKeybindings = Effect.gen(function* () {
 
     const revalidateAndEmitSafely = revalidateAndEmit.pipe(Effect.ignoreCause({ log: true }));
 
-    yield* Stream.runForEach(fs.watch(keybindingsConfigDir), (event) => {
-      const isTargetConfigEvent =
-        event.path === keybindingsConfigFile ||
-        event.path === keybindingsConfigPath ||
-        path.resolve(keybindingsConfigDir, event.path) === keybindingsConfigPathResolved;
-      if (!isTargetConfigEvent) {
-        return Effect.void;
-      }
-      return revalidateAndEmitSafely;
-    }).pipe(Effect.ignoreCause({ log: true }), Effect.forkIn(watcherScope), Effect.asVoid);
+    // Debounce watch events so the file is fully written before we read it.
+    // Editors emit multiple events per save (truncate, write, rename) and
+    // `fs.watch` can fire before the content has been flushed to disk.
+    const debouncedKeybindingsEvents = fs.watch(keybindingsConfigDir).pipe(
+      Stream.filter((event) => {
+        return (
+          event.path === keybindingsConfigFile ||
+          event.path === keybindingsConfigPath ||
+          path.resolve(keybindingsConfigDir, event.path) === keybindingsConfigPathResolved
+        );
+      }),
+      Stream.debounce(Duration.millis(100)),
+    );
+
+    yield* Stream.runForEach(debouncedKeybindingsEvents, () => revalidateAndEmitSafely).pipe(
+      Effect.ignoreCause({ log: true }),
+      Effect.forkIn(watcherScope),
+      Effect.asVoid,
+    );
   });
 
   const start = Effect.gen(function* () {

apps/server/src/main.test.ts

@@ -6,6 +6,7 @@ import * as ConfigProvider from "effect/ConfigProvider";
 import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
+import * as Stream from "effect/Stream";
 import * as Command from "effect/unstable/cli/Command";
 import { FetchHttpClient } from "effect/unstable/http";
 import { beforeEach } from "vitest";
@@ -16,7 +17,9 @@ import { ServerConfig, type ServerConfigShape } from "./config";
 import { Open, type OpenShape } from "./open";
 import { ProjectionSnapshotQuery } from "./orchestration/Services/ProjectionSnapshotQuery";
 import { AnalyticsService } from "./telemetry/Services/AnalyticsService";
+import { DEFAULT_SERVER_SETTINGS } from "@t3tools/contracts";
 import { Server, type ServerShape } from "./wsServer";
+import { ServerSettingsService, type ServerSettingsShape } from "./serverSettings";
 
 const start = vi.fn(() => undefined);
 const stop = vi.fn(() => undefined);
@@ -52,6 +55,13 @@ const testLayer = Layer.mergeAll(
     openBrowser: (_target: string) => Effect.void,
     openInEditor: () => Effect.void,
   } satisfies OpenShape),
+  Layer.succeed(ServerSettingsService, {
+    start: Effect.void,
+    ready: Effect.void,
+    getSettings: Effect.succeed(DEFAULT_SERVER_SETTINGS),
+    updateSettings: () => Effect.succeed(DEFAULT_SERVER_SETTINGS),
+    streamChanges: Stream.empty,
+  } satisfies ServerSettingsShape),
   AnalyticsService.layerTest,
   FetchHttpClient.layer,
   NodeServices.layer,

apps/server/src/main.ts

@@ -28,6 +28,7 @@ import { ServerLoggerLive } from "./serverLogger";
 import { AnalyticsServiceLayerLive } from "./telemetry/Layers/AnalyticsService";
 import { AnalyticsService } from "./telemetry/Services/AnalyticsService";
 import { readBootstrapEnvelope } from "./bootstrap";
+import { ServerSettingsLive } from "./serverSettings";
 
 export class StartupError extends Data.TaggedError("StartupError")<{
   readonly message: string;
@@ -297,6 +298,7 @@ const LayerLive = (input: CliInput) =>
     Layer.provideMerge(SqlitePersistence.layerConfig),
     Layer.provideMerge(ServerLoggerLive),
     Layer.provideMerge(AnalyticsServiceLayerLive),
+    Layer.provideMerge(ServerSettingsLive),
     Layer.provideMerge(ServerConfigLive(input)),
   );
 

apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts

@@ -34,6 +34,7 @@ import { ProviderCommandReactorLive } from "./ProviderCommandReactor.ts";
 import { OrchestrationEngineService } from "../Services/OrchestrationEngine.ts";
 import { ProviderCommandReactor } from "../Services/ProviderCommandReactor.ts";
 import * as NodeServices from "@effect/platform-node/NodeServices";
+import { ServerSettingsService } from "../../serverSettings.ts";
 
 const asProjectId = (value: string): ProjectId => ProjectId.makeUnsafe(value);
 const asApprovalRequestId = (value: string): ApprovalRequestId =>
@@ -214,6 +215,7 @@ describe("ProviderCommandReactor", () => {
       Layer.provideMerge(
         Layer.succeed(TextGeneration, { generateBranchName } as unknown as TextGenerationShape),
       ),
+      Layer.provideMerge(ServerSettingsService.layerTest()),
       Layer.provideMerge(ServerConfig.layerTest(process.cwd(), baseDir)),
       Layer.provideMerge(NodeServices.layer),
     );