@wingman-ai/gateway 0.2.2 → 0.2.4

package/dist/tests/agents-api.test.js

@@ -1,9 +1,9 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { handleAgentsApi } from "../gateway/http/agents.js";
 import { mkdtempSync, readFileSync, rmSync } from "node:fs";
-import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { load } from "js-yaml";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { handleAgentsApi } from "../gateway/http/agents.js";
 const isBunRuntime = void 0 !== globalThis.Bun;
 const describeIfBun = isBunRuntime ? describe : describe.skip;
 const parseMarkdownAgent = (raw)=>{
@@ -63,6 +63,7 @@ describeIfBun("agents API", ()=>{
                     "not_real_tool"
                 ],
                 prompt: "You are the orchestrator.",
+                reasoningEffort: "high",
                 promptTraining: {
                     enabled: true,
                     instructionsPath: "/memories/agents/orchestrator/instructions.md"
@@ -76,6 +77,7 @@ describeIfBun("agents API", ()=>{
                             "not_real_tool"
                         ],
                         prompt: "Plan tasks in detail.",
+                        reasoningEffort: "low",
                         promptTraining: true
                     },
                     {
@@ -84,7 +86,8 @@ describeIfBun("agents API", ()=>{
                         tools: [
                             "command_execute"
                         ],
-                        prompt: "Execute planned tasks."
+                        prompt: "Execute planned tasks.",
+                        thinkingEffort: "minimal"
                     }
                 ]
             })
@@ -97,12 +100,15 @@ describeIfBun("agents API", ()=>{
             enabled: true,
             instructionsPath: "/memories/agents/orchestrator/instructions.md"
         });
+        expect(created.reasoningEffort).toBe("high");
         expect(created.promptRefinement).toEqual(created.promptTraining);
         expect(created.subAgents).toHaveLength(2);
         expect(created.subAgents[0].promptTraining).toBe(true);
         expect(created.subAgents[0].tools).toEqual([
             "think"
         ]);
+        expect(created.subAgents[0].reasoningEffort).toBe("low");
+        expect(created.subAgents[1].reasoningEffort).toBe("minimal");
         const agentPath = join(tempDir, "agents", "orchestrator", "agent.md");
         const parsed = parseMarkdownAgent(readFileSync(agentPath, "utf-8"));
         expect(parsed.prompt).toBe("You are the orchestrator.");
@@ -110,10 +116,13 @@ describeIfBun("agents API", ()=>{
             enabled: true,
             instructionsPath: "/memories/agents/orchestrator/instructions.md"
         });
+        expect(parsed.metadata.reasoningEffort).toBe("high");
         expect(parsed.metadata.subAgents).toHaveLength(2);
         expect(parsed.metadata.subAgents[0].name).toBe("planner");
+        expect(parsed.metadata.subAgents[0].reasoningEffort).toBe("low");
         expect(parsed.metadata.subAgents[0].promptRefinement).toBe(true);
         expect(parsed.metadata.subAgents[0].systemPrompt).toBe("Plan tasks in detail.");
+        expect(parsed.metadata.subAgents[1].reasoningEffort).toBe("minimal");
         const detailReq = new Request("http://localhost/api/agents/orchestrator", {
             method: "GET"
         });
@@ -123,9 +132,11 @@ describeIfBun("agents API", ()=>{
         const detail = await detailRes.json();
         expect(detail.promptTraining).toEqual(created.promptTraining);
         expect(detail.promptRefinement).toEqual(created.promptTraining);
+        expect(detail.reasoningEffort).toBe("high");
         expect(detail.subAgents).toHaveLength(2);
         expect(detail.subAgents[0].id).toBe("planner");
         expect(detail.subAgents[0].prompt).toBe("Plan tasks in detail.");
+        expect(detail.subAgents[0].reasoningEffort).toBe("low");
     });
     it("updates promptTraining and subAgents in markdown", async ()=>{
         const createReq = new Request("http://localhost/api/agents", {
@@ -139,6 +150,7 @@ describeIfBun("agents API", ()=>{
                     "think"
                 ],
                 prompt: "Original prompt",
+                reasoningEffort: "low",
                 promptTraining: true,
                 subAgents: [
                     {
@@ -147,7 +159,8 @@ describeIfBun("agents API", ()=>{
                         tools: [
                             "think"
                         ],
-                        prompt: "Original planner prompt"
+                        prompt: "Original planner prompt",
+                        reasoningEffort: "minimal"
                     }
                 ]
             })
@@ -160,6 +173,7 @@ describeIfBun("agents API", ()=>{
                 "Content-Type": "application/json"
             },
             body: JSON.stringify({
+                reasoningEffort: "high",
                 promptTraining: false,
                 subAgents: [
                     {
@@ -169,6 +183,7 @@ describeIfBun("agents API", ()=>{
                             "git_status"
                         ],
                         prompt: "Review carefully.",
+                        thinkingEffort: "medium",
                         promptTraining: {
                             enabled: true,
                             instructionsPath: "/memories/reviewer.md"
@@ -184,8 +199,10 @@ describeIfBun("agents API", ()=>{
         const updated = await updateRes.json();
         expect(updated.promptTraining).toBe(false);
         expect(updated.promptRefinement).toBe(false);
+        expect(updated.reasoningEffort).toBe("high");
         expect(updated.subAgents).toHaveLength(1);
         expect(updated.subAgents[0].id).toBe("reviewer");
+        expect(updated.subAgents[0].reasoningEffort).toBe("medium");
         expect(updated.subAgents[0].promptTraining).toEqual({
             enabled: true,
             instructionsPath: "/memories/reviewer.md"
@@ -193,8 +210,10 @@ describeIfBun("agents API", ()=>{
         const agentPath = join(tempDir, "agents", "editor-agent", "agent.md");
         const parsed = parseMarkdownAgent(readFileSync(agentPath, "utf-8"));
         expect(parsed.metadata.promptRefinement).toBe(false);
+        expect(parsed.metadata.reasoningEffort).toBe("high");
         expect(parsed.metadata.subAgents).toHaveLength(1);
         expect(parsed.metadata.subAgents[0].name).toBe("reviewer");
+        expect(parsed.metadata.subAgents[0].reasoningEffort).toBe("medium");
         expect(parsed.metadata.subAgents[0].promptRefinement).toEqual({
             enabled: true,
             instructionsPath: "/memories/reviewer.md"
@@ -223,4 +242,25 @@ describeIfBun("agents API", ()=>{
         expect(created.promptTraining).toBe(true);
         expect(created.promptRefinement).toBe(true);
     });
+    it("accepts legacy thinkingEffort input as reasoningEffort", async ()=>{
+        const createReq = new Request("http://localhost/api/agents", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                id: "legacy-thinking-agent",
+                tools: [
+                    "think"
+                ],
+                prompt: "Legacy thinking prompt",
+                thinkingEffort: "medium"
+            })
+        });
+        const createRes = await handleAgentsApi(ctx, createReq, new URL(createReq.url));
+        expect(createRes).not.toBeNull();
+        expect(createRes?.ok).toBe(true);
+        const created = await createRes.json();
+        expect(created.reasoningEffort).toBe("medium");
+    });
 });

package/dist/tests/cli-config-loader.test.cjs

@@ -33,6 +33,33 @@ const external_os_namespaceObject = require("os");
             (0, external_vitest_namespaceObject.expect)(config).toEqual({
                 logLevel: "info",
                 recursionLimit: 5000,
+                summarization: {
+                    enabled: true,
+                    maxTokensBeforeSummary: 12000,
+                    messagesToKeep: 8
+                },
+                modelRetry: {
+                    enabled: true,
+                    maxRetries: 2,
+                    backoffFactor: 2,
+                    initialDelayMs: 1000,
+                    maxDelayMs: 60000,
+                    jitter: true,
+                    onFailure: "continue"
+                },
+                toolRetry: {
+                    enabled: false,
+                    maxRetries: 2,
+                    backoffFactor: 2,
+                    initialDelayMs: 1000,
+                    maxDelayMs: 60000,
+                    jitter: true,
+                    onFailure: "continue"
+                },
+                humanInTheLoop: {
+                    enabled: false,
+                    interruptOn: {}
+                },
                 search: {
                     provider: "duckduckgo",
                     maxResults: 5
@@ -111,6 +138,11 @@ const external_os_namespaceObject = require("os");
                 logLevel: "debug",
                 defaultAgent: "coder",
                 recursionLimit: 5,
+                summarization: {
+                    enabled: true,
+                    maxTokensBeforeSummary: 18000,
+                    messagesToKeep: 10
+                },
                 search: {
                     provider: "perplexity",
                     maxResults: 10
@@ -130,6 +162,62 @@ const external_os_namespaceObject = require("os");
             const config = loader.loadConfig();
             (0, external_vitest_namespaceObject.expect)(config).toMatchObject(configData);
         });
+        (0, external_vitest_namespaceObject.it)("should allow disabling summarization middleware", ()=>{
+            const configData = {
+                summarization: {
+                    enabled: false
+                }
+            };
+            (0, external_fs_namespaceObject.writeFileSync)((0, external_path_namespaceObject.join)(configDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new loader_cjs_namespaceObject.WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            (0, external_vitest_namespaceObject.expect)(config.summarization).toEqual({
+                enabled: false,
+                maxTokensBeforeSummary: 12000,
+                messagesToKeep: 8
+            });
+        });
+        (0, external_vitest_namespaceObject.it)("should load retry and HITL middleware config", ()=>{
+            const configData = {
+                modelRetry: {
+                    enabled: true,
+                    maxRetries: 3,
+                    backoffFactor: 1.5,
+                    initialDelayMs: 250,
+                    maxDelayMs: 4000,
+                    jitter: false,
+                    onFailure: "error"
+                },
+                toolRetry: {
+                    enabled: true,
+                    maxRetries: 4,
+                    backoffFactor: 2,
+                    initialDelayMs: 500,
+                    maxDelayMs: 8000,
+                    jitter: true,
+                    onFailure: "continue",
+                    tools: [
+                        "internet_search",
+                        "web_crawler"
+                    ]
+                },
+                humanInTheLoop: {
+                    enabled: true,
+                    interruptOn: {
+                        command_execute: {
+                            allowedDecisions: [
+                                "approve",
+                                "reject"
+                            ]
+                        }
+                    }
+                }
+            };
+            (0, external_fs_namespaceObject.writeFileSync)((0, external_path_namespaceObject.join)(configDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new loader_cjs_namespaceObject.WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            (0, external_vitest_namespaceObject.expect)(config).toMatchObject(configData);
+        });
         (0, external_vitest_namespaceObject.it)("should handle all valid log levels", ()=>{
             const levels = [
                 "debug",

package/dist/tests/cli-config-loader.test.js

@@ -31,6 +31,33 @@ describe("CLI Config Loader", ()=>{
             expect(config).toEqual({
                 logLevel: "info",
                 recursionLimit: 5000,
+                summarization: {
+                    enabled: true,
+                    maxTokensBeforeSummary: 12000,
+                    messagesToKeep: 8
+                },
+                modelRetry: {
+                    enabled: true,
+                    maxRetries: 2,
+                    backoffFactor: 2,
+                    initialDelayMs: 1000,
+                    maxDelayMs: 60000,
+                    jitter: true,
+                    onFailure: "continue"
+                },
+                toolRetry: {
+                    enabled: false,
+                    maxRetries: 2,
+                    backoffFactor: 2,
+                    initialDelayMs: 1000,
+                    maxDelayMs: 60000,
+                    jitter: true,
+                    onFailure: "continue"
+                },
+                humanInTheLoop: {
+                    enabled: false,
+                    interruptOn: {}
+                },
                 search: {
                     provider: "duckduckgo",
                     maxResults: 5
@@ -109,6 +136,11 @@ describe("CLI Config Loader", ()=>{
                 logLevel: "debug",
                 defaultAgent: "coder",
                 recursionLimit: 5,
+                summarization: {
+                    enabled: true,
+                    maxTokensBeforeSummary: 18000,
+                    messagesToKeep: 10
+                },
                 search: {
                     provider: "perplexity",
                     maxResults: 10
@@ -128,6 +160,62 @@ describe("CLI Config Loader", ()=>{
             const config = loader.loadConfig();
             expect(config).toMatchObject(configData);
         });
+        it("should allow disabling summarization middleware", ()=>{
+            const configData = {
+                summarization: {
+                    enabled: false
+                }
+            };
+            writeFileSync(join(configDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            expect(config.summarization).toEqual({
+                enabled: false,
+                maxTokensBeforeSummary: 12000,
+                messagesToKeep: 8
+            });
+        });
+        it("should load retry and HITL middleware config", ()=>{
+            const configData = {
+                modelRetry: {
+                    enabled: true,
+                    maxRetries: 3,
+                    backoffFactor: 1.5,
+                    initialDelayMs: 250,
+                    maxDelayMs: 4000,
+                    jitter: false,
+                    onFailure: "error"
+                },
+                toolRetry: {
+                    enabled: true,
+                    maxRetries: 4,
+                    backoffFactor: 2,
+                    initialDelayMs: 500,
+                    maxDelayMs: 8000,
+                    jitter: true,
+                    onFailure: "continue",
+                    tools: [
+                        "internet_search",
+                        "web_crawler"
+                    ]
+                },
+                humanInTheLoop: {
+                    enabled: true,
+                    interruptOn: {
+                        command_execute: {
+                            allowedDecisions: [
+                                "approve",
+                                "reject"
+                            ]
+                        }
+                    }
+                }
+            };
+            writeFileSync(join(configDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            expect(config).toMatchObject(configData);
+        });
         it("should handle all valid log levels", ()=>{
             const levels = [
                 "debug",

package/dist/tests/cli-init.test.cjs

@@ -1,10 +1,10 @@
 "use strict";
 var __webpack_exports__ = {};
-const external_vitest_namespaceObject = require("vitest");
-const init_cjs_namespaceObject = require("../cli/commands/init.cjs");
 const external_node_fs_namespaceObject = require("node:fs");
-const external_node_path_namespaceObject = require("node:path");
 const external_node_os_namespaceObject = require("node:os");
+const external_node_path_namespaceObject = require("node:path");
+const external_vitest_namespaceObject = require("vitest");
+const init_cjs_namespaceObject = require("../cli/commands/init.cjs");
 (0, external_vitest_namespaceObject.describe)("CLI init", ()=>{
     let workspace;
     (0, external_vitest_namespaceObject.beforeEach)(()=>{
@@ -39,6 +39,30 @@ const external_node_os_namespaceObject = require("node:os");
         (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(agentPath)).toBe(true);
         const agent = JSON.parse((0, external_node_fs_namespaceObject.readFileSync)(agentPath, "utf-8"));
         (0, external_vitest_namespaceObject.expect)(agent.name).toBe("wingman");
+        const codingAgentPath = (0, external_node_path_namespaceObject.join)(workspace, ".wingman", "agents", "coding", "agent.md");
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(codingAgentPath)).toBe(true);
+        const codingPrompt = (0, external_node_fs_namespaceObject.readFileSync)(codingAgentPath, "utf-8");
+        (0, external_vitest_namespaceObject.expect)(codingPrompt).toContain("write_todos");
+        (0, external_vitest_namespaceObject.expect)(codingPrompt).not.toContain("update_plan");
+        (0, external_vitest_namespaceObject.expect)(codingPrompt).not.toContain("subAgents:");
+        (0, external_vitest_namespaceObject.expect)(codingPrompt).toContain("Do not delegate coding work to subagents");
+        const codingV2AgentPath = (0, external_node_path_namespaceObject.join)(workspace, ".wingman", "agents", "coding-v2", "agent.md");
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(codingV2AgentPath)).toBe(true);
+        const codingV2Prompt = (0, external_node_fs_namespaceObject.readFileSync)(codingV2AgentPath, "utf-8");
+        (0, external_vitest_namespaceObject.expect)(codingV2Prompt).toContain("name: coding-v2");
+        (0, external_vitest_namespaceObject.expect)(codingV2Prompt).toContain("subAgents:");
+        (0, external_vitest_namespaceObject.expect)(codingV2Prompt).toContain("name: coding-worker");
+        (0, external_vitest_namespaceObject.expect)(codingV2Prompt).toContain("promptFile: ./implementor.md");
+        (0, external_vitest_namespaceObject.expect)(codingV2Prompt).toContain("`task` tool");
+        (0, external_vitest_namespaceObject.expect)(codingV2Prompt).toContain("write_todos");
+        const codingV2ImplementorPath = (0, external_node_path_namespaceObject.join)(workspace, ".wingman", "agents", "coding-v2", "implementor.md");
+        const codingV2PlannerPath = (0, external_node_path_namespaceObject.join)(workspace, ".wingman", "agents", "coding-v2", "planner.md");
+        const codingV2ReviewerPath = (0, external_node_path_namespaceObject.join)(workspace, ".wingman", "agents", "coding-v2", "reviewer.md");
+        const codingV2ResearcherPath = (0, external_node_path_namespaceObject.join)(workspace, ".wingman", "agents", "coding-v2", "researcher.md");
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(codingV2ImplementorPath)).toBe(true);
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(codingV2PlannerPath)).toBe(false);
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(codingV2ReviewerPath)).toBe(false);
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(codingV2ResearcherPath)).toBe(false);
     });
     (0, external_vitest_namespaceObject.it)("merges existing config when --merge is set", async ()=>{
         const configDir = (0, external_node_path_namespaceObject.join)(workspace, ".wingman");

package/dist/tests/cli-init.test.js

@@ -1,8 +1,8 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { executeInitCommand } from "../cli/commands/init.js";
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { executeInitCommand } from "../cli/commands/init.js";
 describe("CLI init", ()=>{
     let workspace;
     beforeEach(()=>{
@@ -37,6 +37,30 @@ describe("CLI init", ()=>{
         expect(existsSync(agentPath)).toBe(true);
         const agent = JSON.parse(readFileSync(agentPath, "utf-8"));
         expect(agent.name).toBe("wingman");
+        const codingAgentPath = join(workspace, ".wingman", "agents", "coding", "agent.md");
+        expect(existsSync(codingAgentPath)).toBe(true);
+        const codingPrompt = readFileSync(codingAgentPath, "utf-8");
+        expect(codingPrompt).toContain("write_todos");
+        expect(codingPrompt).not.toContain("update_plan");
+        expect(codingPrompt).not.toContain("subAgents:");
+        expect(codingPrompt).toContain("Do not delegate coding work to subagents");
+        const codingV2AgentPath = join(workspace, ".wingman", "agents", "coding-v2", "agent.md");
+        expect(existsSync(codingV2AgentPath)).toBe(true);
+        const codingV2Prompt = readFileSync(codingV2AgentPath, "utf-8");
+        expect(codingV2Prompt).toContain("name: coding-v2");
+        expect(codingV2Prompt).toContain("subAgents:");
+        expect(codingV2Prompt).toContain("name: coding-worker");
+        expect(codingV2Prompt).toContain("promptFile: ./implementor.md");
+        expect(codingV2Prompt).toContain("`task` tool");
+        expect(codingV2Prompt).toContain("write_todos");
+        const codingV2ImplementorPath = join(workspace, ".wingman", "agents", "coding-v2", "implementor.md");
+        const codingV2PlannerPath = join(workspace, ".wingman", "agents", "coding-v2", "planner.md");
+        const codingV2ReviewerPath = join(workspace, ".wingman", "agents", "coding-v2", "reviewer.md");
+        const codingV2ResearcherPath = join(workspace, ".wingman", "agents", "coding-v2", "researcher.md");
+        expect(existsSync(codingV2ImplementorPath)).toBe(true);
+        expect(existsSync(codingV2PlannerPath)).toBe(false);
+        expect(existsSync(codingV2ReviewerPath)).toBe(false);
+        expect(existsSync(codingV2ResearcherPath)).toBe(false);
     });
     it("merges existing config when --merge is set", async ()=>{
         const configDir = join(workspace, ".wingman");

package/dist/tests/codex-credentials-precedence.test.cjs

@@ -0,0 +1,94 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_os_namespaceObject = require("node:os");
+const external_node_path_namespaceObject = require("node:path");
+const external_vitest_namespaceObject = require("vitest");
+(0, external_vitest_namespaceObject.describe)("codex credential precedence", ()=>{
+    let homeDir;
+    let codexHome;
+    const originalHome = process.env.HOME;
+    const originalCodexHome = process.env.CODEX_HOME;
+    const originalCodexAccessToken = process.env.CODEX_ACCESS_TOKEN;
+    const originalChatGptAccessToken = process.env.CHATGPT_ACCESS_TOKEN;
+    (0, external_vitest_namespaceObject.beforeEach)(()=>{
+        homeDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-home-"));
+        codexHome = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-codex-home-"));
+        process.env.HOME = homeDir;
+        process.env.CODEX_HOME = codexHome;
+        delete process.env.CODEX_ACCESS_TOKEN;
+        delete process.env.CHATGPT_ACCESS_TOKEN;
+    });
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        if (void 0 === originalHome) delete process.env.HOME;
+        else process.env.HOME = originalHome;
+        if (void 0 === originalCodexHome) delete process.env.CODEX_HOME;
+        else process.env.CODEX_HOME = originalCodexHome;
+        if (void 0 === originalCodexAccessToken) delete process.env.CODEX_ACCESS_TOKEN;
+        else process.env.CODEX_ACCESS_TOKEN = originalCodexAccessToken;
+        if (void 0 === originalChatGptAccessToken) delete process.env.CHATGPT_ACCESS_TOKEN;
+        else process.env.CHATGPT_ACCESS_TOKEN = originalChatGptAccessToken;
+        if ((0, external_node_fs_namespaceObject.existsSync)(homeDir)) (0, external_node_fs_namespaceObject.rmSync)(homeDir, {
+            recursive: true,
+            force: true
+        });
+        if ((0, external_node_fs_namespaceObject.existsSync)(codexHome)) (0, external_node_fs_namespaceObject.rmSync)(codexHome, {
+            recursive: true,
+            force: true
+        });
+    });
+    (0, external_vitest_namespaceObject.it)("prefers Codex auth file over stored Wingman credentials for codex", async ()=>{
+        external_vitest_namespaceObject.vi.resetModules();
+        const credentials = await import("../providers/credentials.cjs");
+        const codex = await import("../providers/codex.cjs");
+        const credsPath = credentials.getCredentialsPath();
+        (0, external_node_fs_namespaceObject.mkdirSync)((0, external_node_path_namespaceObject.dirname)(credsPath), {
+            recursive: true
+        });
+        (0, external_node_fs_namespaceObject.writeFileSync)(credsPath, JSON.stringify({
+            version: 1,
+            updatedAt: new Date().toISOString(),
+            providers: {
+                codex: {
+                    apiKey: "stale-wingman-token"
+                }
+            }
+        }, null, 2));
+        const authPath = codex.getCodexAuthPath();
+        (0, external_node_fs_namespaceObject.mkdirSync)((0, external_node_path_namespaceObject.dirname)(authPath), {
+            recursive: true
+        });
+        (0, external_node_fs_namespaceObject.writeFileSync)(authPath, JSON.stringify({
+            tokens: {
+                access_token: "codex-file-token",
+                account_id: "acct_123"
+            }
+        }, null, 2));
+        const resolved = credentials.resolveProviderToken("codex");
+        (0, external_vitest_namespaceObject.expect)(resolved.token).toBe("codex-file-token");
+        (0, external_vitest_namespaceObject.expect)(resolved.source).toBe("credentials");
+    });
+    (0, external_vitest_namespaceObject.it)("still prefers env vars over Codex auth file", async ()=>{
+        process.env.CODEX_ACCESS_TOKEN = "env-token";
+        external_vitest_namespaceObject.vi.resetModules();
+        const credentials = await import("../providers/credentials.cjs");
+        const codex = await import("../providers/codex.cjs");
+        const authPath = codex.getCodexAuthPath();
+        (0, external_node_fs_namespaceObject.mkdirSync)((0, external_node_path_namespaceObject.dirname)(authPath), {
+            recursive: true
+        });
+        (0, external_node_fs_namespaceObject.writeFileSync)(authPath, JSON.stringify({
+            tokens: {
+                access_token: "codex-file-token"
+            }
+        }, null, 2));
+        const resolved = credentials.resolveProviderToken("codex");
+        (0, external_vitest_namespaceObject.expect)(resolved.token).toBe("env-token");
+        (0, external_vitest_namespaceObject.expect)(resolved.source).toBe("env");
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.readFileSync)(authPath, "utf-8")).toContain("codex-file-token");
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/codex-credentials-precedence.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/codex-credentials-precedence.test.js

@@ -0,0 +1,88 @@
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+describe("codex credential precedence", ()=>{
+    let homeDir;
+    let codexHome;
+    const originalHome = process.env.HOME;
+    const originalCodexHome = process.env.CODEX_HOME;
+    const originalCodexAccessToken = process.env.CODEX_ACCESS_TOKEN;
+    const originalChatGptAccessToken = process.env.CHATGPT_ACCESS_TOKEN;
+    beforeEach(()=>{
+        homeDir = mkdtempSync(join(tmpdir(), "wingman-home-"));
+        codexHome = mkdtempSync(join(tmpdir(), "wingman-codex-home-"));
+        process.env.HOME = homeDir;
+        process.env.CODEX_HOME = codexHome;
+        delete process.env.CODEX_ACCESS_TOKEN;
+        delete process.env.CHATGPT_ACCESS_TOKEN;
+    });
+    afterEach(()=>{
+        if (void 0 === originalHome) delete process.env.HOME;
+        else process.env.HOME = originalHome;
+        if (void 0 === originalCodexHome) delete process.env.CODEX_HOME;
+        else process.env.CODEX_HOME = originalCodexHome;
+        if (void 0 === originalCodexAccessToken) delete process.env.CODEX_ACCESS_TOKEN;
+        else process.env.CODEX_ACCESS_TOKEN = originalCodexAccessToken;
+        if (void 0 === originalChatGptAccessToken) delete process.env.CHATGPT_ACCESS_TOKEN;
+        else process.env.CHATGPT_ACCESS_TOKEN = originalChatGptAccessToken;
+        if (existsSync(homeDir)) rmSync(homeDir, {
+            recursive: true,
+            force: true
+        });
+        if (existsSync(codexHome)) rmSync(codexHome, {
+            recursive: true,
+            force: true
+        });
+    });
+    it("prefers Codex auth file over stored Wingman credentials for codex", async ()=>{
+        vi.resetModules();
+        const credentials = await import("../providers/credentials.js");
+        const codex = await import("../providers/codex.js");
+        const credsPath = credentials.getCredentialsPath();
+        mkdirSync(dirname(credsPath), {
+            recursive: true
+        });
+        writeFileSync(credsPath, JSON.stringify({
+            version: 1,
+            updatedAt: new Date().toISOString(),
+            providers: {
+                codex: {
+                    apiKey: "stale-wingman-token"
+                }
+            }
+        }, null, 2));
+        const authPath = codex.getCodexAuthPath();
+        mkdirSync(dirname(authPath), {
+            recursive: true
+        });
+        writeFileSync(authPath, JSON.stringify({
+            tokens: {
+                access_token: "codex-file-token",
+                account_id: "acct_123"
+            }
+        }, null, 2));
+        const resolved = credentials.resolveProviderToken("codex");
+        expect(resolved.token).toBe("codex-file-token");
+        expect(resolved.source).toBe("credentials");
+    });
+    it("still prefers env vars over Codex auth file", async ()=>{
+        process.env.CODEX_ACCESS_TOKEN = "env-token";
+        vi.resetModules();
+        const credentials = await import("../providers/credentials.js");
+        const codex = await import("../providers/codex.js");
+        const authPath = codex.getCodexAuthPath();
+        mkdirSync(dirname(authPath), {
+            recursive: true
+        });
+        writeFileSync(authPath, JSON.stringify({
+            tokens: {
+                access_token: "codex-file-token"
+            }
+        }, null, 2));
+        const resolved = credentials.resolveProviderToken("codex");
+        expect(resolved.token).toBe("env-token");
+        expect(resolved.source).toBe("env");
+        expect(readFileSync(authPath, "utf-8")).toContain("codex-file-token");
+    });
+});