feat: default to gpt-5.4 and seed project storage fallback

- default unknown/empty model fallback to gpt-5.4 across transform and runtime family selection
- load global account storage when project storage is missing, then seed project-scoped storage
- align tests and internal testing docs with the new fallback behavior

Author: ndycode

docs/development/TESTING.md

@@ -248,9 +248,9 @@ API receives: "gpt-5-codex" ✅
 ```
 User selects: (none - uses OpenCode default)
 Plugin receives: undefined or default from OpenCode
-normalizeModel: undefined → "gpt-5.1" ✅ (fallback)
+normalizeModel: undefined → "gpt-5.4" ✅ (fallback)
 Config lookup: models[undefined] → undefined
-API receives: "gpt-5.1" ✅
+API receives: "gpt-5.4" ✅
 ```
 
 **Result:** ✅ Works (safe fallback)
@@ -621,14 +621,14 @@ normalizeModel("gpt-5")                 // → "gpt-5.4" ✅
 normalizeModel("gpt-5-mini")            // → "gpt-5.4" ✅
 normalizeModel("gpt-5-nano")            // → "gpt-5.4" ✅
 normalizeModel("GPT 5.4 Pro High")      // → "gpt-5.4-pro" ✅
-normalizeModel(undefined)                 // → "gpt-5.1" ✅
-normalizeModel("random-model")          // → "gpt-5.1" ✅ (fallback)
+normalizeModel(undefined)                 // → "gpt-5.4" ✅
+normalizeModel("random-model")          // → "gpt-5.4" ✅ (fallback)
 ```
 
 **Implementation:**
 ```typescript
 export function normalizeModel(model: string | undefined): string {
-  if (!model) return "gpt-5.1";
+  if (!model) return "gpt-5.4";
 
   const modelId = model.includes("/") ? model.split("/").pop() ?? model : model;
   const mappedModel = getNormalizedModel(modelId);
@@ -660,14 +660,14 @@ export function normalizeModel(model: string | undefined): string {
   if (normalized.includes("gpt-5") || normalized.includes("gpt 5")) {
     return "gpt-5.4";
   }
-  return "gpt-5.1";
+  return "gpt-5.4";
 }
 ```
 
 **Why this works:**
 - ✅ Case-insensitive (`.toLowerCase()` + `.includes()`)
 - ✅ Pattern-based (works with any naming)
-- ✅ Legacy GPT-5 fallback (`gpt-5*` aliases → `gpt-5.4`) + safe unknown fallback (`gpt-5.1`)
+- ✅ Legacy GPT-5 fallback (`gpt-5*` aliases → `gpt-5.4`) + safe unknown fallback (`gpt-5.4`)
 - ✅ Codex priority with explicit Codex Mini support (`codex-mini*` → `codex-mini-latest`)
 
 ---
@@ -741,9 +741,9 @@ describe('normalizeModel', () => {
   })
 
   test('handles edge cases', () => {
-    expect(normalizeModel(undefined)).toBe('gpt-5.1')
+    expect(normalizeModel(undefined)).toBe('gpt-5.4')
     expect(normalizeModel('codex-mini-latest')).toBe('gpt-5.1-codex-mini')
-    expect(normalizeModel('random')).toBe('gpt-5.1')
+    expect(normalizeModel('random')).toBe('gpt-5.4')
   })
 })
 

index.ts

@@ -1896,7 +1896,7 @@ export const OpenAIOAuthPlugin: Plugin = async ({ client }: PluginInput) => {
                                                 const url = rewriteUrlForCodex(originalUrl);
 
 							// Step 3: Transform request body with model-specific Codex instructions
-							// Instructions are fetched per model family (codex-max, codex, gpt-5.1)
+							// Instructions are fetched per model family (codex-max, codex, gpt-5.4, etc.)
 							// Capture original stream value before transformation
 							// generateText() sends no stream field, streamText() sends stream=true
 								const normalizeRequestInit = async (
@@ -1986,7 +1986,7 @@ export const OpenAIOAuthPlugin: Plugin = async ({ client }: PluginInput) => {
 										let transformedBody: RequestBody | undefined = transformation?.body;
 										const promptCacheKey = transformedBody?.prompt_cache_key;
 										let model = transformedBody?.model;
-										let modelFamily = model ? getModelFamily(model) : "gpt-5.1";
+										let modelFamily = model ? getModelFamily(model) : "gpt-5.4";
 										let quotaKey = model ? `${modelFamily}:${model}` : modelFamily;
 						const threadIdCandidate =
 							(process.env.CODEX_THREAD_ID ?? promptCacheKey ?? "")

lib/request/request-transformer.ts

@@ -38,7 +38,7 @@ export {
  * @returns Normalized model name (e.g., "gpt-5-codex", "gpt-5.1-codex-max")
  */
 export function normalizeModel(model: string | undefined): string {
-	if (!model) return "gpt-5.1";
+	if (!model) return "gpt-5.4";
 
 	// Strip provider prefix if present (e.g., "openai/gpt-5-codex" → "gpt-5-codex")
 	const modelId = model.includes("/") ? model.split("/").pop() ?? model : model;
@@ -151,7 +151,7 @@ export function normalizeModel(model: string | undefined): string {
 	}
 
 	// Default fallback
-	return "gpt-5.1";
+	return "gpt-5.4";
 }
 
 /**

lib/storage.ts

@@ -669,6 +669,58 @@ export async function loadAccounts(): Promise<AccountStorageV3 | null> {
   return loadAccountsInternal(saveAccounts);
 }
 
+function getGlobalAccountsStoragePath(): string {
+  return join(getConfigDir(), ACCOUNTS_FILE_NAME);
+}
+
+function shouldUseProjectGlobalFallback(): boolean {
+  return Boolean(currentStoragePath && currentProjectRoot);
+}
+
+async function loadGlobalAccountsFallback(): Promise<AccountStorageV3 | null> {
+  if (!shouldUseProjectGlobalFallback() || !currentStoragePath) {
+    return null;
+  }
+
+  const globalStoragePath = getGlobalAccountsStoragePath();
+  if (globalStoragePath === currentStoragePath) {
+    return null;
+  }
+
+  try {
+    const content = await fs.readFile(globalStoragePath, "utf-8");
+    const data = JSON.parse(content) as unknown;
+
+    const schemaErrors = getValidationErrors(AnyAccountStorageSchema, data);
+    if (schemaErrors.length > 0) {
+      log.warn("Global account storage schema validation warnings", {
+        path: globalStoragePath,
+        errors: schemaErrors.slice(0, 5),
+      });
+    }
+
+    const normalized = normalizeAccountStorage(data);
+    if (!normalized) return null;
+
+    log.info("Loaded global account storage as project fallback", {
+      from: globalStoragePath,
+      to: currentStoragePath,
+      accounts: normalized.accounts.length,
+    });
+    return normalized;
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException).code;
+    if (code !== "ENOENT") {
+      log.warn("Failed to load global fallback account storage", {
+        from: globalStoragePath,
+        to: currentStoragePath,
+        error: String(error),
+      });
+    }
+    return null;
+  }
+}
+
 async function loadAccountsInternal(
   persistMigration: ((storage: AccountStorageV3) => Promise<void>) | null,
 ): Promise<AccountStorageV3 | null> {
@@ -704,7 +756,25 @@ async function loadAccountsInternal(
         ? await migrateLegacyProjectStorageIfNeeded(persistMigration)
         : null;
       if (migrated) return migrated;
-      return null;
+      const globalFallback = await loadGlobalAccountsFallback();
+      if (!globalFallback) return null;
+
+      if (persistMigration) {
+        try {
+          await persistMigration(globalFallback);
+          log.info("Seeded project account storage from global fallback", {
+            path: getStoragePath(),
+            accounts: globalFallback.accounts.length,
+          });
+        } catch (persistError) {
+          log.warn("Failed to seed project storage from global fallback", {
+            path: getStoragePath(),
+            error: String(persistError),
+          });
+        }
+      }
+
+      return globalFallback;
     }
     log.error("Failed to load account storage", { error: String(error) });
     return null;

test/edge-cases.test.ts

@@ -18,9 +18,9 @@ import type { InputItem, UserConfig } from "../lib/types.js";
 describe("Edge Cases and Boundary Conditions", () => {
 	describe("normalizeModel edge cases", () => {
 		it("should handle null-like values", () => {
-			expect(normalizeModel(undefined)).toBe("gpt-5.1");
-			expect(normalizeModel("")).toBe("gpt-5.1");
-			expect(normalizeModel("   ")).toBe("gpt-5.1");
+			expect(normalizeModel(undefined)).toBe("gpt-5.4");
+			expect(normalizeModel("")).toBe("gpt-5.4");
+			expect(normalizeModel("   ")).toBe("gpt-5.4");
 		});
 
 		it("should handle models with multiple slashes", () => {
@@ -40,13 +40,13 @@ describe("Edge Cases and Boundary Conditions", () => {
 
 		it("should handle models with mixed separators", () => {
 			// Mixed separators may miss explicit 5.4/pro patterns and fall through to generic GPT-5 fallback.
-			expect(normalizeModel("gpt_5.4-high")).toBe("gpt-5.1");
+			expect(normalizeModel("gpt_5.4-high")).toBe("gpt-5.4");
 			expect(normalizeModel("gpt-5_4 pro")).toBe("gpt-5.4");
 		});
 
 		it("should handle models with numeric-only names", () => {
-			expect(normalizeModel("5.4")).toBe("gpt-5.1");
-			expect(normalizeModel("5")).toBe("gpt-5.1");
+			expect(normalizeModel("5.4")).toBe("gpt-5.4");
+			expect(normalizeModel("5")).toBe("gpt-5.4");
 		});
 
 		it("should handle models with unicode characters", () => {

test/gpt54-models.test.ts

@@ -219,13 +219,13 @@ describe("GPT-5.4 Model Support", () => {
 
 		it("should handle gpt-5.4 with multiple spaces", () => {
 			// Multiple spaces are not explicitly handled, falls back to default
-			expect(normalizeModel("gpt  5.4")).toBe("gpt-5.1");
-			expect(normalizeModel("gpt   5.4   high")).toBe("gpt-5.1");
+			expect(normalizeModel("gpt  5.4")).toBe("gpt-5.4");
+			expect(normalizeModel("gpt   5.4   high")).toBe("gpt-5.4");
 		});
 
 		it("should handle gpt-5.4 with underscore separator", () => {
 			// Underscore separator not explicitly supported, falls back to default
-			expect(normalizeModel("gpt_5_4")).toBe("gpt-5.1");
+			expect(normalizeModel("gpt_5_4")).toBe("gpt-5.4");
 		});
 
 		it("should not match gpt-5.4x patterns as gpt-5.4", () => {
@@ -234,9 +234,9 @@ describe("GPT-5.4 Model Support", () => {
 			expect(normalizeModel("gpt-5.44")).toBe("gpt-5.4");
 		});
 
-		it("should handle empty/undefined model names defaulting to gpt-5.1", () => {
-			expect(normalizeModel(undefined)).toBe("gpt-5.1");
-			expect(normalizeModel("")).toBe("gpt-5.1");
+		it("should handle empty/undefined model names defaulting to gpt-5.4", () => {
+			expect(normalizeModel(undefined)).toBe("gpt-5.4");
+			expect(normalizeModel("")).toBe("gpt-5.4");
 		});
 	});
 

test/property/transformer.property.test.ts

@@ -47,12 +47,12 @@ describe("normalizeModel property tests", () => {
 
   it("handles undefined gracefully", () => {
     const result = normalizeModel(undefined);
-    expect(result).toBe("gpt-5.1");
+    expect(result).toBe("gpt-5.4");
   });
 
   it("handles empty string gracefully", () => {
     const result = normalizeModel("");
-    expect(result).toBe("gpt-5.1");
+    expect(result).toBe("gpt-5.4");
   });
 });
 

test/request-transformer.test.ts

@@ -35,13 +35,13 @@ describe('Request Transformer Module', () => {
 			expect(normalizeModel('gpt-5-nano')).toBe('gpt-5.4');
 		});
 
-		it('should return gpt-5.1 as default for unknown models', async () => {
-			expect(normalizeModel('unknown-model')).toBe('gpt-5.1');
-			expect(normalizeModel('gpt-4')).toBe('gpt-5.1');
+		it('should return gpt-5.4 as default for unknown models', async () => {
+			expect(normalizeModel('unknown-model')).toBe('gpt-5.4');
+			expect(normalizeModel('gpt-4')).toBe('gpt-5.4');
 		});
 
-		it('should return gpt-5.1 for undefined', async () => {
-			expect(normalizeModel(undefined)).toBe('gpt-5.1');
+		it('should return gpt-5.4 for undefined', async () => {
+			expect(normalizeModel(undefined)).toBe('gpt-5.4');
 		});
 
 		// Codex CLI preset name tests - legacy gpt-5 base aliases now map to gpt-5.4
@@ -173,7 +173,7 @@ describe('Request Transformer Module', () => {
 
 			it('should handle special characters', async () => {
 				expect(normalizeModel('my_gpt-5_codex')).toBe('gpt-5-codex');
-				expect(normalizeModel('gpt.5.high')).toBe('gpt-5.1');
+				expect(normalizeModel('gpt.5.high')).toBe('gpt-5.4');
 			});
 
 			it('should handle old verbose names', async () => {
@@ -182,7 +182,7 @@ describe('Request Transformer Module', () => {
 			});
 
 			it('should handle empty string', async () => {
-				expect(normalizeModel('')).toBe('gpt-5.1');
+				expect(normalizeModel('')).toBe('gpt-5.4');
 			});
 		});
 	});

test/storage.test.ts

@@ -1780,6 +1780,50 @@ describe("storage", () => {
       expect(existsSync(legacyStoragePath)).toBe(false);
       expect(existsSync(getStoragePath())).toBe(true);
     });
+
+    it("loads global storage as fallback when project-scoped storage is missing", async () => {
+      const fakeHome = join(testWorkDir, "home-fallback");
+      const projectDir = join(testWorkDir, "project-fallback");
+      const projectGitDir = join(projectDir, ".git");
+      const globalConfigDir = join(fakeHome, ".opencode");
+      const globalStoragePath = join(globalConfigDir, "openai-codex-accounts.json");
+
+      await fs.mkdir(fakeHome, { recursive: true });
+      await fs.mkdir(projectGitDir, { recursive: true });
+      await fs.mkdir(globalConfigDir, { recursive: true });
+      process.env.HOME = fakeHome;
+      process.env.USERPROFILE = fakeHome;
+      setStoragePath(projectDir);
+
+      const globalStorage = {
+        version: 3,
+        activeIndex: 0,
+        accounts: [
+          {
+            refreshToken: "global-refresh",
+            accountId: "global-account",
+            addedAt: 1,
+            lastUsed: 1,
+          },
+        ],
+      };
+      await fs.writeFile(globalStoragePath, JSON.stringify(globalStorage), "utf-8");
+
+      const loaded = await loadAccounts();
+
+      expect(loaded).not.toBeNull();
+      expect(loaded?.accounts).toHaveLength(1);
+      expect(loaded?.accounts[0]?.accountId).toBe("global-account");
+
+      const projectScopedPath = getStoragePath();
+      expect(projectScopedPath).toContain(join(fakeHome, ".opencode", "projects"));
+      expect(existsSync(projectScopedPath)).toBe(true);
+
+      const seeded = JSON.parse(await fs.readFile(projectScopedPath, "utf-8")) as {
+        accounts?: Array<{ accountId?: string }>;
+      };
+      expect(seeded.accounts?.[0]?.accountId).toBe("global-account");
+    });
   });
 
   describe("saveAccounts EPERM/EBUSY retry logic", () => {